ff-automationv2 2.1.3 → 2.2.2

package/dist/utils/DomExtraction/jsForAttributeInjection.js

@@ -0,0 +1,256 @@
+import { logger } from "../../utils/logger/logData.js";
+export async function getAnnotatedDOM(browser) {
+    return await browser.execute(() => {
+        let nodeIndex = 0;
+        // const xpaths: Record<string, string> = {};
+        // ==========================================================
+        // COVERAGE CHECK
+        // ==========================================================
+        function getCoverageStatus(el) {
+            if (!el || !el.getBoundingClientRect)
+                return "unknown";
+            const rect = el.getBoundingClientRect();
+            if (rect.width === 0 || rect.height === 0)
+                return "false";
+            const testPoints = [
+                [rect.left + 5, rect.top + 5],
+                [rect.right - 5, rect.top + 5],
+                [rect.left + 5, rect.bottom - 5],
+                [rect.right - 5, rect.bottom - 5],
+                [rect.left + rect.width / 2, rect.top + rect.height / 2]
+            ];
+            for (const [x, y] of testPoints) {
+                const topEl = document.elementFromPoint(x, y);
+                if (!topEl)
+                    continue;
+                if (topEl === el || el.contains(topEl))
+                    continue;
+                const style = getComputedStyle(topEl);
+                if (style.pointerEvents === "none" ||
+                    style.opacity === "0" ||
+                    style.visibility === "hidden")
+                    continue;
+                if (el.closest("label")?.contains(topEl))
+                    continue;
+                if (topEl.closest("label")?.contains(el))
+                    continue;
+                if (el.parentElement?.contains(topEl))
+                    continue;
+                const isBlocking = ["BUTTON", "A"].includes(topEl.tagName) ||
+                    topEl.onclick ||
+                    topEl.getAttribute("role") === "button";
+                if (isBlocking)
+                    return "true";
+            }
+            return "false";
+        }
+        // ==========================================================
+        // VISIBILITY CHECK
+        // ==========================================================
+        function isUsable(node) {
+            const s = getComputedStyle(node);
+            if (s.display === "none" ||
+                s.visibility === "hidden" ||
+                s.opacity === "0" ||
+                s.pointerEvents === "none")
+                return false;
+            const rect = node.getBoundingClientRect();
+            if (rect.width === 0 || rect.height === 0)
+                return false;
+            return true;
+        }
+        // ==========================================================
+        // ANNOTATION
+        // ==========================================================
+        function annotate(node) {
+            const s = getComputedStyle(node);
+            node.setAttribute("element-visibility", s.visibility || "");
+            node.setAttribute("element-pointer-events", s.pointerEvents || "");
+            node.setAttribute("element-zindex", s.zIndex || "");
+            if (!isUsable(node)) {
+                node.setAttribute("element-covered", "true");
+                return;
+            }
+            try {
+                node.setAttribute("element-covered", getCoverageStatus(node));
+            }
+            catch {
+                node.setAttribute("element-covered", "unknown");
+            }
+        }
+        // ==========================================================
+        // XPATH (Shadow + iframe safe)
+        // ==========================================================
+        function getXPath(node) {
+            if (!node || node.nodeType !== 1)
+                return "";
+            const segments = [];
+            let current = node;
+            while (current && current.nodeType === 1) {
+                const parent = current.parentNode;
+                if (parent instanceof ShadowRoot) {
+                    const host = parent.host;
+                    const siblings = Array.from(parent.children)
+                        .filter(n => n.tagName === current.tagName);
+                    const index = siblings.indexOf(current) + 1;
+                    segments.unshift("shadow/" +
+                        current.tagName.toLowerCase() +
+                        "[" + index + "]");
+                    current = host;
+                    continue;
+                }
+                let index = 1;
+                if (parent && parent.children) {
+                    const siblings = Array.from(parent.children).filter(n => n.tagName === current.tagName);
+                    index = siblings.indexOf(current) + 1;
+                }
+                segments.unshift(current.tagName.toLowerCase() +
+                    "[" + index + "]");
+                if (!parent || parent.nodeType !== 1)
+                    break;
+                current = parent;
+            }
+            let path = "/" + segments.join("/");
+            if (node.ownerDocument !== document) {
+                const frameEl = node.ownerDocument.defaultView?.frameElement;
+                if (frameEl) {
+                    let framePath = frameEl.getAttribute("ff-xpath");
+                    if (!framePath) {
+                        framePath = getXPath(frameEl);
+                    }
+                    path = framePath + path;
+                }
+            }
+            return path;
+        }
+        // ==========================================================
+        // TRUE NODE WALK (TreeWalker)
+        // ==========================================================
+        function walk(root) {
+            const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null);
+            let node = walker.currentNode;
+            while (node) {
+                if (node.nodeType === 1 &&
+                    !["META", "STYLE", "SCRIPT"]
+                        .includes(node.tagName)) {
+                    const fireId = "Fire-Flink-" + nodeIndex++;
+                    const xpath = getXPath(node);
+                    node.setAttribute("ff-inspect", fireId);
+                    node.setAttribute("ff-xpath", xpath);
+                    // xpaths[fireId] = xpath;
+                    annotate(node);
+                }
+                if (node.shadowRoot) {
+                    walk(node.shadowRoot);
+                }
+                if (node.tagName === "IFRAME") {
+                    try {
+                        const doc = node
+                            .contentDocument;
+                        if (doc?.documentElement) {
+                            walk(doc.documentElement);
+                        }
+                    }
+                    catch {
+                        node.setAttribute("ff-cross-origin", "true");
+                    }
+                }
+                node = walker.nextNode();
+            }
+        }
+        // Start traversal
+        walk(document.documentElement);
+        // ==========================================================
+        // SERIALIZER
+        // ==========================================================
+        function serializeNode(node) {
+            if (node.nodeType === Node.TEXT_NODE)
+                return node.textContent || "";
+            if (node.nodeType !== Node.ELEMENT_NODE)
+                return "";
+            const el = node;
+            const tag = el.tagName.toLowerCase();
+            let html = "<" + tag;
+            for (const attr of Array.from(el.attributes)) {
+                if (attr.name === "srcdoc")
+                    continue;
+                html +=
+                    " " + attr.name +
+                        "=\"" +
+                        attr.value.replace(/"/g, "&quot;") +
+                        "\"";
+            }
+            html += ">";
+            if (el.shadowRoot) {
+                html += "<!--#shadow-root-->";
+                el
+                    .shadowRoot
+                    .childNodes
+                    .forEach(child => {
+                    html += serializeNode(child);
+                });
+                html += "<!--#/shadow-root-->";
+            }
+            if (tag === "iframe" &&
+                el.getAttribute("ff-cross-origin") !== "true") {
+                try {
+                    const doc = el
+                        .contentDocument;
+                    if (doc) {
+                        html += serializeNode(doc.documentElement);
+                    }
+                }
+                catch (error) {
+                    logger.error("Attribute injection failed", error);
+                }
+            }
+            el.childNodes.forEach(child => {
+                html += serializeNode(child);
+            });
+            html += "</" + tag + ">";
+            return html;
+        }
+        return {
+            dom: "<!DOCTYPE html>\n" +
+                serializeNode(document.documentElement)
+            // selectors: xpaths
+        };
+    });
+}
+import { DOMParser, XMLSerializer } from "@xmldom/xmldom";
+export async function getAnnotatedDOMForMobile(driver) {
+    try {
+        // Wait like Python sleep(2)
+        await driver.pause(2000);
+        const pageSource = await driver.getPageSource();
+        if (!pageSource) {
+            throw new Error("Unable to capture DOM");
+        }
+        // Parse XML DOM
+        const parser = new DOMParser();
+        const xmlDoc = parser.parseFromString(pageSource, "text/xml");
+        const allElements = xmlDoc.getElementsByTagName("*");
+        let index = 1;
+        for (const element of Array.from(allElements)) {
+            element.setAttribute("FF-inspecter", `Fire-Flink-${index}`);
+            index++;
+        }
+        // Convert DOM back to string
+        const serializer = new XMLSerializer();
+        let annotatedXML = serializer.serializeToString(xmlDoc);
+        // Preserve XML declaration if present
+        if (pageSource.trim().startsWith("<?xml")) {
+            const declarationEnd = pageSource.indexOf("?>");
+            if (declarationEnd !== -1) {
+                const declaration = pageSource.substring(0, declarationEnd + 2).trim();
+                annotatedXML = `${declaration}\n${annotatedXML}`;
+            }
+        }
+        return {
+            dom: annotatedXML
+        };
+    }
+    catch (error) {
+        throw new Error(`Unable to annotate DOM: ${error.message}`, { cause: error });
+    }
+}

