ff-automationv2 2.2.28 → 2.2.30

package/dist/fireflinkData/fireflinkLocators/parser/getElementsFromHTML.js

@@ -0,0 +1,573 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAiElementsFromHTML = void 0;
+const xpath_js_1 = require("../utils/xpath.js");
+const cssSelector_js_1 = require("../utils/cssSelector.js");
+const jsdom_1 = require("jsdom");
+const xpathHelpers_js_1 = require("../utils/xpathHelpers.js");
+const domSanitizer_js_1 = require("../../../utils/helpers/domSanitizer.js");
+const logData_js_1 = require("../../../utils/logger/logData.js");
+const getAiElementFromCssSelector = (docmt, selector) => {
+    try {
+        const found = docmt.querySelector(selector);
+        if (found)
+            return found;
+    }
+    catch (error) {
+        console.error("Invalid CSS selector:", selector, error);
+        return null;
+    }
+    return getAiElementFromShadowRoot(docmt.body, selector);
+};
+const isAiCssSelectorLocator = (locator) => {
+    return locator.name?.toLowerCase().includes("cssselector") ?? false;
+};
+const getAiElementFromShadowRoot = (el, selector) => {
+    const shadowRoot = el.shadowRoot;
+    if (shadowRoot && !selector.includes("dynamic")) {
+        return shadowRoot.querySelector(selector);
+    }
+    const elements = Array.from(el.querySelectorAll("*"));
+    try {
+        for (let i = 0; i < elements.length; i++) {
+            if (elements[i].shadowRoot) {
+                const { shadowRoot } = elements[i];
+                if (shadowRoot) {
+                    const nestedElement = getAiElementFromShadowRoot(shadowRoot, selector);
+                    if (nestedElement) {
+                        return nestedElement;
+                    }
+                    if (shadowRoot && !selector.includes("dynamic")) {
+                        return shadowRoot.querySelector(selector);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        logData_js_1.logger.error(error);
+    }
+    return null;
+};
+const getaiId = (element) => {
+    return element?.id || null;
+};
+const getAiClassName = (element) => {
+    const svgClass = element.ownerDocument?.defaultView?.SVGElement;
+    if (svgClass && element instanceof svgClass) {
+        const cls = element.className;
+        if (typeof cls === "string") {
+            return cls;
+        }
+        return cls?.baseVal || null;
+    }
+    return element.getAttribute("class") || element.className || null;
+};
+const getAiVisibleText = (element) => {
+    return element.textContent?.trim() || null;
+};
+const getAiName = (element) => {
+    if (element.hasAttribute("name")) {
+        const attrValue = element.getAttribute("name");
+        const name = `${attrValue}`;
+        return name || null;
+    }
+    return null;
+};
+const aiRelations = [
+    "/preceding-sibling",
+    "/following-sibling",
+    "/parent",
+    "/descendant",
+    "/ancestor",
+    "/self",
+    "/ancestor-or-self",
+    "/child",
+    "/preceding",
+    "/following"
+];
+function getAiElementFromXPath(docmt, xpath, platform) {
+    if (platform !== "web") {
+        const ffMatch = xpath.match(/^\/\/\*\[@FF-inspecter="([^"]+)"\]$/);
+        if (ffMatch) {
+            return docmt.querySelector(`[FF-inspecter="${ffMatch[1]}"]`);
+        }
+    }
+    return (0, xpathHelpers_js_1.evaluateAiXPath)(xpath, docmt, "first").singleNodeValue;
+}
+function checkAiReferenceElementIsValid(locator, relation, docmt) {
+    if (locator.includes(relation)) {
+        const locatotSplitArray = locator.split(relation);
+        const sourceLoc = locatotSplitArray[0].trim();
+        if (!locator.includes("dynamic")) {
+            const sourceElement = (0, xpathHelpers_js_1.evaluateAiXPath)(sourceLoc, docmt, "first").singleNodeValue;
+            if (sourceElement) {
+                const completeElement = (0, xpathHelpers_js_1.evaluateAiXPath)(locator, docmt, "first").singleNodeValue;
+                let relativeXpath;
+                if (completeElement) {
+                    relativeXpath = locator;
+                    return relativeXpath;
+                }
+                else {
+                    console.error("Complete Locator is Invalid:", locator);
+                    relativeXpath = locator;
+                    return relativeXpath;
+                }
+            }
+            else {
+                console.error("Source Locator Not Found:", sourceLoc);
+            }
+        }
+    }
+    return null;
+}
+const getAiElementsFromHTML = (record, htmlString, platform) => {
+    const virtualConsole = new jsdom_1.VirtualConsole();
+    let docmt;
+    if (platform === "web") {
+        try {
+            const dom = new jsdom_1.JSDOM((0, domSanitizer_js_1.sanitizeWebDom)(htmlString), {
+                resources: "usable",
+                runScripts: "outside-only",
+                pretendToBeVisual: true,
+                virtualConsole,
+                includeNodeLocations: true,
+            });
+            docmt = dom.window.document;
+        }
+        catch (e) {
+            logData_js_1.logger.error("Unable to parse HTML : ", e.message);
+            return null;
+        }
+    }
+    else {
+        try {
+            const dom = new jsdom_1.JSDOM(htmlString, {
+                contentType: "text/xml",
+                virtualConsole,
+            });
+            docmt = dom.window.document;
+        }
+        catch (e) {
+            logData_js_1.logger.error("Unable to parse XML : ", e.message);
+            return null;
+        }
+    }
+    const aiElementsToRemove = docmt.querySelectorAll("script, style, link[rel='stylesheet'], meta, noscript, embed, object, param, source");
+    if (aiElementsToRemove) {
+        aiElementsToRemove.forEach((tag) => {
+            tag.remove();
+        });
+    }
+    const finalAiLocatorsSet = new Set();
+    const finalLocators = [];
+    function createAiLocator(base, overrides = {}) {
+        const newLocator = {
+            name: overrides.name ?? base?.name,
+            type: overrides.type ?? base?.type,
+            value: overrides.value ?? base?.value,
+            reference: overrides.reference ?? base?.reference,
+            status: overrides.status ?? base?.status,
+            isRecorded: overrides.isRecorded ?? base?.isRecorded
+        };
+        newLocator.isAiRecorded = "Y";
+        pushAiUniqueLocator(newLocator);
+    }
+    function resolveAiElement(ctx, locator, selector) {
+        if (isAiCssSelectorLocator(locator)) {
+            return getAiElementFromCssSelector(ctx, selector);
+        }
+        else if (locator.name.includes("id") || selector.startsWith("#")) {
+            return ctx.querySelector("#" + (0, xpathHelpers_js_1.escapeAttrValue)(selector));
+        }
+        else if (locator.name.includes("className") || selector.startsWith(".")) {
+            return ctx.querySelector("." + selector);
+        }
+        else if (locator.name === "name") {
+            const safeName = (0, xpathHelpers_js_1.escapeAttrValue)(selector);
+            return ctx.querySelector(`[name="${safeName}"]`);
+        }
+        else if (locator.name === "tagName") {
+            return ctx.querySelector(selector);
+        }
+        else if (locator.name === "linkText") {
+            return (Array.from(ctx.querySelectorAll("a")).find((a) => a.textContent?.trim() === selector) || null);
+        }
+        else if (locator.name === "partialLinkText") {
+            return (Array.from(ctx.querySelectorAll("a")).find((a) => a.textContent?.includes(selector)) || null);
+        }
+        else if ((locator.name.includes("xpath") || selector.startsWith("//")) &&
+            !locator.type.match("dynamic")) {
+            const el = getAiElementFromXPath(ctx, selector, platform);
+            if (el) {
+                createAiLocator(locator, {
+                    value: selector,
+                    isRecorded: "N"
+                });
+            }
+            return el;
+        }
+        else {
+            return ctx.querySelector(selector);
+        }
+    }
+    function aiFindInIframes(docmt, locator, selector) {
+        const iframes = docmt.querySelectorAll("iframe");
+        for (const iframe of iframes) {
+            try {
+                const iframeDoc = iframe.contentDocument || iframe.contentWindow?.document;
+                if (!iframeDoc)
+                    continue;
+                const el = resolveAiElement(iframeDoc, locator, selector);
+                if (el)
+                    return el;
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    function pushAiUniqueLocator(obj) {
+        const key = `${obj.name}:${obj.value}`;
+        if (!finalAiLocatorsSet.has(key)) {
+            finalAiLocatorsSet.add(key);
+            finalLocators.push(obj);
+        }
+    }
+    /** Locator Value Cleaner (Handles Special Scenarios) **/
+    const cleanAiLocatorValue = (val, type) => {
+        if (!val)
+            return null;
+        if (val.toLowerCase().includes('ff-inspecter') || val.toLowerCase().includes('ff-inspect')) {
+            return null;
+        }
+        let cleaned = val.trim();
+        // Return null for empty or literal "null"
+        if (platform === "web") {
+            if (!cleaned || cleaned.toLowerCase() === "null")
+                return null;
+        }
+        else {
+            if (!cleaned || cleaned === "null")
+                return null;
+        }
+        // Unescape any escaped quotes
+        cleaned = cleaned.replace(/\\"/g, '"').replace(/\\'/g, "'");
+        // Remove surrounding single or double quotes
+        cleaned = cleaned.replace(/^['"](.+?)['"]$/, "$1");
+        // Replace double single quotes with a single quote inside XPath
+        cleaned = cleaned.replace(/''/g, "'");
+        // Normalize double quotes in XPath attribute selectors [@id="" -> [@id='']
+        cleaned = cleaned.replace(/\[@(id|name)=['"]{2}(.+?)['"]{2}\]/g, "[@$1='$2']");
+        // For DOM selectors (id or name), remove ALL quotes
+        if (type === "id" || type === "name") {
+            cleaned = cleaned.replace(/['"]/g, "").trim();
+        }
+        if (platform === "web" && type === "xpath" && !val.startsWith("//"))
+            return null;
+        // Final check for empty strings
+        if (!cleaned || /^['"]{2}$/.test(cleaned))
+            return null;
+        return cleaned;
+    };
+    locators: for (const locator of record.locators) {
+        try {
+            const recordedNLocators = record.locators.filter((l) => l.isRecorded === "N");
+            if (recordedNLocators.length > 0) {
+                for (const locator of recordedNLocators) {
+                    createAiLocator(locator);
+                }
+            }
+            const isDynamic = String(locator.value || locator.type || "");
+            if (isDynamic.includes("dynamic") ||
+                isDynamic.match("dynamic") ||
+                isDynamic.includes("{") ||
+                isDynamic.includes("}")) {
+                createAiLocator(locator);
+                continue;
+            }
+            // if (record.isShared.includes("Y")) {
+            //   break locators;
+            // }
+            try {
+                let targetElement = null;
+                const selectors = locator.value.split(">>>");
+                for (const selector of selectors) {
+                    if (!docmt) {
+                        console.error("Element not found at:", selector);
+                        break;
+                    }
+                    const trimmedSelector = selector.trim();
+                    //normal DOM
+                    targetElement = resolveAiElement(docmt, locator, trimmedSelector);
+                    //iframe (if not found)
+                    if (!targetElement && platform === "web") {
+                        targetElement = aiFindInIframes(docmt, locator, trimmedSelector);
+                    }
+                    //shadow DOM (if still not found)
+                    if (!targetElement && platform === "web") {
+                        targetElement = getAiElementFromShadowRoot(docmt.body, trimmedSelector);
+                    }
+                    if (!targetElement) {
+                        console.warn("Locator failed:", trimmedSelector);
+                        continue locators;
+                    }
+                }
+                const locatorAiExists = (name, value) => {
+                    const key = `${name}:${value}`;
+                    return finalAiLocatorsSet.has(key);
+                };
+                if (targetElement) {
+                    const excludedAttributes = [];
+                    const idValue = getaiId(targetElement);
+                    const ffXpath = targetElement.getAttribute("ff-xpath");
+                    if (idValue &&
+                        !locatorAiExists("id", idValue) &&
+                        !(0, xpathHelpers_js_1.isAiNumberExist)(idValue)) {
+                        const prevId = record.locators.find((l) => l.name === "id");
+                        if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "id", idValue, targetElement)) {
+                            excludedAttributes.push("id");
+                            createAiLocator(prevId, {
+                                name: "id",
+                                type: "static",
+                                isRecorded: "N",
+                                value: idValue
+                            });
+                        }
+                    }
+                    const tagName = targetElement.tagName;
+                    if (tagName && platform === "web" && !locatorAiExists("tagName", tagName)) {
+                        const prevTag = record.locators.find((l) => l.name === "tagName");
+                        if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "tagName", tagName, targetElement)) {
+                            excludedAttributes.push("tagName");
+                            createAiLocator(prevTag, {
+                                name: "tagName",
+                                type: "static",
+                                isRecorded: "N",
+                                value: tagName
+                            });
+                        }
+                    }
+                    const textValue = getAiVisibleText(targetElement);
+                    if (targetElement.tagName.toLowerCase() === "a" &&
+                        textValue &&
+                        !(0, xpathHelpers_js_1.isAiNumberExist)(textValue)) {
+                        const prevLinkText = record.locators.find((l) => l.name === "linkText");
+                        if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "linkText", textValue, targetElement)) {
+                            excludedAttributes.push("linkText");
+                            createAiLocator(prevLinkText, {
+                                name: "linkText",
+                                type: "static",
+                                isRecorded: "N",
+                                value: textValue
+                            });
+                        }
+                    }
+                    const nameLocator = getAiName(targetElement);
+                    if (nameLocator &&
+                        !locatorAiExists("name", nameLocator) &&
+                        !(0, xpathHelpers_js_1.isAiNumberExist)(nameLocator)) {
+                        const prevName = record.locators.find((l) => l.name === "name");
+                        if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "name", nameLocator, targetElement)) {
+                            excludedAttributes.push("name");
+                            createAiLocator(prevName, {
+                                name: "name",
+                                type: "static",
+                                isRecorded: "N",
+                                value: nameLocator
+                            });
+                        }
+                    }
+                    const classValue = getAiClassName(targetElement);
+                    if (classValue &&
+                        classValue.trim() !== "" &&
+                        !classValue.includes(" ") &&
+                        !locatorAiExists("className", classValue) &&
+                        !(0, xpathHelpers_js_1.isAiNumberExist)(classValue)) {
+                        const prevClassLocator = record.locators.find((l) => l.name === "className");
+                        if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "className", classValue, targetElement)) {
+                            excludedAttributes.push("className");
+                            createAiLocator(prevClassLocator, {
+                                name: "className",
+                                type: "static",
+                                isRecorded: "N",
+                                value: classValue
+                            });
+                        }
+                    }
+                    (0, cssSelector_js_1.parseAiCssSelectors)(targetElement, "single").forEach((cssSelector) => {
+                        if (cssSelector.value &&
+                            !locatorAiExists("cssSelector", cssSelector.value)) {
+                            createAiLocator(undefined, {
+                                name: "cssSelector",
+                                value: cssSelector.value,
+                                type: "static",
+                                isRecorded: "N"
+                            });
+                        }
+                    });
+                    const allAttributes = Array.from(targetElement.attributes);
+                    const includedAttributes = allAttributes.filter((attr) => !excludedAttributes.includes(attr.name));
+                    //If any direct locator is broken then we consider it as broken xpath
+                    let xpathResults = [];
+                    try {
+                        xpathResults =
+                            (0, xpath_js_1.aiParseDOM)(targetElement, docmt, true, includedAttributes, platform) ??
+                                [];
+                    }
+                    catch (error) {
+                        console.error("Error generating XPath candidates:", error);
+                    }
+                    if (xpathResults.length === 0 && ffXpath) {
+                        xpathResults.push({ value: ffXpath });
+                    }
+                    xpathResults.forEach(result => {
+                        if (!result.value)
+                            return;
+                        if (result.key === "iosClassChain") {
+                            createAiLocator(undefined, {
+                                name: "iOSClassChain",
+                                value: result.value,
+                                type: "static",
+                                isRecorded: "N"
+                            });
+                        }
+                        else if (result.key === "iosPredicateString") {
+                            createAiLocator(undefined, {
+                                name: "iOSNsPredicateString",
+                                value: result.value,
+                                type: "static",
+                                isRecorded: "N"
+                            });
+                        }
+                        // else if (result.key === "iosAccessibilityID") {
+                        //   createAiLocator(undefined, {
+                        //     name: "accessibilityId",
+                        //     value: result.value,
+                        //     type: "static",
+                        //     isRecorded: "N"
+                        //   });
+                        // }
+                        else {
+                            createAiLocator(undefined, {
+                                name: "xpath",
+                                value: result.value,
+                                type: "static",
+                                isRecorded: "N"
+                            });
+                        }
+                    });
+                    try {
+                        for (const loc of record.locators) {
+                            if (!loc.value)
+                                continue;
+                            for (const relation of aiRelations) {
+                                if (loc.value.includes(relation)) {
+                                    const relativeXpath = checkAiReferenceElementIsValid(loc.value, relation, docmt);
+                                    if (relativeXpath) {
+                                        createAiLocator(loc, {
+                                            name: "xpath",
+                                            value: relativeXpath,
+                                            isRecorded: "N"
+                                        });
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch (error) {
+                        console.error("Error processing locator:", locator, error);
+                    }
+                    if (finalLocators.length < 5) {
+                        const fallbackCandidates = [
+                            { name: "id", value: getaiId(targetElement) },
+                            { name: "name", value: getAiName(targetElement) },
+                            { name: "className", value: getAiClassName(targetElement) },
+                            { name: "tagName", value: targetElement.tagName },
+                            {
+                                name: "linkText",
+                                value: targetElement.tagName.toLowerCase() === "a"
+                                    ? getAiVisibleText(targetElement)
+                                    : null
+                            }
+                        ];
+                        for (const candidate of fallbackCandidates) {
+                            if (finalLocators.length > 4)
+                                break;
+                            const { name, value } = candidate;
+                            if (!value)
+                                continue;
+                            if ((0, xpathHelpers_js_1.isAiNumberExist)(value))
+                                continue;
+                            if (name === "className" && value.includes(" "))
+                                continue;
+                            if ((0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, name, value, targetElement)) {
+                                createAiLocator(undefined, {
+                                    name,
+                                    type: "static",
+                                    value,
+                                    isRecorded: "N",
+                                    isAiRecorded: "Y"
+                                });
+                            }
+                        }
+                        if (finalLocators.length < 5) {
+                            (0, cssSelector_js_1.parseAiCssSelectors)(targetElement, "multiple").forEach((cssSelector) => {
+                                if (finalLocators.length > 4)
+                                    return;
+                                if (!cssSelector.value)
+                                    return;
+                                if (!(0, xpathHelpers_js_1.isAiUniqueInDOM)(docmt, "cssSelector", cssSelector.value, targetElement)) {
+                                    return;
+                                }
+                                createAiLocator(undefined, {
+                                    name: "cssSelector",
+                                    type: "static",
+                                    value: cssSelector.value,
+                                    isRecorded: "N",
+                                    isAiRecorded: "Y"
+                                });
+                            });
+                        }
+                    }
+                    const finalAutoHealedLocators = finalLocators.map((obj) => ({
+                        ...obj,
+                        value: cleanAiLocatorValue(obj.value, obj.name)
+                    }));
+                    const getLocatorPriority = (name) => {
+                        const lower = (name || "").toLowerCase();
+                        if (lower === "id")
+                            return 1;
+                        if (lower === "name")
+                            return 2;
+                        if (lower === "xpath")
+                            return 3;
+                        return 4;
+                    };
+                    const validLocators = finalAutoHealedLocators
+                        .filter((locator) => locator?.value != null && locator.value !== "")
+                        .sort((a, b) => getLocatorPriority(a.name) - getLocatorPriority(b.name));
+                    const jsonResult = [
+                        {
+                            locators: validLocators,
+                            // isShared: `${record.isShared}`,
+                        }
+                    ];
+                    return jsonResult;
+                }
+            }
+            catch (error) {
+                console.error("Error processing locator:", locator, error);
+                continue;
+            }
+        }
+        catch (error) {
+            console.error("Error processing locator:", locator, error);
+            continue;
+        }
+    }
+    return null;
+};
+exports.getAiElementsFromHTML = getAiElementsFromHTML;

package/dist/fireflinkData/fireflinkLocators/types/locator.d.ts

@@ -0,0 +1,27 @@
+export interface Locator {
+    name: string;
+    type: string;
+    value: string;
+    reference: string;
+    status: string;
+    isRecorded: string;
+    isAiRecorded?: string;
+}
+export interface ElementRecord {
+    locators: Locator[];
+}
+export type SelectorMode = "single" | "multiple";
+export type XPathEntry = {
+    key: string;
+    value: string;
+};
+export interface AiDomContext {
+    tag: string;
+    attributes: Attr[];
+    normalizedText: string;
+    filteredText: string;
+    parent: Element | null;
+    ancestors: Element[];
+    previousSiblings: Element[];
+    nextSiblings: Element[];
+}

package/dist/fireflinkData/fireflinkLocators/types/locator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/fireflinkData/fireflinkLocators/utils/androidSelector.d.ts

@@ -0,0 +1,2 @@
+import { XPathEntry } from "../types/locator.js";
+export declare const generateAiAndroidLocators: (element: HTMLElement | Element, docmt: Document, isTarget: boolean) => XPathEntry[];

package/dist/fireflinkData/fireflinkLocators/utils/androidSelector.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAiAndroidLocators = void 0;
+const xpathHelpers_js_1 = require("./xpathHelpers.js");
+const addAiLocator = (locators, key, attribute, value, element, docmt, isTarget) => {
+    const xpath = (0, xpathHelpers_js_1.getAiPropertyXPath)(element, docmt, attribute, value, isTarget, 'android');
+    if (xpath &&
+        (0, xpathHelpers_js_1.getAiCountOfXPath)(xpath, element, docmt) === 1) {
+        locators.push({
+            key,
+            value: xpath
+        });
+    }
+};
+const generateAiAndroidLocators = (element, docmt, isTarget) => {
+    const locators = [];
+    const resourceId = element.getAttribute("resource-id");
+    const contentDesc = element.getAttribute("content-desc");
+    const text = element.getAttribute("text");
+    if (resourceId) {
+        addAiLocator(locators, "androidResourceID", "@resource-id", resourceId, element, docmt, isTarget);
+    }
+    if (contentDesc) {
+        addAiLocator(locators, "androidAccessibilityID", "@content-desc", contentDesc, element, docmt, isTarget);
+    }
+    if (text) {
+        addAiLocator(locators, "androidText", "@text", text, element, docmt, isTarget);
+    }
+    if (locators.length === 0) {
+        const relativeXpath = (0, xpathHelpers_js_1.getAIRelativeXPath)(element, docmt, isTarget, Array.from(element.attributes), "android");
+        if (relativeXpath && (0, xpathHelpers_js_1.getAiCountOfXPath)(relativeXpath, element, docmt) === 1) {
+            locators.push({
+                key: "Relative xpath",
+                value: relativeXpath
+            });
+        }
+    }
+    if (locators.length === 0) {
+        const absoluteXpath = (0, xpathHelpers_js_1.getAiAbsoluteXPath)(element, docmt);
+        if (absoluteXpath) {
+            if (absoluteXpath.startsWith('/hierarchy')) {
+                locators.push({
+                    key: "absoluteXPath",
+                    value: absoluteXpath
+                });
+            }
+            else {
+                locators.push({
+                    key: "absoluteXPath",
+                    value: `/hierarchy${absoluteXpath}`
+                });
+            }
+        }
+    }
+    return locators;
+};
+exports.generateAiAndroidLocators = generateAiAndroidLocators;

package/dist/fireflinkData/fireflinkLocators/utils/cssSelector.d.ts

@@ -0,0 +1,19 @@
+import { SelectorMode } from "../types/locator.js";
+export declare const parseAiCssSelectors: (el: Element, mode?: SelectorMode) => {
+    key: string;
+    value: string;
+}[];
+export declare const getIdAiCssPath: (el: HTMLElement | Element) => string | undefined;
+export declare const getAiAttributeCssPath: (el: Element) => string | undefined;
+export declare const getAiClassCssPath: (el: HTMLElement | Element) => string | undefined;
+export declare const getAiAbsoluteCssPath: (el: Element) => string | undefined;
+export declare const cssSelectors: {
+    parseAiCssSelectors: (el: Element, mode?: SelectorMode) => {
+        key: string;
+        value: string;
+    }[];
+    getIdAiCssPath: (el: HTMLElement | Element) => string | undefined;
+    getAiAttributeCssPath: (el: Element) => string | undefined;
+    getAiClassCssPath: (el: HTMLElement | Element) => string | undefined;
+    getAiAbsoluteCssPath: (el: Element) => string | undefined;
+};