ff-automationv2 2.2.0 → 2.2.5

package/dist/utils/DomExtraction/jsForAttributeInjection.js

@@ -0,0 +1,258 @@
+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(1000);
+        const startTime = Date.now();
+        const pageSource = await driver.getPageSource();
+        logger.info(`Page source captured in ${Date.now() - startTime}ms`);
+        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/browserCap/capability.d.ts

@@ -0,0 +1,23 @@
+import { Browser } from "../../core/types/browserType";
+export declare function getCapabilities(browserName: Browser): {
+    'goog:chromeOptions'?: {
+        args: string[];
+    } | undefined;
+    browserName: string;
+    "wdio:enforceWebDriverClassic": boolean;
+} | {
+    'moz:firefoxOptions'?: {
+        args: string[];
+    } | undefined;
+    browserName: string;
+    "wdio:enforceWebDriverClassic": boolean;
+} | {
+    'ms:edgeOptions'?: {
+        args: string[];
+    } | undefined;
+    browserName: string;
+    "wdio:enforceWebDriverClassic": boolean;
+} | {
+    browserName: string;
+    "wdio:enforceWebDriverClassic": boolean;
+};

package/dist/utils/browserCap/capability.js

@@ -0,0 +1,37 @@
+export function getCapabilities(browserName) {
+    const isLinux = process.platform === 'linux';
+    const browserCapabilities = {
+        chrome: {
+            browserName: 'chrome',
+            "wdio:enforceWebDriverClassic": true,
+            ...(isLinux && {
+                'goog:chromeOptions': {
+                    args: ['--ozone-platform=x11']
+                },
+            })
+        },
+        firefox: {
+            browserName: 'firefox',
+            "wdio:enforceWebDriverClassic": true,
+            ...(isLinux && {
+                'moz:firefoxOptions': {
+                    args: ['--ozone-platform=x11']
+                }
+            })
+        },
+        edge: {
+            browserName: 'MicrosoftEdge',
+            "wdio:enforceWebDriverClassic": true,
+            ...(isLinux && {
+                'ms:edgeOptions': {
+                    args: ['--ozone-platform=x11']
+                }
+            })
+        },
+        safari: {
+            browserName: 'safari',
+            "wdio:enforceWebDriverClassic": true
+        }
+    };
+    return browserCapabilities[browserName];
+}

package/dist/utils/cloudConfig/cloudPath.d.ts

@@ -0,0 +1,2 @@
+import { CloudConfig } from "../../core/interfaces/cloudConfigInterface";
+export declare function getPath(cloudConfig: CloudConfig): string;

package/dist/utils/cloudConfig/cloudPath.js

@@ -0,0 +1,3 @@
+export function getPath(cloudConfig) {
+    return `/${cloudConfig.path}?accessKey=${cloudConfig.accessKey}&licenseId=${cloudConfig.licenseId}&projectName=${cloudConfig.projectName}/`;
+}

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,121 @@
+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) {
+    try {
+        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 = "";
+        const getElementChildren = (node) => {
+            return Array.from(node?.childNodes || []).filter((n) => n.nodeType === 1);
+        };
+        if (element) {
+            const elementClass = (element.getAttribute("class") || "").toLowerCase();
+            if (elementClass.includes("edittext") ||
+                elementClass.includes("autocompletetextview")) {
+                const result = getFFIndexAndXPath(annotatedDom, num);
+                xpathPath = result.xpathPath;
+            }
+            else {
+                const children = getElementChildren(element);
+                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) {
+                        const result = getFFIndexAndXPath(annotatedDom, `Fire-Flink-${childNum}`);
+                        xpathPath = result.xpathPath;
+                    }
+                }
+                else {
+                    const result = getFFIndexAndXPath(annotatedDom, num);
+                    xpathPath = result.xpathPath;
+                }
+            }
+        }
+        else {
+            logger.info(`No element found for ffNumber: ${numericFF} in MOB_Enter action`);
+        }
+        return {
+            xpathPath
+        };
+    }
+    catch (error) {
+        logger.error(`Error in enterActionHelperMob: ${error}`);
+        throw error;
+    }
+}

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,6 @@
+interface FFResult {
+    xpathPath: string;
+    ffInspector?: string;
+}
+export declare function getFFIndexAndXPath(annotatedDom: string, fireflinkIndex: string): FFResult;
+export {};

package/dist/utils/helpers/xpathcreation.js

@@ -0,0 +1,56 @@
+import { DOMParser } from "@xmldom/xmldom";
+import xpath from "xpath";
+export function getFFIndexAndXPath(annotatedDom, fireflinkIndex) {
+    try {
+        const parser = new DOMParser();
+        const xmlDoc = parser.parseFromString(annotatedDom, "text/xml");
+        let xpathQuery = "";
+        let isBounds = false;
+        // 🔥 Detect input type
+        if (fireflinkIndex.startsWith("[")) {
+            isBounds = true;
+            xpathQuery = `//*[@bounds='${fireflinkIndex}' and @clickable='true']`;
+        }
+        else {
+            xpathQuery = `//*[@FF-inspecter='${fireflinkIndex}']`;
+        }
+        const nodes = xpath.select(xpathQuery, xmlDoc);
+        const element = nodes.length ? nodes[0] : null;
+        if (!element) {
+            return { xpathPath: "" };
+        }
+        const ffInspector = element.getAttribute("FF-inspecter") || "";
+        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("/");
+        }
+        const xpathPath = buildXPath(element);
+        if (isBounds) {
+            return {
+                xpathPath,
+                ffInspector
+            };
+        }
+        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>;