package/dist/utils/InstancesDetails/getInstancesInfo.d.ts

@@ -0,0 +1 @@
+export declare function getAiInstanceInfo(responseObject: any): Record<string, string>;

package/dist/utils/InstancesDetails/getInstancesInfo.js

@@ -0,0 +1,9 @@
+export function getAiInstanceInfo(responseObject) {
+    return {
+        serviceProvider: responseObject.serviceProvider,
+        apiKey: responseObject.instanceDetails.apiKey,
+        apiUrl: responseObject.instanceDetails.apiUrl,
+        visionApiKey: responseObject.instanceDetails.visionApiKey ?? "c2stcHJvai1zODVFenVfWkdnVUxoT1dNVVhRTmxuUW9ELUpnS3dEMGpvSmJZcDE0YWd4ZEZ3MWM5Mlh5NnlLUFJpYk1XckUtTTRTV1dzcHc0MFQzQmxia0ZKekVkWXRMTm1rWWlJQVRYTUwyTWhhTU5NR3FUWjhZekJYZHdkTHc0MHRVT084d0t6N19wRENYSERSX0NsSVRtTVpjR3VsY3ZlNEE=",
+        model: responseObject.model,
+    };
+}

package/dist/utils/alertPopup/isAlertPresent.d.ts

@@ -0,0 +1,2 @@
+import { IAlertChecker } from "./isAlertPresentInterface";
+export declare const isAlertPresent: IAlertChecker;

