ff-dom 3.0.3-beta.2 → 3.0.3-beta.4

package/dist/index.cdn.js

@@ -1875,16 +1875,21 @@
         if (!xpaths1?.length) {
             const xpaths = addAttributeSplitCombineXpaths(domNode.attributes, domNode, docmt, isTarget);
             if (xpaths?.length) {
-                xpaths1.concat(xpaths);
+                xpaths1.push(...xpaths);
             }
         }
         return xpaths1;
     };
-    const parseXml = (xmlStr, type) => {
-        if (window.DOMParser) {
-            return new window.DOMParser().parseFromString(xmlStr, type);
+    const parseXml = (xmlStr, type, DOMParserImpl) => {
+        if (!DOMParserImpl) {
+            return null;
         }
-        return null;
+        const doc = new DOMParserImpl().parseFromString(xmlStr, type);
+        // optional validation
+        if (doc.querySelector("parsererror")) {
+            throw new Error("Invalid XML");
+        }
+        return doc;
     };
     const normalizeXPath = (xpath) => {
         // Replace text() = "value"  or  text()='value'
@@ -1907,29 +1912,70 @@
         }
         return closePos;
     };
-    function canonicalizeXPath(xpath) {
-        return (xpath
+    function getXPathString(xpath) {
+        // ✅ Normal web xpath
+        if (typeof xpath === "string") {
+            return xpath;
+        }
+        // ✅ Android/object xpath
+        if (xpath &&
+            typeof xpath === "object" &&
+            typeof xpath.value === "string") {
+            return xpath.value;
+        }
+        return "";
+    }
+    function canonicalizeXPath(xpath, platform) {
+        const xpathValue = getXPathString(xpath);
+        // Android flow
+        if (String(platform).toLowerCase() === "android") {
+            return xpathValue
+                .toLowerCase()
+                .replace(/@text="[^"]*"/g, '@text="?"')
+                .replace(/@text='[^']*'/g, "@text='?'")
+                .replace(/"[^"]*"/g, "?")
+                .replace(/'[^']*'/g, "?")
+                .replace(/\/\/android\.[a-z0-9._-]+/g, "//android_tag")
+                .replace(/\/\/\*/g, "//*");
+        }
+        // Web flow
+        return xpathValue
             .toLowerCase()
-            // replace quoted values
             .replace(/'[^']*'/g, "?")
             .replace(/"[^"]*"/g, "?")
-            // replace numbers in predicates
             .replace(/\[\d+\]/g, "[?]")
-            // normalize node names
             .replace(/\/\/[a-z0-9_-]+/g, "//node")
-            .replace(/\/[a-z0-9_-]+/g, "/node"));
+            .replace(/\/[a-z0-9_-]+/g, "/node");
     }
     function extractXPathSignatureParts(xpath) {
-        const xp = xpath.toLowerCase();
+        const xpathValue = typeof xpath === "string"
+            ? xpath
+            : xpath?.value || "";
+        if (!xpathValue) {
+            return {
+                axis: "none",
+                attribute: "none",
+                usesNormalize: false
+            };
+        }
+        const xp = xpathValue.toLowerCase();
         const axisMatch = xp.match(/(ancestor-or-self|ancestor|descendant-or-self|descendant|following-sibling|preceding-sibling|following|preceding|parent|child|self)::/);
         const axis = axisMatch?.[1] ?? "none";
         const attrMatch = xp.match(/@([a-z0-9:-]+)/);
         const attribute = attrMatch?.[1] ?? "none";
         const usesNormalize = xp.includes("normalize-space");
-        return { axis, attribute, usesNormalize };
+        return {
+            axis,
+            attribute,
+            usesNormalize
+        };
     }
-    function getXPathPattern(xpath) {
-        const canonical = canonicalizeXPath(xpath);
+    function getXPathPattern(xpath, platform) {
+        const canonical = canonicalizeXPath(xpath, platform);
+        // Android: use full canonical xpath as pattern
+        if (platform?.toLowerCase().includes("android")) {
+            return `XPATH|shape:${canonical}`;
+        }
         const parts = extractXPathSignatureParts(xpath);
         return [
             "XPATH",
@@ -1945,8 +1991,13 @@
     function shouldUseSnapshot(xpath) {
         return /\[(?:\s*\.|\s*contains\s*\(\s*\.|\s*normalize-space\s*\(\s*\.)/.test(xpath);
     }
-    function isUniqueInDOM(docmt, name, value, element) {
-        const root = element?.getRootNode?.() ?? docmt;
+    function isUniqueInDOM(docmt, name, value, element, platform) {
+        // Scope uniqueness checks to the element's actual root, including ShadowRoot.
+        const root = (element?.getRootNode?.() ?? docmt);
+        const isAndroid = String(platform).toLowerCase().includes("android");
+        const isIOS = String(platform).toLowerCase().includes("ios");
+        const isMobile = isAndroid || isIOS;
+        // ✅ Fix 2: explicitly type the return as Element[]
         const queryAll = (selector) => {
             try {
                 return Array.from(root.querySelectorAll(selector));
@@ -1955,24 +2006,83 @@
                 return [];
             }
         };
+        // ✅ Fix 3: explicitly type the filter result as Element[]
+        const walkAttrAll = (attr, val) => {
+            try {
+                return Array.from(root.querySelectorAll("*")).filter((el) => el.getAttribute(attr) === val);
+            }
+            catch {
+                return [];
+            }
+        };
+        // ✅ Fix 4: partial match walk also needs explicit type guard
+        const walkAttrIncludes = (attr, val) => {
+            try {
+                return Array.from(root.querySelectorAll("*")).filter((el) => el.getAttribute(attr)?.includes(val) ?? false);
+            }
+            catch {
+                return [];
+            }
+        };
         try {
             switch (name) {
-                case "id":
+                case "id": {
+                    if (isAndroid)
+                        return walkAttrAll("resource-id", value).length === 1;
+                    if (isIOS)
+                        return walkAttrAll("name", value).length === 1;
                     return queryAll(`#${escapeAttrValue(value)}`).length === 1;
-                case "name":
-                    return queryAll(`[name="${escapeAttrValue(value)}"]`).length === 1;
-                case "className":
+                }
+                case "accessibilityId": {
+                    if (isAndroid)
+                        return walkAttrAll("content-desc", value).length === 1;
+                    if (isIOS)
+                        return walkAttrAll("name", value).length === 1;
+                    return walkAttrAll("aria-label", value).length === 1;
+                }
+                case "className": {
+                    if (isAndroid)
+                        return walkAttrAll("class", value).length === 1;
+                    if (isIOS)
+                        return walkAttrAll("type", value).length === 1;
                     return queryAll(`.${value}`).length === 1;
-                case "tagName":
+                }
+                case "tagName": {
+                    if (isAndroid)
+                        return walkAttrAll("class", value).length === 1;
+                    if (isIOS) {
+                        return queryAll("*").filter((candidate) => (candidate.getAttribute("type") || candidate.tagName) === value).length === 1;
+                    }
                     return queryAll(value).length === 1;
-                case "linkText":
-                    return (queryAll("a").filter((a) => a.textContent?.trim() === value)
-                        .length === 1);
-                case "partialLinkText":
-                    return (queryAll("a").filter((a) => a.textContent?.includes(value)).length ===
-                        1);
-                case "cssSelector":
+                }
+                case "name": {
+                    if (isAndroid) {
+                        return (walkAttrAll("text", value).length === 1 ||
+                            walkAttrAll("content-desc", value).length === 1);
+                    }
+                    if (isIOS)
+                        return walkAttrAll("name", value).length === 1;
+                    return queryAll(`[name="${escapeAttrValue(value)}"]`).length === 1;
+                }
+                case "linkText": {
+                    if (isAndroid)
+                        return walkAttrAll("text", value).length === 1;
+                    if (isIOS)
+                        return walkAttrAll("label", value).length === 1;
+                    return (queryAll("a").filter((a) => a.textContent?.trim() === value).length === 1);
+                }
+                case "partialLinkText": {
+                    if (isAndroid)
+                        return walkAttrIncludes("text", value).length === 1;
+                    if (isIOS)
+                        return walkAttrIncludes("label", value).length === 1;
+                    return (queryAll("a").filter((a) => a.textContent?.includes(value)).length === 1);
+                }
+                case "cssSelector": {
+                    if (isMobile)
+                        return false;
                     return queryAll(value).length === 1;
+                }
                 default:
                     return false;
             }
@@ -2035,9 +2145,132 @@
         getContainerTextCondition,
     };
 
+    function getOptimalClassChain(doc, domNode, uniqueAttributes) {
+        try {
+            if (!domNode ||
+                domNode.nodeType !== 1 ||
+                !domNode.tagName ||
+                domNode.tagName === "XCUIElementTypeApplication") {
+                return "";
+            }
+            const tag = domNode.tagName;
+            // Priority attributes
+            const priorityAttrs = ["name", "label", "value"];
+            // ---------- STEP 1 : TRY GOOD ATTRIBUTES ----------
+            for (const attrName of priorityAttrs) {
+                const attr = uniqueAttributes.find(a => a.name === attrName);
+                if (!attr)
+                    continue;
+                let attrValue = attr.value;
+                if (!attrValue)
+                    continue;
+                attrValue = attrValue.trim().replace(/\s+/g, " ");
+                if (isNumberExist(attrValue))
+                    continue;
+                const xpath = `//${tag}[@${attrName}="${attrValue}"]`;
+                let count = 0;
+                try {
+                    count = getCountOfXPath(xpath, domNode, doc);
+                }
+                catch (err) {
+                    console.log(err);
+                    continue;
+                }
+                const hasSpace = /\s/.test(attrValue);
+                if (count === 1) {
+                    if (hasSpace) {
+                        return `**/${tag}[\`${attrName} CONTAINS "${attrValue}"\`]`;
+                    }
+                    return `**/${tag}[\`${attrName} == "${attrValue}"\`]`;
+                }
+                if (count > 1 && domNode.parentElement) {
+                    const siblings = Array.from(domNode.parentElement.children)
+                        .filter(el => el.tagName === tag);
+                    const index = siblings.indexOf(domNode) + 1;
+                    if (hasSpace) {
+                        return `**/${tag}[\`${attrName} CONTAINS "${attrValue}"\`][${index}]`;
+                    }
+                    return `**/${tag}[\`${attrName} == "${attrValue}"\`][${index}]`;
+                }
+            }
+            // ---------- STEP 2 : FALLBACK USING TAG INDEX ----------
+            let classChain = `/${tag}`;
+            if (domNode.parentElement) {
+                const siblings = Array.from(domNode.parentElement.children)
+                    .filter(el => el.tagName === tag);
+                if (siblings.length > 1) {
+                    const index = siblings.indexOf(domNode) + 1;
+                    classChain += `[${index}]`;
+                }
+            }
+            const parentChain = getOptimalClassChain(doc, domNode.parentElement, uniqueAttributes);
+            return parentChain + classChain;
+        }
+        catch (error) {
+            console.log(`Unable to generate optimal -ios class chain : ${JSON.stringify(error)}`);
+            return null;
+        }
+    }
+    function getOptimalPredicateString(doc, domNode, uniqueAttributes) {
+        try {
+            // BASE CASE #1: If this isn't an element, we're above the root, or this is `XCUIElementTypeApplication`,
+            // which is not an official XCUITest element, return empty string
+            if (!domNode?.tagName ||
+                domNode?.nodeType !== 1 ||
+                domNode?.tagName === 'XCUIElementTypeApplication') {
+                return '';
+            }
+            // BASE CASE #2: Check attributes in iOS locator priority order.
+            // Prefer stable XCTest identifiers (`name`) over weak type-only predicates.
+            let xpathAttributes = [];
+            let predicateString = [];
+            const priorityAttrs = ["name", "label", "value", "type"];
+            const orderedAttributes = priorityAttrs
+                .map((attrName) => uniqueAttributes.find((attr) => attr.name === attrName))
+                .filter((attr) => Boolean(attr));
+            for (let attr of orderedAttributes) {
+                const attrValue = attr.value;
+                const attrName = attr.name;
+                if (attrValue.length === 0) {
+                    continue;
+                }
+                if (attrValue && !isNumberExist(attrValue)) {
+                    xpathAttributes.push(`@${attrName}="${attrValue}"`);
+                    const xpathe = `//*[${xpathAttributes.join(' and ')}]`;
+                    predicateString.push(`${attrName} == "${attrValue}"`);
+                    let othersWithAttr;
+                    // If the XPath does not parse, move to the next unique attribute
+                    try {
+                        othersWithAttr = getCountOfXPath(xpathe, domNode, doc);
+                    }
+                    catch (ign) {
+                        console.log(ign);
+                        continue;
+                    }
+                    if (othersWithAttr === 1) {
+                        if (attrName === "type" && predicateString.length === 1) {
+                            continue;
+                        }
+                        return predicateString.join(' AND ');
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // If there's an unexpected exception, abort and don't get an XPath
+            console.log(`The most optimal '-ios predicate string' could not be determined because an error was thrown: '${JSON.stringify(error, null, 2)}'`);
+        }
+        return null;
+    }
+    const iosSelectors = {
+        getOptimalClassChain,
+        getOptimalPredicateString
+    };
+
     let xpathData$1 = [];
     let xpathDataWithIndex$1 = [];
     let referenceElementMode = false;
+    let locatorData = [];
     let parentXpathCache = new WeakMap();
     let childRelativeXpathCache = new WeakMap();
     const getElementSignature = (element) => element ?
@@ -3573,7 +3806,191 @@
             console.log(error);
         }
     };
-    const parseDOM = (element, doc, isIndex, isTarget, includedAttributes = [], strategies = []) => {
+    const parseDOMAndroid = (element, doc, isIndex, isTarget, includedAttributes = []) => {
+        xpathData$1 = [];
+        locatorData = [];
+        const res = {};
+        const keys = {};
+        const targetElemt = element;
+        const docmt = targetElemt?.ownerDocument || doc;
+        const tag = targetElemt?.tagName;
+        const { attributes } = targetElemt;
+        [...attributes].forEach((m) => {
+            if (m.name === 'resource-id') {
+                res['id'] = m.value;
+            }
+            else if (m.name === 'content-desc') {
+                res['content'] = m.value;
+            }
+            else {
+                res[m.name] = m.value;
+            }
+        });
+        // resource-id locator
+        if (res?.id && !isNumberExist(res.id)) {
+            const idXpath = `//*[@resource-id=${escapeCharacters(res.id)}]`;
+            const count = getCountOfXPath(idXpath, targetElemt, docmt);
+            if (count === 1) {
+                locatorData.push({
+                    key: 'id',
+                    value: [{ key: 'resource-id', value: res.id }],
+                    viewkey: 'Id',
+                });
+                keys['resource-id'] = 1;
+            }
+        }
+        // accessibility id locator
+        if (res?.content && !isNumberExist(res.content)) {
+            const contentXpath = `//*[@content-desc=${escapeCharacters(res.content)}]`;
+            const count = getCountOfXPath(contentXpath, targetElemt, docmt);
+            if (count === 1) {
+                locatorData.push({
+                    key: 'accessibilityId',
+                    value: [
+                        {
+                            key: 'accessibilityID',
+                            value: res.content,
+                        },
+                    ],
+                    viewkey: 'accessibilityId',
+                });
+                keys['content-desc'] = 1;
+            }
+        }
+        // class locator
+        if (res?.class && !isNumberExist(res.class)) {
+            const classXpath = `//*[@class=${escapeCharacters(res.class)}]`;
+            const count = getCountOfXPath(classXpath, targetElemt, docmt);
+            if (count === 1) {
+                locatorData.push({
+                    key: 'className',
+                    viewkey: 'className',
+                    value: [{ key: 'class', value: res.class }],
+                });
+                keys['class'] = 1;
+            }
+        }
+        const attributesToUse = includedAttributes.length > 0
+            ? includedAttributes
+            : Array.from(attributes);
+        const relevantAttributes = attributesToUse.filter((x) => !keys[x.name]);
+        addAllXPathAttributes(relevantAttributes, targetElemt, docmt, isIndex, isTarget);
+        // regex xpath generation
+        if (xpathData$1.length) {
+            const len = xpathData$1.length;
+            for (let i = 0; i < len; i++) {
+                let xpth = xpathData$1[i].value;
+                xpth =
+                    '//*' +
+                        xpth.substring(xpth.indexOf('//') + 2 + tag.length);
+                const count = getCountOfXPath(xpth, element, docmt);
+                if (count === 1) {
+                    xpathData$1.push({
+                        key: `${xpathData$1[i].key} regex`,
+                        value: xpth,
+                    });
+                }
+            }
+        }
+        // relative xpath fallback
+        if (!xpathData$1.length) {
+            addRelativeXpaths(targetElemt, docmt, isIndex, isTarget, relevantAttributes);
+        }
+        // merge xpath locators
+        for (const x of xpathData$1) {
+            locatorData.push({
+                key: 'xpath',
+                viewkey: 'xpath',
+                value: [x],
+            });
+        }
+        return locatorData;
+    };
+    const parseDOMIOS = (element, doc, isIndex, isTarget, includedAttributes = []) => {
+        xpathData$1 = [];
+        locatorData = [];
+        const keys = {};
+        const targetElemt = element;
+        const docmt = targetElemt?.ownerDocument || doc;
+        const tag = targetElemt?.tagName;
+        const { attributes } = targetElemt;
+        const addUniqueIOSLocator = (locatorKey, viewkey, attributeName) => {
+            const attributeValue = targetElemt.getAttribute(attributeName);
+            if (!attributeValue || isNumberExist(attributeValue)) {
+                return;
+            }
+            const locatorXpath = `//*[@${attributeName}=${escapeCharacters(attributeValue)}]`;
+            const count = getCountOfXPath(locatorXpath, targetElemt, docmt);
+            if (count !== 1) {
+                return;
+            }
+            locatorData.push({
+                key: locatorKey,
+                viewkey,
+                value: [{ key: attributeName, value: attributeValue }]
+            });
+            keys[attributeName] = 1;
+        };
+        addUniqueIOSLocator("accessibilityId", "accessibilityId", "name");
+        addUniqueIOSLocator("className", "className", "type");
+        const attributesToUse = includedAttributes.length > 0
+            ? includedAttributes
+            : Array.from(attributes);
+        const selectorAttributes = attributesToUse.filter((attribute) => ["label", "name", "value", "type"].includes(attribute.name));
+        const classChain = iosSelectors.getOptimalClassChain(docmt, targetElemt, selectorAttributes);
+        if (classChain) {
+            locatorData.push({
+                viewkey: "Class Chain",
+                key: "iOSClassChain",
+                value: [{ key: "classChain", value: classChain }]
+            });
+        }
+        const predicateString = iosSelectors.getOptimalPredicateString(docmt, targetElemt, selectorAttributes);
+        if (predicateString) {
+            locatorData.push({
+                viewkey: "Predicate String",
+                key: "iOSNsPredicateString",
+                value: [{ key: "predicateString", value: predicateString }]
+            });
+        }
+        const relevantAttributes = attributesToUse.filter((attribute) => (attribute.name === "name" || !keys[attribute.name]) &&
+            ["name", "label", "value"].includes(attribute.name));
+        addAllXPathAttributes(relevantAttributes, targetElemt, docmt, isIndex, isTarget);
+        if (xpathData$1.length) {
+            const len = xpathData$1.length;
+            for (let i = 0; i < len; i++) {
+                let xpth = xpathData$1[i].value;
+                xpth =
+                    "//*" +
+                        xpth.substring(xpth.indexOf("//") + 2 + tag.length);
+                const count = getCountOfXPath(xpth, element, docmt);
+                if (count === 1) {
+                    xpathData$1.push({
+                        key: `${xpathData$1[i].key} regex`,
+                        value: xpth
+                    });
+                }
+            }
+        }
+        if (!xpathData$1.length) {
+            addRelativeXpaths(targetElemt, docmt, isIndex, isTarget, relevantAttributes);
+        }
+        for (const xpath of xpathData$1) {
+            locatorData.push({
+                key: "xpath",
+                viewkey: "xpath",
+                value: [xpath]
+            });
+        }
+        return locatorData;
+    };
+    const parseDOM = (element, doc, isIndex, isTarget, includedAttributes = [], strategies = [], platform) => {
+        if (platform === 'Android') {
+            return parseDOMAndroid(element, doc, isIndex, isTarget, includedAttributes);
+        }
+        if (platform === 'iOS') {
+            return parseDOMIOS(element, doc, isIndex, isTarget, includedAttributes);
+        }
         xpathData$1 = [];
         console.log(element);
         const targetElemt = element;
@@ -3781,7 +4198,9 @@
         // Share target candidate work across all relation attempts in this run.
         const targetCandidateContext = createTargetCandidateContext(element2, docmt, xpaths2);
         let finalXpaths = [];
-        const relations = allowedRelations || [];
+        const relations = allowedRelations?.length ?
+            allowedRelations
+            : getSmartRelations(element1, element2);
         if (!isIndex) {
             // Fresh non-index runs should start from a clean candidate list for this
             // reference/target pair; only candidates found in this pass are reusable.
@@ -4943,7 +5362,18 @@
     };
     const getReferenceElementXpath = (element) => {
         let xpaths1 = [];
-        xpaths1 = parseDOM(element, element.ownerDocument, false, false);
+        const normalizeXpaths = (data) => Array.isArray(data)
+            ? data.flatMap((item) => typeof item?.value === "string"
+                ? [{ key: item.key || "", value: item.value }]
+                : Array.isArray(item?.value)
+                    ? item.value
+                        .filter((entry) => typeof entry?.value === "string")
+                        .map((entry) => ({
+                        key: entry.key || item.key || "",
+                        value: entry.value
+                    }))
+                    : [])
+            : [];
         const referenceElementXpaths = getReferenceElementsXpath(element, element.ownerDocument, false);
         if (referenceElementXpaths?.length) {
             xpaths1 = xpaths1?.length
@@ -4951,41 +5381,53 @@
                 : referenceElementXpaths;
         }
         if (!xpaths1?.length) {
-            xpaths1 = parseDOM(element, element.ownerDocument, true, false);
+            xpaths1 = normalizeXpaths(parseDOM(element, element.ownerDocument, true, false));
             xpaths1 = xpaths1?.map((x) => x.value.charAt(0) == "(" &&
                 findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
                 ? { key: "", value: removeParenthesis(x.value) }
                 : { key: "", value: x.value });
+            xpaths1 = xpaths1.map((x) => x.value.charAt(0) === "(" &&
+                findMatchingParenthesis(x.value, 0) + 1 ===
+                    x.value.lastIndexOf("[")
+                ? {
+                    key: "",
+                    value: removeParenthesis(x.value)
+                }
+                : x);
         }
         else {
-            let xpaths = parseDOM(element, element.ownerDocument, true, false);
-            if (xpaths?.length) {
-                xpaths = xpaths?.map((x) => x.value.charAt(0) == "(" &&
-                    findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
-                    ? { key: "", value: removeParenthesis(x.value) }
-                    : { key: "", value: x.value });
+            let xpaths = normalizeXpaths(parseDOM(element, element.ownerDocument, true, false));
+            if (xpaths.length) {
+                xpaths = xpaths.map((x) => x.value.charAt(0) === "(" &&
+                    findMatchingParenthesis(x.value, 0) + 1 ===
+                        x.value.lastIndexOf("[")
+                    ? {
+                        key: "",
+                        value: removeParenthesis(x.value)
+                    }
+                    : x);
                 xpaths1 = xpaths1.concat(xpaths);
             }
         }
-        if (!xpaths1?.length) {
-            xpaths1 = [
-                {
+        if (!xpaths1.length) {
+            xpaths1 = [{
                     key: "",
                     value: getRelativeXPath(element, element.ownerDocument, false, false, Array.from(element.attributes))
-                }
-            ];
+                }];
         }
-        if (!xpaths1?.length) {
-            xpaths1 = [
-                {
+        if (!xpaths1.length) {
+            xpaths1 = [{
                     key: "",
                     value: getRelativeXPath(element, element.ownerDocument, true, false, Array.from(element.attributes))
+                }];
+            xpaths1 = xpaths1.map((x) => x.value.charAt(0) === "(" &&
+                findMatchingParenthesis(x.value, 0) + 1 ===
+                    x.value.lastIndexOf("[")
+                ? {
+                    key: "",
+                    value: removeParenthesis(x.value)
                 }
-            ];
-            xpaths1 = xpaths1?.map((x) => x.value.charAt(0) == "(" &&
-                findMatchingParenthesis(x.value, 0) + 1 === x.value.lastIndexOf("[")
-                ? { key: "", value: removeParenthesis(x.value) }
-                : { key: "", value: x.value });
+                : x);
         }
         const childAnchorXpaths = Array.from(element.children || [])
             .map((child) => {
@@ -5242,6 +5684,19 @@
         const trimmed = value.trim();
         return Boolean(trimmed) && trimmed.length <= 120 && !/^\d+$/.test(trimmed);
     };
+    const isStableSemanticId = (el, idAttribute) => {
+        const value = idAttribute.value.trim();
+        if (!isStableAttributeValue(value))
+            return false;
+        const wasModified = modifiedElementAttributes.some((modifiedAttribute) => modifiedAttribute.doc === el.ownerDocument &&
+            modifiedAttribute.element === el &&
+            modifiedAttribute.attributeName === "id");
+        if (wasModified)
+            return false;
+        // Keep semantic levels/versions such as "level2-shadow-host", but reject
+        // IDs containing long numeric runs, which are more likely generated.
+        return !/\d{4,}/.test(value);
+    };
     const isCssSelectorUnique = (selector, el, root) => {
         try {
             const matches = root.querySelectorAll(selector);
@@ -5299,8 +5754,8 @@
             return;
         const idAttribute = el.getAttributeNode("id");
         if (!idAttribute ||
-            !isStableAttributeValue(idAttribute.value) ||
-            !checkBlockedAttributes(idAttribute, el, true)) {
+            (!checkBlockedAttributes(idAttribute, el, true) &&
+                !isStableSemanticId(el, idAttribute))) {
             return;
         }
         return `#${escapeCssIdentifier(el.id, el)}`;
@@ -5420,6 +5875,59 @@
         }
         return;
     };
+    const getNthOfType = (el) => {
+        let index = 1;
+        let sibling = el.previousElementSibling;
+        while (sibling) {
+            if (sibling.tagName === el.tagName)
+                index++;
+            sibling = sibling.previousElementSibling;
+        }
+        return index;
+    };
+    const getRelativeCssSegment = (el) => {
+        const parent = el.parentElement;
+        const tag = el.tagName.toLowerCase();
+        if (parent) {
+            const stableSelectors = getDirectStableSelectors(el, {
+                includeTag: true,
+                preferredAttributesOnly: true
+            })
+                .filter((selector) => isCssSelectorUnique(selector, el, parent))
+                .sort((a, b) => a.length - b.length);
+            if (stableSelectors.length)
+                return stableSelectors[0];
+            const sameTagSiblings = Array.from(parent.children).filter((child) => child.tagName === el.tagName);
+            if (sameTagSiblings.length > 1) {
+                return `${tag}:nth-of-type(${getNthOfType(el)})`;
+            }
+        }
+        return tag;
+    };
+    const getShortestPositionalCssPath = (el) => {
+        if (!isElementNode(el) || isIgnoredTag(el))
+            return;
+        const root = el.getRootNode();
+        const descendantSegments = [];
+        let current = el;
+        while (current && isElementNode(current) && !isIgnoredTag(current)) {
+            const anchorSelectors = getDirectStableSelectors(current, {
+                includeTag: true,
+                preferredAttributesOnly: true
+            });
+            for (const anchorSelector of anchorSelectors) {
+                if (!isCssSelectorUnique(anchorSelector, current, root))
+                    continue;
+                const candidate = [anchorSelector, ...descendantSegments].join(" > ");
+                if (isCssSelectorUnique(candidate, el, root)) {
+                    return candidate;
+                }
+            }
+            descendantSegments.unshift(getRelativeCssSegment(current));
+            current = current.parentElement;
+        }
+        return getAbsoluteCssPath(el);
+    };
     const getAbsoluteCssPath = (el) => {
         const view = el.ownerDocument?.defaultView;
         if (!view || !(el instanceof view.Element))
@@ -5447,6 +5955,7 @@
         getIdCssPath,
         getAttributeCssPath,
         getClassCssPath,
+        getShortestPositionalCssPath,
         getAbsoluteCssPath
     };
 
@@ -5514,10 +6023,30 @@
         }
         return null;
     };
-    const getId = (element) => {
-        return element?.id || null;
+    const getId = (element, platform) => {
+        if (!element)
+            return null;
+        const normalizedPlatform = String(platform).toLowerCase();
+        if (normalizedPlatform.includes("android")) {
+            return (element.getAttribute("resource-id") ||
+                element.getAttribute("resourceId") ||
+                null);
+        }
+        if (normalizedPlatform.includes("ios")) {
+            return element.getAttribute("name") || null;
+        }
+        return element.id || null;
     };
-    const getClassName = (element) => {
+    const getClassName = (element, platform) => {
+        const normalizedPlatform = String(platform).toLowerCase();
+        if (normalizedPlatform.includes("android")) {
+            return (element.getAttribute("class") ||
+                element.getAttribute("className") ||
+                null);
+        }
+        if (normalizedPlatform.includes("ios")) {
+            return element.getAttribute("type") || null;
+        }
         return element.className || null;
     };
     const getVisibleText = (element) => {
@@ -5545,12 +6074,25 @@
         "/following"
     ];
     function getElementFromXPath(docmt, xpath) {
-        const window = docmt.defaultView;
-        if (!window)
+        try {
+            const xpathResultType = docmt.defaultView?.XPathResult?.FIRST_ORDERED_NODE_TYPE ??
+                (typeof XPathResult !== "undefined"
+                    ? XPathResult.FIRST_ORDERED_NODE_TYPE
+                    : 9);
+            const xpathEvaluator = docmt.defaultView?.XPathEvaluator
+                ? new docmt.defaultView.XPathEvaluator()
+                : typeof XPathEvaluator !== "undefined"
+                    ? new XPathEvaluator()
+                    : null;
+            const xpathResult = xpathEvaluator
+                ? xpathEvaluator.evaluate(xpath, docmt, null, xpathResultType, null)
+                : docmt.evaluate(xpath, docmt, null, xpathResultType, null);
+            return xpathResult.singleNodeValue;
+        }
+        catch (error) {
+            console.error("Invalid XPath:", xpath, error);
             return null;
-        const xpathEvaluator = new window.XPathEvaluator();
-        const xpathResult = xpathEvaluator.evaluate(xpath, docmt, null, window.XPathResult.FIRST_ORDERED_NODE_TYPE, null);
-        return xpathResult.singleNodeValue;
+        }
     }
     function checkReferenceElementIsValid(locator, relation, docmt) {
         if (locator.includes(relation)) {
@@ -5584,7 +6126,7 @@
         }
         return null;
     }
-    const getElementsFromHTML = (record, docmt) => {
+    const getElementsFromHTML = (record, docmt, platform) => {
         clearXPathEvalCache(docmt);
         const elementsToRemove = docmt.querySelectorAll("script, style, link[rel='stylesheet'], meta, noscript, embed, object, param, source, svg");
         if (elementsToRemove) {
@@ -5613,45 +6155,330 @@
                     : resolveIsSelfHealed(newLocator.name, oldValue, newValue);
             pushUniqueLocator(newLocator);
         }
-        function resolveElement(ctx, locator, selector) {
+        const walkAttr = (ctx, attr, value) => {
+            for (const el of Array.from(ctx.querySelectorAll("*"))) {
+                if (el.getAttribute(attr) === value)
+                    return el;
+            }
+            return null;
+        };
+        const isAndroidPlatform = (platform) => String(platform).toLowerCase().includes("android");
+        const isMobilePlatform = (platform) => isAndroidPlatform(platform) ||
+            String(platform).toLowerCase().includes("ios");
+        const isIOSPlatform = (platform) => String(platform).toLowerCase().includes("ios");
+        const getLocatorStrategy = (name) => {
+            const normalized = String(name || "")
+                .trim()
+                .toLowerCase()
+                .replace(/^-/, "")
+                .replace(/[\s_-]+/g, "");
+            switch (normalized) {
+                case "id":
+                    return "id";
+                case "name":
+                    return "name";
+                case "xpath":
+                    return "xpath";
+                case "classname":
+                    return "className";
+                case "accessibilityid":
+                    return "accessibilityId";
+                case "iospredicatestring":
+                case "iosnspredicatestring":
+                    return "iosPredicateString";
+                case "iosclasschain":
+                    return "iosClassChain";
+                default:
+                    return String(name || "");
+            }
+        };
+        const findLocatorByStrategy = (strategy) => record.locators.find((candidate) => getLocatorStrategy(candidate.name) === strategy);
+        const getAttributeValue = (element, attribute) => {
+            if (attribute.toLowerCase() === "type") {
+                return element.getAttribute("type") || element.tagName || "";
+            }
+            return element.getAttribute(attribute) || "";
+        };
+        const splitIOSExpression = (expression) => {
+            const clauses = [];
+            const operators = [];
+            let quote = "";
+            let start = 0;
+            for (let index = 0; index < expression.length; index++) {
+                const char = expression[index];
+                if ((char === '"' || char === "'") && expression[index - 1] !== "\\") {
+                    quote = quote === char ? "" : quote || char;
+                    continue;
+                }
+                if (quote)
+                    continue;
+                const remaining = expression.slice(index);
+                const operatorMatch = remaining.match(/^\s+(AND|OR)\s+/i);
+                if (!operatorMatch)
+                    continue;
+                clauses.push(expression.slice(start, index).trim());
+                operators.push(operatorMatch[1].toUpperCase());
+                index += operatorMatch[0].length - 1;
+                start = index + 1;
+            }
+            clauses.push(expression.slice(start).trim());
+            return { clauses, operators };
+        };
+        const matchesIOSPredicate = (element, predicate) => {
+            const expression = predicate.trim().replace(/^\((.*)\)$/s, "$1");
+            if (/^(TRUEPREDICATE|1\s*==\s*1)$/i.test(expression))
+                return true;
+            const { clauses, operators } = splitIOSExpression(expression);
+            const results = clauses.map((clause) => {
+                const match = clause.match(/^([\w-]+)\s*(==|=|!=|CONTAINS|BEGINSWITH|ENDSWITH|MATCHES)(\[[cd]+\])?\s*(?:"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'|([^\s]+))$/i);
+                if (!match)
+                    return false;
+                const [, attribute, rawOperator, modifiers, doubleQuoted, singleQuoted, bare] = match;
+                const expected = (doubleQuoted ?? singleQuoted ?? bare ?? "")
+                    .replace(/\\([\\"'])/g, "$1");
+                let actual = getAttributeValue(element, attribute);
+                let comparableExpected = expected;
+                if (comparableExpected === "1" && actual.toLowerCase() === "true") {
+                    actual = "1";
+                }
+                else if (comparableExpected === "0" &&
+                    actual.toLowerCase() === "false") {
+                    actual = "0";
+                }
+                if (modifiers?.toLowerCase().includes("c")) {
+                    actual = actual.toLocaleLowerCase();
+                    comparableExpected = comparableExpected.toLocaleLowerCase();
+                }
+                switch (rawOperator.toUpperCase()) {
+                    case "=":
+                    case "==":
+                        return actual === comparableExpected;
+                    case "!=":
+                        return actual !== comparableExpected;
+                    case "CONTAINS":
+                        return actual.includes(comparableExpected);
+                    case "BEGINSWITH":
+                        return actual.startsWith(comparableExpected);
+                    case "ENDSWITH":
+                        return actual.endsWith(comparableExpected);
+                    case "MATCHES":
+                        try {
+                            return new RegExp(comparableExpected).test(actual);
+                        }
+                        catch {
+                            return false;
+                        }
+                    default:
+                        return false;
+                }
+            });
+            let result = results[0] ?? false;
+            operators.forEach((operator, index) => {
+                result = operator === "AND"
+                    ? result && results[index + 1]
+                    : result || results[index + 1];
+            });
+            return result;
+        };
+        const resolveIOSPredicate = (ctx, predicate) => Array.from(ctx.querySelectorAll("*")).find((element) => matchesIOSPredicate(element, predicate)) || null;
+        const splitIOSClassChain = (classChain) => {
+            const segments = [];
+            let current = "";
+            let quote = "";
+            let fence = "";
+            let bracketDepth = 0;
+            for (let index = 0; index < classChain.length; index++) {
+                const char = classChain[index];
+                if ((char === '"' || char === "'") && classChain[index - 1] !== "\\") {
+                    quote = quote === char ? "" : quote || char;
+                }
+                else if (!quote && (char === "`" || char === "$")) {
+                    fence = fence === char ? "" : fence || char;
+                }
+                else if (!quote && !fence && char === "[") {
+                    bracketDepth++;
+                }
+                else if (!quote && !fence && char === "]") {
+                    bracketDepth--;
+                }
+                if (char === "/" && !quote && !fence && bracketDepth === 0) {
+                    if (current)
+                        segments.push(current);
+                    current = "";
+                }
+                else {
+                    current += char;
+                }
+            }
+            if (current)
+                segments.push(current);
+            return segments.filter(Boolean);
+        };
+        const resolveIOSClassChain = (ctx, classChain) => {
+            const segments = splitIOSClassChain(classChain.trim());
+            let current = [ctx];
+            let useDescendants = false;
+            for (const segment of segments) {
+                if (segment === "**") {
+                    useDescendants = true;
+                    continue;
+                }
+                const type = segment.match(/^([^[]+)/)?.[1]?.trim() || "*";
+                const predicates = Array.from(segment.matchAll(/\[(?:`([^`]*)`|\$([^$]*)\$)\]/g)).map((match) => match[1] ?? match[2]);
+                const indexMatch = segment.match(/\[(-?\d+)\]\s*$/);
+                const candidates = [];
+                for (const parent of current) {
+                    const descendants = useDescendants
+                        ? Array.from(parent.querySelectorAll("*"))
+                        : parent.nodeType === 9
+                            ? [parent.documentElement]
+                            : Array.from(parent.children);
+                    candidates.push(...descendants.filter((element) => {
+                        const elementType = getAttributeValue(element, "type");
+                        return (type === "*" || elementType === type) &&
+                            predicates.every((predicate) => matchesIOSPredicate(element, predicate));
+                    }));
+                }
+                if (indexMatch) {
+                    const requestedIndex = Number(indexMatch[1]);
+                    const resolvedIndex = requestedIndex < 0
+                        ? candidates.length + requestedIndex
+                        : requestedIndex - 1;
+                    current = candidates[resolvedIndex] ? [candidates[resolvedIndex]] : [];
+                }
+                else {
+                    current = candidates;
+                }
+                useDescendants = false;
+                if (!current.length)
+                    return null;
+            }
+            return current[0] || null;
+        };
+        const isXPathLocator = (locator, selector) => (getLocatorStrategy(locator.name) === "xpath" ||
+            locator.name?.toLowerCase().includes("xpath") ||
+            selector.startsWith("//")) &&
+            !String(locator.type || "").includes("dynamic");
+        const getXPathCandidates = (results) => {
+            return results.flatMap((group) => {
+                if (!group)
+                    return [];
+                if (Array.isArray(group.value)) {
+                    if (group.key !== "xpath" && group.viewkey !== "xpath") {
+                        return [];
+                    }
+                    return group.value;
+                }
+                return [group];
+            }).filter((result) => typeof result?.value === "string" &&
+                result.value.trim().startsWith("//"));
+        };
+        const resolveAndroidElement = (ctx, locator, selector) => {
+            const strategy = getLocatorStrategy(locator.name);
+            if (isXPathLocator(locator, selector)) {
+                return getElementFromXPath(ctx, normalizeXPath(selector));
+            }
+            // ID
+            if (strategy === "id" ||
+                (strategy !== "accessibilityId" && locator.name.includes("id")) ||
+                selector.startsWith("#")) {
+                const clean = selector.startsWith("#")
+                    ? selector.slice(1)
+                    : selector;
+                return (walkAttr(ctx, "resource-id", clean) ||
+                    walkAttr(ctx, "content-desc", clean));
+            }
+            // accessibilityId
+            if (strategy === "accessibilityId") {
+                return walkAttr(ctx, "content-desc", selector);
+            }
+            // className
+            if (strategy === "className" ||
+                locator.name.includes("className") ||
+                selector.startsWith(".")) {
+                return (ctx.querySelector(`[class="${selector}"]`) ||
+                    null);
+            }
+            // name
+            if (strategy === "name") {
+                return (walkAttr(ctx, "text", selector) ||
+                    walkAttr(ctx, "content-desc", selector));
+            }
+            // tagName
+            if (strategy === "tagName") {
+                return (ctx.querySelector(`[class="${selector}"]`) ||
+                    null);
+            }
+            // linkText
+            if (strategy === "linkText") {
+                return walkAttr(ctx, "text", selector);
+            }
+            // partialLinkText
+            if (strategy === "partialLinkText") {
+                return (Array.from(ctx.querySelectorAll("*")).find((el) => el.getAttribute("text")?.includes(selector)) || null);
+            }
+            return null;
+        };
+        const resolveIOSElement = (ctx, locator, selector) => {
+            const strategy = getLocatorStrategy(locator.name);
+            if (isXPathLocator(locator, selector)) {
+                return getElementFromXPath(ctx, normalizeXPath(selector));
+            }
+            if (strategy === "id") {
+                return walkAttr(ctx, "name", selector);
+            }
+            if (strategy === "accessibilityId") {
+                return walkAttr(ctx, "name", selector);
+            }
+            if (strategy === "name") {
+                return walkAttr(ctx, "name", selector);
+            }
+            if (strategy === "className") {
+                return walkAttr(ctx, "type", selector);
+            }
+            if (strategy === "iosPredicateString") {
+                return resolveIOSPredicate(ctx, selector);
+            }
+            if (strategy === "iosClassChain") {
+                return resolveIOSClassChain(ctx, selector);
+            }
+            return null;
+        };
+        const resolveWebElement = (ctx, locator, selector) => {
+            const strategy = getLocatorStrategy(locator.name);
+            if (isXPathLocator(locator, selector)) {
+                return getElementFromXPath(ctx, normalizeXPath(selector));
+            }
             if (isCssSelectorLocator(locator)) {
                 return getElementFromCssSelector(ctx, selector);
             }
-            else if (locator.name.includes("id") || selector.startsWith("#")) {
-                return ctx.querySelector("#" + escapeAttrValue(selector));
-            }
-            else if (locator.name.includes("className") || selector.startsWith(".")) {
-                return ctx.querySelector("." + selector);
+            if (strategy === "id" ||
+                locator.name.includes("id") ||
+                selector.startsWith("#")) {
+                const clean = selector.startsWith("#")
+                    ? selector.slice(1)
+                    : selector;
+                return ctx.querySelector("#" + escapeAttrValue(clean));
+            }
+            if (strategy === "className" ||
+                locator.name.includes("className") ||
+                selector.startsWith(".")) {
+                return ctx.querySelector(selector);
             }
-            else if (locator.name === "name") {
-                const safeName = escapeAttrValue(selector);
-                return ctx.querySelector(`[name="${safeName}"]`);
+            if (strategy === "name") {
+                return ctx.querySelector(`[name="${escapeAttrValue(selector)}"]`);
             }
-            else if (locator.name === "tagName") {
+            if (strategy === "tagName") {
                 return ctx.querySelector(selector);
             }
-            else if (locator.name === "linkText") {
+            if (strategy === "linkText") {
                 return (Array.from(ctx.querySelectorAll("a")).find((a) => a.textContent?.trim() === selector) || null);
             }
-            else if (locator.name === "partialLinkText") {
+            if (strategy === "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 normalizedXPath = normalizeXPath(selector);
-                const el = getElementFromXPath(ctx, normalizedXPath);
-                if (el) {
-                    createLocator(locator, {
-                        value: selector,
-                        isRecorded: String(locator.isRecorded).includes("N") ? "N" : "Y"
-                    });
-                }
-                return el;
-            }
-            else {
-                return ctx.querySelector(selector);
-            }
-        }
+            return null;
+        };
         function findInIframes(docmt, locator, selector) {
             const iframes = docmt.querySelectorAll("iframe");
             for (const iframe of iframes) {
@@ -5659,7 +6486,11 @@
                     const iframeDoc = iframe.contentDocument || iframe.contentWindow?.document;
                     if (!iframeDoc)
                         continue;
-                    const el = resolveElement(iframeDoc, locator, selector);
+                    const el = isAndroidPlatform(platform)
+                        ? resolveAndroidElement(iframeDoc, locator, selector)
+                        : isIOSPlatform(platform)
+                            ? resolveIOSElement(iframeDoc, locator, selector)
+                            : resolveWebElement(iframeDoc, locator, selector);
                     if (el)
                         return el;
                 }
@@ -5677,9 +6508,12 @@
             }
         }
         /** Locator Value Cleaner (Handles Special Scenarios) **/
-        const cleanLocatorValue = (val, type, isRecorded) => {
-            if (!val)
+        const cleanLocatorValue = (val, type, isRecorded, platform) => {
+            if (val == null)
                 return null;
+            if (typeof val !== "string") {
+                val = String(val);
+            }
             let cleaned = val.trim();
             // Return null for empty or literal "null"
             if (!cleaned || cleaned.toLowerCase() === "null")
@@ -5696,8 +6530,15 @@
             if (type === "id" || type === "name") {
                 cleaned = cleaned.replace(/['"]/g, "").trim();
             }
-            if (type === "xpath" && isRecorded === "Y" && !val.startsWith("//"))
-                return null;
+            const isAndroid = String(platform).toLowerCase().includes("android");
+            const isAndroidResourceId = /^[a-zA-Z0-9._]+:id\/[a-zA-Z0-9_]+$/.test(cleaned);
+            if (type === "xpath" &&
+                isRecorded === "Y" &&
+                !cleaned.startsWith("//")) {
+                if (!(isAndroid && isAndroidResourceId)) {
+                    return null;
+                }
+            }
             // Final check for empty strings
             if (!cleaned || /^['"]{2}$/.test(cleaned))
                 return null;
@@ -5733,13 +6574,18 @@
                         }
                         const trimmedSelector = selector.trim();
                         //normal DOM
-                        targetElement = resolveElement(docmt, locator, trimmedSelector);
+                        // normal DOM
+                        targetElement = isAndroidPlatform(platform)
+                            ? resolveAndroidElement(docmt, locator, trimmedSelector)
+                            : isIOSPlatform(platform)
+                                ? resolveIOSElement(docmt, locator, trimmedSelector)
+                                : resolveWebElement(docmt, locator, trimmedSelector);
                         //iframe (if not found)
                         if (!targetElement) {
                             targetElement = findInIframes(docmt, locator, trimmedSelector);
                         }
                         //shadow DOM (if still not found)
-                        if (!targetElement) {
+                        if (!targetElement && !isMobilePlatform(platform) && docmt.body) {
                             targetElement = getElementFromShadowRoot(docmt.body, trimmedSelector);
                         }
                         if (!targetElement) {
@@ -5752,7 +6598,7 @@
                         return finalLocatorsSet.has(key);
                     };
                     if (targetElement) {
-                        const payloadXPaths = record.locators.filter((l) => l.name === "xpath" && l.value);
+                        const payloadXPaths = record.locators.filter((l) => getLocatorStrategy(l.name) === "xpath" && l.value);
                         const payloadCssSelectors = record.locators.filter((l) => isCssSelectorLocator(l) && l.value);
                         for (const px of payloadXPaths) {
                             if (isSameXPathStillValid(px.value, docmt, targetElement))
@@ -5766,17 +6612,19 @@
                                     isSelfHealed: null
                                 });
                         }
-                        const existingXPaths = finalLocators.filter((l) => l.name === "xpath" && l.value);
-                        // Track XPath patterns already used
-                        const usedXPathPatterns = new Set(existingXPaths.map((x) => getXPathPattern(x.value)));
+                        const existingXPaths = finalLocators.filter((l) => getLocatorStrategy(l.name) === "xpath" && l.value);
+                        const usedXPathPatterns = new Set(existingXPaths.map((x) => getXPathPattern(x.value, platform)));
                         const excludedAttributes = [];
-                        const idValue = getId(targetElement);
-                        if (idValue &&
+                        const idValue = getId(targetElement, platform);
+                        if (!isIOSPlatform(platform) &&
+                            idValue &&
                             !locatorExists("id", idValue) &&
                             !isNumberExist(idValue)) {
-                            const prevId = record.locators.find((l) => l.name === "id");
-                            if (isUniqueInDOM(docmt, "id", idValue, targetElement)) {
-                                excludedAttributes.push("id");
+                            const prevId = findLocatorByStrategy("id");
+                            if (isUniqueInDOM(docmt, "id", idValue, targetElement, platform)) {
+                                excludedAttributes.push(isAndroidPlatform(platform)
+                                    ? "resource-id"
+                                    : "id");
                                 createLocator(prevId, {
                                     name: "id",
                                     type: "static",
@@ -5785,26 +6633,56 @@
                                 });
                             }
                         }
-                        const tagName = targetElement.tagName;
-                        if (tagName && !locatorExists("tagName", tagName)) {
-                            const prevTag = record.locators.find((l) => l.name === "tagName");
-                            if (isUniqueInDOM(docmt, "tagName", tagName, targetElement)) {
-                                excludedAttributes.push("tagName");
-                                createLocator(prevTag, {
-                                    name: "tagName",
+                        const accessibilityId = isAndroidPlatform(platform)
+                            ? targetElement.getAttribute("content-desc")
+                            : isIOSPlatform(platform)
+                                ? targetElement.getAttribute("name")
+                                : targetElement.getAttribute("aria-label");
+                        const prevAccessibility = findLocatorByStrategy("accessibilityId");
+                        if (accessibilityId &&
+                            (!isIOSPlatform(platform) || prevAccessibility) &&
+                            !locatorExists("accessibilityId", accessibilityId) &&
+                            !isNumberExist(accessibilityId)) {
+                            if (isUniqueInDOM(docmt, "accessibilityId", accessibilityId, targetElement, platform)) {
+                                excludedAttributes.push(isAndroidPlatform(platform)
+                                    ? "content-desc"
+                                    : isIOSPlatform(platform)
+                                        ? "name"
+                                        : "aria-label");
+                                createLocator(prevAccessibility, {
+                                    name: prevAccessibility?.name || "accessibilityId",
                                     type: "static",
                                     isRecorded: "Y",
-                                    value: tagName
+                                    value: accessibilityId
                                 });
                             }
                         }
+                        if (!isMobilePlatform(platform)) {
+                            const tagName = targetElement.tagName;
+                            if (tagName && !locatorExists("tagName", tagName)) {
+                                const prevTag = findLocatorByStrategy("tagName");
+                                if (isUniqueInDOM(docmt, "tagName", tagName, targetElement, platform)) {
+                                    excludedAttributes.push("tagName");
+                                    createLocator(prevTag, {
+                                        name: "tagName",
+                                        type: "static",
+                                        isRecorded: "Y",
+                                        value: tagName
+                                    });
+                                }
+                            }
+                        }
                         const textValue = getVisibleText(targetElement);
                         if (textValue && !isNumberExist(textValue)) {
-                            const prevLinkText = record.locators.find((l) => l.name === "linkText");
-                            if (isUniqueInDOM(docmt, "linkText", textValue, targetElement)) {
-                                excludedAttributes.push("linkText");
+                            const prevLinkText = findLocatorByStrategy("linkText");
+                            if (isUniqueInDOM(docmt, "linkText", textValue, targetElement, platform)) {
+                                excludedAttributes.push(isAndroidPlatform(platform)
+                                    ? "text"
+                                    : "linkText");
                                 createLocator(prevLinkText, {
-                                    name: "linkText",
+                                    name: isAndroidPlatform(platform)
+                                        ? "name"
+                                        : "linkText",
                                     type: "static",
                                     isRecorded: "Y",
                                     value: textValue
@@ -5812,11 +6690,12 @@
                             }
                         }
                         const nameLocator = getName(targetElement);
-                        if (nameLocator &&
+                        if (!isIOSPlatform(platform) &&
+                            nameLocator &&
                             !locatorExists("name", nameLocator) &&
                             !isNumberExist(nameLocator)) {
-                            const prevName = record.locators.find((l) => l.name === "name");
-                            if (isUniqueInDOM(docmt, "name", nameLocator, targetElement)) {
+                            const prevName = findLocatorByStrategy("name");
+                            if (isUniqueInDOM(docmt, "name", nameLocator, targetElement, platform)) {
                                 excludedAttributes.push("name");
                                 createLocator(prevName, {
                                     name: "name",
@@ -5826,42 +6705,68 @@
                                 });
                             }
                         }
-                        const classValue = getClassName(targetElement);
+                        const classValue = getClassName(targetElement, platform);
+                        const prevClassLocator = findLocatorByStrategy("className");
                         if (classValue &&
+                            (!isIOSPlatform(platform) || prevClassLocator) &&
                             classValue.trim() !== "" &&
                             !classValue.includes(" ") &&
                             !locatorExists("className", classValue) &&
                             !isNumberExist(classValue)) {
-                            const prevClassLocator = record.locators.find((l) => l.name === "className");
-                            if (isUniqueInDOM(docmt, "className", classValue, targetElement)) {
-                                excludedAttributes.push("className");
+                            if (isUniqueInDOM(docmt, "className", classValue, targetElement, platform)) {
+                                excludedAttributes.push(isIOSPlatform(platform) ? "type" : "className");
                                 createLocator(prevClassLocator, {
-                                    name: "className",
+                                    name: prevClassLocator?.name || (isIOSPlatform(platform) ? "class name" : "className"),
                                     type: "static",
                                     isRecorded: "Y",
                                     value: classValue
                                 });
                             }
                         }
-                        parseCssSelectors(targetElement, "single").forEach((cssSelector) => {
-                            if (cssSelector.value &&
-                                !locatorExists("cssSelector", cssSelector.value)) {
-                                createLocator(undefined, {
-                                    name: "cssSelector",
-                                    value: cssSelector.value,
+                        if (isIOSPlatform(platform)) {
+                            const selectorAttributes = Array.from(targetElement.attributes);
+                            const predicateString = iosSelectors.getOptimalPredicateString(docmt, targetElement, selectorAttributes);
+                            const prevPredicate = findLocatorByStrategy("iosPredicateString");
+                            if (prevPredicate && predicateString && !locatorExists(prevPredicate.name, predicateString)) {
+                                createLocator(prevPredicate, {
+                                    name: prevPredicate.name,
                                     type: "static",
-                                    isRecorded: "Y"
+                                    isRecorded: "Y",
+                                    value: predicateString
                                 });
                             }
-                        });
+                            const classChain = iosSelectors.getOptimalClassChain(docmt, targetElement, selectorAttributes);
+                            const prevClassChain = findLocatorByStrategy("iosClassChain");
+                            if (prevClassChain && classChain && !locatorExists(prevClassChain.name, classChain)) {
+                                createLocator(prevClassChain, {
+                                    name: prevClassChain.name,
+                                    type: "static",
+                                    isRecorded: "Y",
+                                    value: classChain
+                                });
+                            }
+                        }
+                        if (!isMobilePlatform(platform)) {
+                            parseCssSelectors(targetElement, "single").forEach((cssSelector) => {
+                                if (cssSelector.value &&
+                                    !locatorExists("cssSelector", cssSelector.value)) {
+                                    createLocator(undefined, {
+                                        name: "cssSelector",
+                                        value: cssSelector.value,
+                                        type: "static",
+                                        isRecorded: "Y"
+                                    });
+                                }
+                            });
+                        }
                         const allAttributes = Array.from(targetElement.attributes);
-                        const includedAttributes = allAttributes.filter((attr) => !excludedAttributes.includes(attr.name));
+                        const includedAttributes = allAttributes.filter((attr) => !excludedAttributes.includes(attr.name) ||
+                            (isIOSPlatform(platform) && attr.name === "name"));
                         //If any direct locator is broken then we consider it as broken xpath
                         let xpathResults = [];
                         try {
                             xpathResults =
-                                parseDOM(targetElement, docmt, false, true, includedAttributes) ??
-                                    [];
+                                parseDOM(targetElement, docmt, false, true, includedAttributes, [], platform) ?? [];
                         }
                         catch (error) {
                             console.error("Error generating XPath candidates:", error);
@@ -5872,10 +6777,12 @@
                             for (const brokenPx of brokenPayloadXPaths) {
                                 if (xpathAdded >= brokenPayloadXPaths.length)
                                     break;
-                                const originalPattern = getXPathPattern(brokenPx.value);
+                                const originalPattern = getXPathPattern(brokenPx.value, platform);
                                 if (usedXPathPatterns.has(originalPattern))
                                     continue;
-                                const match = xpathResults.find((r) => r.value && getXPathPattern(r.value) === originalPattern);
+                                const flatXpaths = getXPathCandidates(xpathResults);
+                                const match = flatXpaths.find((r) => typeof r.value === "string" &&
+                                    getXPathPattern(r.value, platform) === originalPattern);
                                 if (match?.value) {
                                     createLocator(brokenPx, {
                                         name: "xpath",
@@ -5889,23 +6796,34 @@
                                 }
                             }
                             if (xpathAdded < brokenPayloadXPaths.length) {
-                                for (const result of xpathResults) {
-                                    if (xpathAdded >= brokenPayloadXPaths.length)
-                                        break;
-                                    if (!result.value)
-                                        continue;
-                                    const pattern = getXPathPattern(result.value);
-                                    if (usedXPathPatterns.has(pattern))
-                                        continue;
-                                    createLocator(result, {
-                                        name: "xpath",
-                                        value: result.value,
-                                        type: "static",
-                                        isRecorded: "Y",
-                                        isSelfHealed: "Y"
-                                    });
-                                    usedXPathPatterns.add(pattern);
-                                    xpathAdded++;
+                                console.log("xpathResults =", JSON.stringify(xpathResults, null, 2));
+                                for (const group of xpathResults) {
+                                    const values = getXPathCandidates([group]);
+                                    for (const result of values) {
+                                        if (xpathAdded >= brokenPayloadXPaths.length)
+                                            break;
+                                        const xpathValue = typeof result.value === "string"
+                                            ? result.value
+                                            : "";
+                                        if (!xpathValue)
+                                            continue;
+                                        const pattern = getXPathPattern(xpathValue, platform);
+                                        if (usedXPathPatterns.has(pattern))
+                                            continue;
+                                        const baseLocator = brokenPayloadXPaths[xpathAdded] ??
+                                            payloadXPaths[xpathAdded];
+                                        if (!baseLocator)
+                                            continue;
+                                        createLocator(baseLocator, {
+                                            name: "xpath",
+                                            value: xpathValue,
+                                            type: "static",
+                                            isRecorded: "Y",
+                                            isSelfHealed: "Y"
+                                        });
+                                        usedXPathPatterns.add(pattern);
+                                        xpathAdded++;
+                                    }
                                 }
                             }
                         }
@@ -5936,12 +6854,20 @@
                                 console.error("Error processing locator:", locator, error);
                             }
                         }
-                        if (finalLocators.length < 5) {
+                        if (!isIOSPlatform(platform) && finalLocators.length < 5) {
                             const fallbackCandidates = [
-                                { name: "id", value: getId(targetElement) },
+                                { name: "id", value: getId(targetElement, platform) },
                                 { name: "name", value: getName(targetElement) },
-                                { name: "className", value: getClassName(targetElement) },
-                                { name: "linkText", value: getVisibleText(targetElement) }
+                                { name: "className", value: getClassName(targetElement, platform) },
+                                ...(!isMobilePlatform(platform)
+                                    ? [{ name: "tagName", value: targetElement.tagName }]
+                                    : []),
+                                {
+                                    name: isAndroidPlatform(platform)
+                                        ? "name"
+                                        : "linkText",
+                                    value: getVisibleText(targetElement)
+                                }
                             ];
                             for (const candidate of fallbackCandidates) {
                                 if (finalLocators.length > 4)
@@ -5955,7 +6881,7 @@
                                     continue;
                                 if (name === "className" && value.includes(" "))
                                     continue;
-                                if (isUniqueInDOM(docmt, name, value, targetElement)) {
+                                if (isUniqueInDOM(docmt, name, value, targetElement, platform)) {
                                     createLocator(undefined, {
                                         name,
                                         type: "static",
@@ -5965,7 +6891,7 @@
                                     });
                                 }
                             }
-                            if (finalLocators.length < 5) {
+                            if (finalLocators.length < 5 && !isMobilePlatform(platform)) {
                                 parseCssSelectors(targetElement, "multiple").forEach((cssSelector) => {
                                     if (finalLocators.length > 4)
                                         return;
@@ -5973,7 +6899,7 @@
                                         return;
                                     if (locatorExists("cssSelector", cssSelector.value))
                                         return;
-                                    if (!isUniqueInDOM(docmt, "cssSelector", cssSelector.value, targetElement)) {
+                                    if (!isUniqueInDOM(docmt, "cssSelector", cssSelector.value, targetElement, platform)) {
                                         return;
                                     }
                                     createLocator(undefined, {
@@ -5988,7 +6914,7 @@
                         }
                         const finalAutoHealedLocators = finalLocators.map((obj) => ({
                             ...obj,
-                            value: cleanLocatorValue(obj.value, obj.name, obj.isRecorded)
+                            value: cleanLocatorValue(obj.value, obj.name, obj.isRecorded, platform)
                         }));
                         const jsonResult = [
                             {
@@ -6025,121 +6951,6 @@
         return null;
     };
 
-    function getOptimalClassChain(doc, domNode, uniqueAttributes) {
-        try {
-            if (!domNode ||
-                domNode.nodeType !== 1 ||
-                !domNode.tagName ||
-                domNode.tagName === "XCUIElementTypeApplication") {
-                return "";
-            }
-            const tag = domNode.tagName;
-            // Priority attributes
-            const priorityAttrs = ["name", "label", "value"];
-            // ---------- STEP 1 : TRY GOOD ATTRIBUTES ----------
-            for (const attrName of priorityAttrs) {
-                const attr = uniqueAttributes.find(a => a.name === attrName);
-                if (!attr)
-                    continue;
-                let attrValue = attr.value;
-                if (!attrValue)
-                    continue;
-                attrValue = attrValue.trim().replace(/\s+/g, " ");
-                if (isNumberExist(attrValue))
-                    continue;
-                const xpath = `//${tag}[@${attrName}="${attrValue}"]`;
-                let count = 0;
-                try {
-                    count = getCountOfXPath(xpath, domNode, doc);
-                }
-                catch (err) {
-                    console.log(err);
-                    continue;
-                }
-                const hasSpace = /\s/.test(attrValue);
-                if (count === 1) {
-                    if (hasSpace) {
-                        return `/${tag}[\`${attrName} CONTAINS "${attrValue}"\`]`;
-                    }
-                    return `/${tag}[\`${attrName} == "${attrValue}"\`]`;
-                }
-                if (count > 1 && domNode.parentElement) {
-                    const siblings = Array.from(domNode.parentElement.children)
-                        .filter(el => el.tagName === tag);
-                    const index = siblings.indexOf(domNode) + 1;
-                    if (hasSpace) {
-                        return `/${tag}[\`${attrName} CONTAINS "${attrValue}"\`][${index}]`;
-                    }
-                    return `/${tag}[\`${attrName} == "${attrValue}"\`][${index}]`;
-                }
-            }
-            // ---------- STEP 2 : FALLBACK USING TAG INDEX ----------
-            let classChain = `/${tag}`;
-            if (domNode.parentElement) {
-                const siblings = Array.from(domNode.parentElement.children)
-                    .filter(el => el.tagName === tag);
-                if (siblings.length > 1) {
-                    const index = siblings.indexOf(domNode) + 1;
-                    classChain += `[${index}]`;
-                }
-            }
-            const parentChain = getOptimalClassChain(doc, domNode.parentElement, uniqueAttributes);
-            return parentChain + classChain;
-        }
-        catch (error) {
-            console.log(`Unable to generate optimal -ios class chain : ${JSON.stringify(error)}`);
-            return null;
-        }
-    }
-    function getOptimalPredicateString(doc, domNode, uniqueAttributes) {
-        try {
-            // BASE CASE #1: If this isn't an element, we're above the root, or this is `XCUIElementTypeApplication`,
-            // which is not an official XCUITest element, return empty string
-            if (!domNode?.tagName ||
-                domNode?.nodeType !== 1 ||
-                domNode?.tagName === 'XCUIElementTypeApplication') {
-                return '';
-            }
-            // BASE CASE #2: Check all attributes and try to find the best way
-            let xpathAttributes = [];
-            let predicateString = [];
-            for (let attr of uniqueAttributes) {
-                const attrValue = attr.value;
-                const attrName = attr.name;
-                if (attrValue.length === 0) {
-                    continue;
-                }
-                if (attrValue && !isNumberExist(attrValue)) {
-                    xpathAttributes.push(`@${attrName}="${attrValue}"`);
-                    const xpathe = `//*[${xpathAttributes.join(' and ')}]`;
-                    predicateString.push(`${attrName} == "${attrValue}"`);
-                    let othersWithAttr;
-                    // If the XPath does not parse, move to the next unique attribute
-                    try {
-                        othersWithAttr = getCountOfXPath(xpathe, domNode, doc);
-                    }
-                    catch (ign) {
-                        console.log(ign);
-                        continue;
-                    }
-                    // If the attribute isn't actually unique, get it's index too
-                    if (othersWithAttr === 1) {
-                        return predicateString.join(' AND ');
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // If there's an unexpected exception, abort and don't get an XPath
-            console.log(`The most optimal '-ios predicate string' could not be determined because an error was thrown: '${JSON.stringify(error, null, 2)}'`);
-        }
-        return null;
-    }
-    const iosSelectors = {
-        getOptimalClassChain,
-        getOptimalPredicateString
-    };
-
     const createXPathAPI = () => ({
         xpath,
         referenceXpaths: referenceXpath,