package/dist/utils/alertPopup/isAlertPresent.js

@@ -0,0 +1,11 @@
+export const isAlertPresent = async (driver, timeout = 0) => {
+    try {
+        if (!driver)
+            return false;
+        await driver.waitUntil(async () => await driver.isAlertOpen(), { timeout });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};

package/dist/utils/alertPopup/isAlertPresentInterface.d.ts

@@ -0,0 +1,3 @@
+export interface IAlertChecker {
+    (driver: WebdriverIO.Browser, timeout?: number): Promise<boolean>;
+}

package/dist/utils/alertPopup/isAlertPresentInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/helpers/enterActionHelper.d.ts

@@ -0,0 +1,10 @@
+interface EnterActionResult {
+    ffNumber: number;
+    xpathPath: string;
+}
+interface EnterActionResultMob {
+    xpathPath: string;
+}
+export declare const enterActionHelper: (pageDOM: string, ffNumber: string) => EnterActionResult;
+export declare function enterActionHelperMob(annotatedDom: string, num: string): EnterActionResultMob;
+export {};

package/dist/utils/helpers/enterActionHelper.js

@@ -0,0 +1,110 @@
+import { JSDOM } from "jsdom";
+import { DOMParser } from "@xmldom/xmldom";
+import { getFFIndexAndXPath } from "./xpathcreation.js";
+import { logger } from "../logger/logData.js";
+import xpath from "xpath";
+export const enterActionHelper = (pageDOM, ffNumber) => {
+    //  Extract numeric part
+    const match = ffNumber.match(/\d+$/);
+    let numericFF = match ? parseInt(match[0], 10) : 0;
+    const parser = new JSDOM(pageDOM);
+    const doc = parser.window.document;
+    const isEditable = (el) => {
+        if (!el)
+            return false;
+        const tag = el.tagName?.toLowerCase();
+        return (["input", "textarea", "select"].includes(tag) ||
+            el.getAttribute("contenteditable") === "true");
+    };
+    const getXPath = (el) => {
+        return el?.getAttribute("ff-xpath") || "";
+    };
+    const element = doc.querySelector(`[ff-inspect="Fire-Flink-${numericFF}"]`);
+    if (!element) {
+        return { ffNumber: numericFF, xpathPath: "" };
+    }
+    let xpathPath = "";
+    //  Current element editable
+    if (isEditable(element)) {
+        xpathPath = getXPath(element);
+    }
+    else {
+        // Search editable child
+        let editableChild = null;
+        for (const child of Array.from(element.querySelectorAll("*"))) {
+            if (isEditable(child)) {
+                editableChild = child;
+                break;
+            }
+        }
+        if (editableChild) {
+            xpathPath = getXPath(editableChild);
+        }
+        else {
+            // Try next 10 FF elements
+            for (let offset = 1; offset <= 10; offset++) {
+                const nextNum = numericFF + offset;
+                const nextTarget = doc.querySelector(`[ff-inspect="Fire-Flink-${nextNum}"]`);
+                if (isEditable(nextTarget)) {
+                    numericFF = nextNum;
+                    xpathPath = getXPath(nextTarget);
+                    break;
+                }
+            }
+            // Final fallback
+            if (!xpathPath) {
+                xpathPath = getXPath(element);
+            }
+        }
+    }
+    // console.log("xpathPath", xpathPath);
+    return {
+        ffNumber: numericFF,
+        xpathPath
+    };
+};
+export function enterActionHelperMob(annotatedDom, num) {
+    const parser = new DOMParser();
+    const match = num.match(/\d+$/);
+    const numericFF = match ? parseInt(match[0], 10) : 0;
+    const xmlDoc = parser.parseFromString(annotatedDom, "text/xml");
+    const xpathQuery = `//*[@FF-inspecter='${num}']`;
+    const nodes = xpath.select(xpathQuery, xmlDoc);
+    const element = nodes.length ? nodes[0] : null;
+    let xpathPath = "";
+    if (element) {
+        const elementClass = (element.getAttribute("class") || "").toLowerCase();
+        if (elementClass.includes("edittext") ||
+            elementClass.includes("autocompletetextview")) {
+            xpathPath = getFFIndexAndXPath(annotatedDom, num);
+        }
+        else {
+            // check immediate children
+            const children = Array.from(element.children);
+            let editableChild = null;
+            for (const child of children) {
+                const childClass = (child.getAttribute("class") || "").toLowerCase();
+                if (childClass.includes("edittext") ||
+                    childClass.includes("autocompletetextview")) {
+                    editableChild = child;
+                    break;
+                }
+            }
+            if (editableChild) {
+                const childNum = editableChild.getAttribute("FF-inspecter")?.split("-").pop();
+                if (childNum) {
+                    xpathPath = getFFIndexAndXPath(annotatedDom, `Fire-Flink-${childNum}`);
+                }
+            }
+            else {
+                xpathPath = getFFIndexAndXPath(annotatedDom, num);
+            }
+        }
+    }
+    else {
+        logger.info(`No element found for ffNumber: ${numericFF} in MOB_Enter action`);
+    }
+    return {
+        xpathPath
+    };
+}

package/dist/utils/helpers/imageUtils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Ensures that a base64 string or Buffer has the correct data URI prefix for PNG images.
+ * @param image The base64 string or Buffer.
+ * @returns The base64 string with the `data:image/png;base64,` prefix.
+ */
+export declare function formatImageBase64(image: string | Buffer): string;

package/dist/utils/helpers/imageUtils.js

@@ -0,0 +1,11 @@
+/**
+ * Ensures that a base64 string or Buffer has the correct data URI prefix for PNG images.
+ * @param image The base64 string or Buffer.
+ * @returns The base64 string with the `data:image/png;base64,` prefix.
+ */
+export function formatImageBase64(image) {
+    if (!image)
+        return "";
+    const base64 = Buffer.isBuffer(image) ? image.toString("base64") : image;
+    return base64.startsWith("data:") ? base64 : `data:image/png;base64,${base64}`;
+}

package/dist/utils/helpers/sameActionsHelper.d.ts

@@ -0,0 +1 @@
+export declare const sameActionHelper: Record<string, string>;

package/dist/utils/helpers/sameActionsHelper.js

@@ -0,0 +1,52 @@
+export const sameActionHelper = {
+    MOB_Tap: "Click",
+    MOB_Enter: "SendKeys",
+    MOB_VerifyElementIsDisplayed: "VerifyElementIsDisplayed",
+    MOB_VerifyElementIsEnabled: "VerifyElementIsEnabled",
+    MOB_VerifyXLocationOfAndroidElement: "VerifyXLocationOfElement",
+    MOB_VerifyElementIsSelected: "VerifyElementIsSelected",
+    MOB_VerifyYLocationOfAndroidElement: "VerifyYLocationOfElement",
+    MOB_VerifyWidthOfElement: "VerifyWidthOfElement",
+    MOB_WaitAndClick: "WaitAndClick",
+    MOB_GetScreenshot: "GetScreenshot",
+    MOB_VerifyText: "VerifyText",
+    MOB_VerifyElementNotContainsText: "VerifyElementNotContainsText",
+    MOB_VerifyIfXAndYCoordinateOfElement: "VerifyIfXAndYCoordinateOfElement",
+    MOB_VerifyPartialAttributeValue: "VerifyPartialAttributeValue",
+    MOB_VerifyElementIsClickable: "VerifyElementIsClickable",
+    MOB_VerifyElementIsDisabled: "VerifyElementIsDisabled",
+    MOB_GetImplicitTimeOut: "GetImplicitTimeOut",
+    MOB_GetDriverInstance: "GetDriverInstance",
+    MOB_GetCurrentWindowHandle: "GetCurrentWindowHandle",
+    MOB_GetTagName: "GetTagName",
+    MOB_GetScreenshotAs: "GetScreenshotAs",
+    MOB_GetX: "GetXLocationOfWebElement",
+    MOB_GetLocation: "GetLocation",
+    MOB_GetY: "GetYLocationOfWebElement",
+    MOB_GetRect: "GetRect",
+    MOB_GetText: "GetText",
+    MOB_GetSize: "GetSize",
+    MOB_GetAttribute: "GetAttribute",
+    MOB_Clear: "Clear",
+    MOB_DoubleTap: "DoubleClick",
+    MOB_TapNTimes: "ClickNTimes",
+    MOB_VerifyPartialText: "VerifyPartialText",
+    MOB_VerifyAttributeValue: "VerifyAttributeValue",
+    MOB_ClearThenEnterInput: "ClearThenEnterInput",
+    MOB_EnterDataAndPressKey: "EnterDataAndPressKey",
+    MOB_WaitAndSendKeys: "WaitAndSendKeys",
+    MOB_VerifyHeightOfElement: "VerifyHeightOfWebElement",
+    MOB_WaitTillPresenceOfElement: "WaitTillPresenceOfElement",
+    MOB_WaitTillPresenceOfAllElements: "WaitTillPresenceOfAllElements",
+    MOB_WaitTillAttributeOfElementIsString: "WaitTillAttributeOfElementIsString",
+    MOB_EnterUrl: "EnterUrl",
+    MOB_SetClipBoardText: "SetClipBoardText",
+    MOB_PressAnyKeyNTimes: "PressAnyKeyNTimes",
+    MOB_FindElements: "FindElements",
+    MOB_WaitTillElementIsClickable: "WaitTillElementIsClickable",
+    MOB_CheckIfElementIsDisplayed: "CheckIfElementIsDisplayed",
+    MOB_PressAnyKey: "PressAnyKey",
+    MOB_WaitTillElementHasText: "WaitTillElementHasText",
+    MOB_WaitTillElementContainsText: "WaitTillElementContainsText",
+    MOB_PressEnterKey: "PressEnterKey"
+};

package/dist/utils/helpers/xpathcreation.d.ts

@@ -0,0 +1 @@
+export declare function getFFIndexAndXPath(annotatedDom: string, fireflinkIndex: string): string;

package/dist/utils/helpers/xpathcreation.js

@@ -0,0 +1,39 @@
+import { DOMParser } from "@xmldom/xmldom";
+import xpath from "xpath";
+// import { logger } from "../logger/logData.js";
+export function getFFIndexAndXPath(annotatedDom, fireflinkIndex) {
+    try {
+        const parser = new DOMParser();
+        const xmlDoc = parser.parseFromString(annotatedDom, "text/xml");
+        const xpathQuery = `//*[@FF-inspecter='${fireflinkIndex}']`;
+        const nodes = xpath.select(xpathQuery, xmlDoc);
+        const element = nodes.length ? nodes[0] : null;
+        function buildXPath(node) {
+            if (node.nodeType !== 1)
+                return "";
+            const parts = [];
+            while (node && node.nodeType === 1) {
+                let index = 1;
+                let sibling = node.previousSibling;
+                while (sibling) {
+                    if (sibling.nodeType === 1 &&
+                        sibling.tagName === node.tagName) {
+                        index++;
+                    }
+                    sibling = sibling.previousSibling;
+                }
+                parts.unshift(`${node.tagName}[${index}]`);
+                node = node.parentNode;
+            }
+            return "/" + parts.join("/");
+        }
+        let xpathPath = "";
+        if (element) {
+            xpathPath = buildXPath(element);
+        }
+        return xpathPath;
+    }
+    catch (error) {
+        throw new Error("Error in getFFIndexAndXPath", { cause: error });
+    }
+}

package/dist/utils/iframesExtraction/findElementUsingFF.d.ts

@@ -0,0 +1,2 @@
+import { IFindElementUsingFF } from "./iframeInterface.js";
+export declare const findElementUsingFF: (args: IFindElementUsingFF) => Promise<void>;

package/dist/utils/iframesExtraction/findElementUsingFF.js

@@ -0,0 +1,32 @@
+import { switchToIframeByMeta } from "./switchToIframeByMeta.js";
+export const findElementUsingFF = async (args) => {
+    await args.driver.switchToFrame(null);
+    const usedElementNames = [];
+    for (const frameMeta of args.frames) {
+        const xpathUsed = await switchToIframeByMeta(args.driver, frameMeta);
+        if (xpathUsed) {
+            let finalElementName = args.elementName;
+            if (finalElementName) {
+                const baseName = finalElementName;
+                let newName = baseName;
+                let count = 0;
+                while (usedElementNames.includes(newName)) {
+                    count++;
+                    newName = `${baseName}_${count}`;
+                }
+                finalElementName = newName;
+                usedElementNames.push(finalElementName);
+            }
+            args.scriptDataAppender.add(async () => ({
+                nlpName: 'SwitchToFrameByFrameElement',
+                stepInputs: [],
+                elementsData: [{
+                        name: finalElementName,
+                        type: args.elementType,
+                        locators: [{ name: "xpath", value: xpathUsed }],
+                        platform: args.platform
+                    }]
+            }));
+        }
+    }
+};

package/dist/utils/iframesExtraction/iframeInterface.d.ts

@@ -0,0 +1,17 @@
+import { ScriptDataAppender } from "../../fireflinkData/fireflinkScript/scriptGenrationData";
+export interface FrameMeta {
+    id?: string;
+    name?: string;
+    title?: string;
+    aria?: string;
+    src?: string;
+}
+export interface IFindElementUsingFF {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    frames: FrameMeta[];
+    scriptDataAppender: ScriptDataAppender;
+    elementName: string;
+    elementType: string;
+    platform: string;
+}

package/dist/utils/iframesExtraction/iframeInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/iframesExtraction/switchToIframeByMeta.d.ts

@@ -0,0 +1,2 @@
+import { FrameMeta } from "./iframeInterface.js";
+export declare function switchToIframeByMeta(driver: WebdriverIO.Browser, frameMeta: FrameMeta): Promise<string | null>;

package/dist/utils/iframesExtraction/switchToIframeByMeta.js

@@ -0,0 +1,22 @@
+export async function switchToIframeByMeta(driver, frameMeta) {
+    const selectors = [
+        frameMeta.id && `//*[@id='${frameMeta.id}']`,
+        frameMeta.name && `//*[@name='${frameMeta.name}']`,
+        frameMeta.title && `//iframe[@title='${frameMeta.title}']`,
+        frameMeta.aria && `//iframe[@aria-label='${frameMeta.aria}']`,
+        frameMeta.src && `//iframe[contains(@src,'${frameMeta.src}')]`,
+    ].filter(Boolean);
+    for (const selector of selectors) {
+        try {
+            const iframe = await driver.$(selector);
+            if (await iframe.isExisting()) {
+                await driver.switchToFrame(iframe);
+                return selector;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}

package/dist/utils/javascript/jsFindElement.d.ts

@@ -0,0 +1 @@
+export declare const Find_element_by_ff_js_script = "\n  const target = arguments[0];\n  const callback = arguments[arguments.length - 1];\n\n  const MAX_WAIT = 2000;\n  const INTERVAL = 50;\n  const start = Date.now();\n\n  // ---------------- FINDER ----------------\n  function findByFfInspect(root) {\n      const visited = new Set();\n      const stack = [{ node: root, frames: [], currentDoc: root }];\n\n      while (stack.length > 0) {\n          const { node, frames, currentDoc } = stack.pop();\n          if (!node) continue;\n\n          if (\n              node.nodeType === Node.DOCUMENT_NODE ||\n              node.nodeType === Node.DOCUMENT_FRAGMENT_NODE\n          ) {\n              if (visited.has(node)) continue;\n              visited.add(node);\n          }\n\n          if (node.nodeType === Node.ELEMENT_NODE) {\n\n              if (node.getAttribute && node.getAttribute(\"ff-inspect\") === target) {\n                  return { node, frames, iframe_dom: currentDoc };\n              }\n\n              // Shadow DOM\n              if (node.shadowRoot) {\n                  stack.push({\n                      node: node.shadowRoot,\n                      frames,\n                      currentDoc\n                  });\n              }\n\n              // Iframe traversal\n              if (node.tagName === \"IFRAME\") {\n                  try {\n                      const doc = node.contentDocument || node.contentWindow?.document;\n                      if (doc) {\n                          const meta = {\n                              id: node.id || null,\n                              name: node.getAttribute(\"name\") || null,\n                              title: node.getAttribute(\"title\") || null,\n                              aria: node.getAttribute(\"aria-label\") || null,\n                              src: node.getAttribute(\"src\") || null,\n                          };\n\n                          stack.push({\n                              node: doc,\n                              frames: [...frames, meta],\n                              currentDoc: doc\n                          });\n                      }\n                  } catch (e) {}\n              }\n\n              const kids = node.children || node.childNodes;\n              for (let i = kids.length - 1; i >= 0; i--) {\n                  stack.push({ node: kids[i], frames, currentDoc });\n              }\n          }\n\n          else if (\n              node.nodeType === Node.DOCUMENT_NODE ||\n              node.nodeType === Node.DOCUMENT_FRAGMENT_NODE\n          ) {\n              const kids = node.childNodes;\n              for (let i = kids.length - 1; i >= 0; i--) {\n                  stack.push({ node: kids[i], frames, currentDoc });\n              }\n          }\n      }\n\n      return null;\n  }\n\n  // ---------------- CLICKABILITY ----------------\n  function isClickable(el) {\n      if (!el || el.nodeType !== Node.ELEMENT_NODE) return false;\n      const tag = el.tagName.toLowerCase();\n      if (tag === \"button\" || tag === \"a\") return true;\n      if (el.getAttribute(\"role\") === \"button\") return true;\n      if (tag === \"input\") {\n          const t = (el.getAttribute(\"type\") || \"\").toLowerCase();\n          return t === \"button\" || t === \"submit\";\n      }\n      return false;\n  }\n\n  function findClickableInside(root) {\n      const queue = [root];\n      while (queue.length) {\n          const node = queue.shift();\n          if (isClickable(node)) return node;\n          const kids = node.children || node.childNodes;\n          for (let k of kids) queue.push(k);\n      }\n      return null;\n  }\n\n  // ---------------- XPATH BUILDER ----------------\n  function buildXPath(el) {\n      if (!el) return null;\n\n      if (el.id) return \"//*[@id=\\\"\" + el.id + \"\\\"]\";\n\n      const name = el.getAttribute(\"name\");\n      if (name) return \"//*[@name=\\\"\" + name + \"\\\"]\";\n\n      const text = el.textContent && el.textContent.trim();\n      if (text && text.length < 50) {\n          const escaped = text.replace(/\"/g, '\\\"');\n          const xp = \"//*[text()=\\\"\" + escaped + \"\\\"]\";\n          try {\n              const n = document.evaluate(xp, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);\n              if (n.singleNodeValue === el) return xp;\n          } catch {}\n      }\n\n      const parts = [];\n      let node = el;\n\n      while (node && node.nodeType === Node.ELEMENT_NODE) {\n          let idx = 1;\n          let sib = node.previousSibling;\n          while (sib) {\n              if (sib.nodeType === Node.ELEMENT_NODE && sib.nodeName === node.nodeName) idx++;\n              sib = sib.previousSibling;\n          }\n          parts.unshift(node.nodeName.toLowerCase() + \"[\" + idx + \"]\");\n          node = node.parentNode instanceof ShadowRoot ? node.parentNode.host : node.parentNode;\n      }\n\n      return \"/\" + parts.join(\"/\");\n  }\n\n  // ---------------- WAIT LOOP ----------------\n  (function attempt() {\n      const found = findByFfInspect(document);\n\n      if (!found) {\n          if (Date.now() - start > MAX_WAIT) {\n              return callback({ success: false, reason: \"timeout\" });\n          }\n          return setTimeout(attempt, INTERVAL);\n      }\n\n      let targetNode = found.node;\n      if (!isClickable(targetNode)) {\n          const inside = findClickableInside(targetNode);\n          if (inside) targetNode = inside;\n      }\n\n      const xpath_if = buildXPath(targetNode);\n\n      return callback({\n          success: true,\n          xpath_if,\n          frames: found.frames,\n          iframe_dom_html: found.iframe_dom?.documentElement?.outerHTML || null\n      });\n  })();\n";