@dev-blinq/cucumber_client 1.0.1339-dev → 1.0.1339-stage

package/bin/assets/scripts/unique_locators.js

@@ -1,834 +1,959 @@
 import DOM_Parent from "./dom_parent";
 import { __PW } from "./pw";
 const candidateAttributes = [
-	"slot",
-	"alt",
-	"name",
-	"placeholder",
-	"title",
-	"aria-label",
-	"aria-placeholder",
-	"role",
-	"data-testid",
-	"data-cy",
+  "slot",
+  "alt",
+  "name",
+  "placeholder",
+  "title",
+  "aria-label",
+  "aria-placeholder",
+  "role",
+  "data-testid",
+  "data-cy",
 ];
 function quoteCSSAttributeValue(text) {
-	return `"${text.replace(/["\\]/g, (char) => "\\" + char)}"`;
+  return `"${text.replace(/["\\]/g, (char) => "\\" + char)}"`;
 }
 function makeSelectorForId(id) {
-	return /^[a-zA-Z][a-zA-Z0-9\-\_]+$/.test(id) ? "#" + id : `[id=${quoteCSSAttributeValue(id)}]`;
+  return /^[a-zA-Z][a-zA-Z0-9\-\_]+$/.test(id) ? "#" + id : `[id=${quoteCSSAttributeValue(id)}]`;
 }
 
 function escapeClassName(className) {
-	let result = "";
-	for (let i = 0; i < className.length; i++) result += cssEscapeCharacter(className, i);
-	return result;
+  let result = "";
+  for (let i = 0; i < className.length; i++) result += cssEscapeCharacter(className, i);
+  return result;
 }
 function cssEscapeCharacter(s, i) {
-	const c = s.charCodeAt(i);
-	if (c === 0) return "\uFFFD";
-	if ((c >= 1 && c <= 31) || (c >= 48 && c <= 57 && (i === 0 || (i === 1 && s.charCodeAt(0) === 45))))
-		return "\\" + c.toString(16) + " ";
-	if (i === 0 && c === 45 && s.length === 1) return "\\" + s.charAt(i);
-	if (c >= 128 || c === 45 || c === 95 || (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122))
-		return s.charAt(i);
-	return "\\" + s.charAt(i);
+  const c = s.charCodeAt(i);
+  if (c === 0) return "\uFFFD";
+  if ((c >= 1 && c <= 31) || (c >= 48 && c <= 57 && (i === 0 || (i === 1 && s.charCodeAt(0) === 45))))
+    return "\\" + c.toString(16) + " ";
+  if (i === 0 && c === 45 && s.length === 1) return "\\" + s.charAt(i);
+  if (c >= 128 || c === 45 || c === 95 || (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122))
+    return s.charAt(i);
+  return "\\" + s.charAt(i);
 }
 function escapeRegexForSelector(re) {
-	if (re.unicode || re.unicodeSets) return String(re);
-	return String(re)
-		.replace(/(^|[^\\])(\\\\)*(["'`])/g, "$1$2\\$3")
-		.replace(/>>/g, "\\>\\>");
+  if (re.unicode || re.unicodeSets) return String(re);
+  return String(re)
+    .replace(/(^|[^\\])(\\\\)*(["'`])/g, "$1$2\\$3")
+    .replace(/>>/g, "\\>\\>");
 }
 class LocatorGenerator {
-	constructor(injectedScript, options = {}) {
-		this.locatorStrategies = {
-			text: "basic",
-			no_text: "no_text",
-			custom: "custom",
-			context: "context",
-			digitIgnore: "ignore_digit",
-			text_with_index: "text_with_index",
-		};
-		this.options = options;
-		this.dom_Parent = new DOM_Parent();
-		this.PW = __PW;
-		this.injectedScript = injectedScript;
-		this.cache = new Map();
-	}
-
-	generateUniqueCSSSelector(element, options) {
-		const root = options?.root || window.document;
-		const separator = options?.separator || " > ";
-		const isUnique = options?.isunique || ((selector) => this.getMatchingElements(selector, options).length === 1);
-		const noCSSId = options?.noCSSId || false;
-
-		if (!(element instanceof Element)) return "";
-
-		if (!root.contains(element)) return "";
-
-		let selector = "";
-		const id = element.getAttribute("id");
-		if (id && !/\d/.test(id) && !noCSSId) {
-			selector = makeSelectorForId(id);
-			if (isUnique(selector)) return selector;
-		}
-		if (element.tagName) {
-			selector = element.tagName.toLowerCase() + selector;
-			if (isUnique(selector)) return selector;
-		}
-
-		const classList = Array.from(element.classList).filter((c) => !/\d/.test(c));
-		if (classList.length) {
-			selector += classList.map((c) => "." + escapeClassName(c)).join("");
-			if (isUnique(selector)) return selector;
-		}
-
-		for (let attr of candidateAttributes) {
-			if (element.hasAttribute(attr)) {
-				let value = element.getAttribute(attr);
-				if (value === "") continue;
-				if (/\d/.test(value)) continue;
-				// Escape special characters in attribute value
-				value = value.replace(/[!"#$%&'()*+,./:;<=>?@[\]^`{|}~]/g, "\\$&");
-				selector += `[${attr}=${this.PW.stringUtils.escapeForAttributeSelector(value)}]`;
-			}
-		}
-		if (isUnique(selector)) return selector;
-
-		if (element === root) return selector;
-
-		let parentElement = element.parentElement;
-		if (!parentElement) {
-			// if element is shadowRoot
-			if (element.parentNode instanceof ShadowRoot) {
-				const parentElement = element.parentNode.host;
-				if (parentElement && parentElement !== root) {
-					const parentSelector = this.generateUniqueCSSSelector(parentElement, options);
-					selector = parentSelector + " >>> " + selector;
-					if (isUnique(selector)) return selector;
-				}
-			}
-		} else if (parentElement !== root) {
-			// if is a slotted element
-			if (element.assignedSlot) {
-				parentElement = element.assignedSlot.parentElement ?? element.assignedSlot.parentNode.host;
-			}
-
-			if (parentElement && parentElement !== root) {
-				const parentSelector = this.generateUniqueCSSSelector(parentElement, options);
-
-				selector = parentSelector + separator + selector;
-				if (isUnique(selector)) return selector;
-			}
-		}
-
-		const siblings = element.parentElement?.children;
-		if (siblings) {
-			for (let i = 0; i < siblings.length; i++) {
-				if (siblings[i] === element) {
-					return selector + `:nth-child(${i + 1})`;
-				}
-			}
-		}
-		return "";
-	}
-
-	getMatchingElements(selector, options = {}) {
-		const { root = window.document, prefix, visible = true } = options;
-		if (visible) {
-			selector = `${selector} >> visible=true`;
-		}
-		if (prefix) {
-			selector = `${prefix} >> ${selector}`;
-		}
-		return this.injectedScript.querySelectorAll(this.injectedScript.parseSelector(selector), root);
-	}
-
-	getLocatorStrategies() {
-		return this.locatorStrategies;
-	}
-	getTextLocators(element, options) {
-		const injectedScript = this.injectedScript;
-		const selectorPartLists = this.PW.selectorGenerator.buildTextCandidates(injectedScript, element, options);
-		const result = [];
-		for (const selectorPartList of selectorPartLists) {
-			let tScore = 0;
-			const tSelectorList = [];
-			for (const selectorPart of selectorPartList) {
-				const { engine, selector } = selectorPart;
-				if (engine === "css") {
-					tSelectorList.push(selector);
-				} else {
-					tSelectorList.push(`${engine}=${selector}`);
-				}
-				tScore += selectorPart.score;
-			}
-			const selector = tSelectorList.join(" >> ");
-			const score = tScore / selectorPartList.length;
-			result.push({
-				css: selector,
-				score,
-			});
-		}
-		return result;
-	}
-	getNoTextLocators(element, options) {
-		const injectedScript = this.injectedScript;
-		const locators = this.PW.selectorGenerator.buildNoTextCandidates(injectedScript, element, options);
-		for (const locator of locators) {
-			if (locator.engine === "css") {
-				locator.css = locator.selector;
-			} else {
-				locator.css = `${locator.engine}=${locator.selector}`;
-			}
-			delete locator.engine; // remove engine to avoid memory leak
-			delete locator.selector; // remove selector to avoid memory leak
-		}
-		return locators;
-	}
-	getCustomLocators(element, options) {
-		const { customAttributes = [] } = this.options;
-		if (!customAttributes || !Array.isArray(customAttributes)) {
-			console.error("Custom attributes must be an array");
-			return [];
-		}
-
-		const result = [];
-		let hasAttribures = [];
-		for (const customAttribute of customAttributes) {
-			if (!customAttribute || typeof customAttribute !== "string") {
-				console.error("Custom attribute must be a string");
-				continue;
-			}
-			const val = element.getAttribute(customAttribute);
-			if (val !== null) {
-				hasAttribures.push(customAttribute);
-				result.push({
-					css: `[${customAttribute}=${this.PW.stringUtils.escapeForAttributeSelector(val)}]`,
-					score: 1,
-					priority: 1,
-				});
-			}
-		}
-		return result;
-	}
-	getContextLocators(element, locators) {
-		if (!locators || !Array.isArray(locators)) {
-			console.error("Locators must be an array");
-			return [];
-		}
-		const result = [];
-		try {
-			const textSet = new Set();
-			for (const locator of locators) {
-				const selector = locator.css;
-				if (!selector || typeof selector !== "string") {
-					console.error("Locator must have a valid css selector");
-					continue;
-				}
-				const parseResult = this.injectedScript.parseSelector(selector);
-				const parts = parseResult.parts;
-				if (!parts || !Array.isArray(parts) || parts.length === 0) {
-					console.error("Locator must have a valid css selector");
-					continue;
-				}
-				// ignore parts.length < 3
-				if (parts.length < 3) {
-					// console.warn("Locator must have at least 3 parts to be a context locator");
-					continue;
-				}
-				const firstPart = parts[0];
-				if (firstPart.name !== "internal:text") {
-					// console.warn("Locator must have internal:text as the first part to be a context locator");
-					continue;
-				}
-				const textBody = firstPart.body;
-				if (!textBody || typeof textBody !== "string" || textBody.length === 0) {
-					console.error("Locator must have a valid text in the first part to be a context locator");
-					continue;
-				}
-				const secondPart = parts[1];
-				if (secondPart.name !== "xpath") {
-					continue;
-				}
-				const xpath = secondPart.body;
-				if (!xpath || typeof xpath !== "string" || xpath.length === 0) {
-					// console.error("Locator must have a valid xpath in the second part to be a context locator");
-					continue;
-				}
-				const climbString = secondPart.body;
-				if (!climbString || typeof climbString !== "string" || climbString.length === 0) {
-					continue;
-				}
-				const climbStringRegex = /(\.\.)(\/\.\.)*/;
-				try {
-					const match = climbStringRegex.test(climbString);
-					if (match) {
-						const climbCount = climbString.split("..").length - 1;
-						const lastIndex = selector.indexOf(climbString);
-						const restOfSelector = selector.substring(lastIndex + climbString.length + 3).trim();
-						if (restOfSelector.length === 0) {
-							// console.warn("Locator must have a valid rest of selector after the xpath part to
-							// be a context locator");
-							continue;
-						}
-
-						const textLocator = `internal:text=${textBody}`;
-						const elements = this.getMatchingElements(textLocator, {});
-						if (elements.length !== 1) {
-							// throw new Error("Context locator must have exactly one element matching the text part");
-							console.error("Context locator must have exactly one element matching the text part");
-							continue;
-						}
-						const textElement = elements[0];
-						// const text = this.PW.selectorUtils.elementText(textElement);
-						const text = this.injectedScript.utils.elementText(new Map(), textElement).full;
-
-						const fullSelector = `${textLocator} >> xpath=${xpath} >> ${restOfSelector}`;
-						const fullElements = this.getMatchingElements(fullSelector, {});
-						if (fullElements.length !== 1) {
-							// throw new Error("Context locator must have exactly one element matching the full selector");
-							console.error("Context locator must have exactly one element matching the full selector");
-							continue;
-						}
-						const fullElement = fullElements[0];
-						if (fullElement !== element) {
-							// throw new Error("Context locator must have the text element as the full element");
-							console.error("Context locator must have the text element as the full element");
-							continue;
-						}
-						if (!textSet.has(text)) {
-							textSet.add(text);
-							const loc = {
-								css: restOfSelector,
-								climb: climbCount,
-								text,
-								priority: 1,
-							};
-							if (locator.index !== undefined) {
-								loc.index = locator.index;
-							}
-							result.push(loc);
-						}
-					}
-				} catch (error) {
-					console.error("Error parsing climb string:", error);
-					continue;
-				}
-			}
-		} catch (error) {
-			console.error("Error generating context locators:", error);
-		}
-		// Sort by text length to prioritize shorter texts
-		result.sort((a, b) => a.text.length - b.text.length);
-		return result;
-	}
-	getDigitIgnoreLocators(element, locators) {
-		const result = [];
-		try {
-			if (!locators || !Array.isArray(locators)) {
-				console.error("Locators must be an array");
-				return [];
-			}
-
-			for (const locator of locators) {
-				const selector = locator.css;
-				if (!selector || typeof selector !== "string") {
-					console.error("Locator must have a valid css selector");
-					continue;
-				}
-				const parseresult = this.injectedScript.parseSelector(selector);
-				const parts = parseresult.parts;
-				if (!parts || !Array.isArray(parts) || parts.length === 0) {
-					console.error("Locator must have a valid css selector");
-					continue;
-				}
-				let finalSelector = "";
-				let hasDigitsInText = false;
-				for (const part of parts) {
-					if (part.name !== "internal:text") {
-						finalSelector += `${part.name === "css" ? "" : part.name + "="}${part.source} >> `;
-						continue;
-					}
-					if (typeof part.body !== "string" || part.body.length === 0) {
-						// console.error("Locator must have a valid text in the first part to be a digit ignore locator");
-						finalSelector += `${part.name === "css" ? "" : part.name + "="}${part.source} >> `;
-						continue;
-					}
-					const text = part.body;
-					const digitsRegex = /\d+/g;
-					hasDigitsInText = digitsRegex.test(text);
-
-					let pattern = this.PW.stringUtils.escapeRegExp(text.substring(1, text.length - 2));
-					const re = new RegExp(pattern);
-
-					finalSelector += `internal:text=${escapeRegexForSelector(re).replace(digitsRegex, "\\d+")} >> `;
-				}
-				if (!hasDigitsInText) {
-					continue;
-				}
-				if (finalSelector.endsWith(` >> `)) {
-					finalSelector = finalSelector.slice(0, -4);
-				}
-				if (finalSelector) {
-					const elements = this.getMatchingElements(finalSelector, {});
-					if (elements.length !== 1) {
-						console.error("Digit ignore locator must have exactly one element matching the final selector");
-						continue;
-					}
-					if (elements[0] !== element) {
-						console.error("Digit ignore locator must match the original element");
-						continue;
-					}
-					result.push({
-						css: finalSelector,
-						priority: locator.priority || 1,
-					});
-				}
-			}
-		} catch (error) {
-			console.error("Error generating digit ignore locators:", error);
-		}
-
-		return result;
-	}
-	getTextwithIndexLocators(locators) {
-		if (!locators || !Array.isArray(locators)) {
-			console.error("Locators must be an array");
-			return [];
-		}
-		const result = [];
-		try {
-			for (const locator of locators) {
-				if (!locator || !locator.css || typeof locator.css !== "string") {
-					console.error("Locator must have a valid css selector");
-					continue;
-				}
-				const index = locator.index;
-				if (typeof index !== "number" || index < 0) {
-					// console.error("Locator must have a valid index");
-					continue;
-				}
-				result.push(locator);
-			}
-		} catch (error) {
-			console.error("Error getting text with index locators:", error);
-		}
-		return result;
-	}
-
-	getXPathSelector(climb) {
-		if (typeof climb !== "number" || climb < 0) {
-			// throw new Error("Climb must be a non-negative integer");
-			console.error("Climb must be a non-negative integer");
-			return "";
-		}
-		if (climb === 0) return "";
-		let selector = "xpath=..";
-		if (climb === 1) {
-			return selector;
-		}
-		for (let i = 1; i < climb; i++) {
-			selector += "/..";
-		}
-		return selector;
-	}
-	categorizeLocators(element, locators, options) {
-		const unique = [];
-		const nonUnique = [];
-		try {
-			for (const locator of locators) {
-				const elements = this.getMatchingElements(locator.css, options);
-				if (elements.length === 0) {
-					console.warn(`No elements found for locator: ${locator.css}`);
-					continue;
-				} else if (elements.length === 1) {
-					if (element === elements[0]) {
-						locator.priority = 1;
-						unique.push(locator);
-					} else if (element.contains(elements[0])) {
-						locator.priority = 1;
-						const climb = this.dom_Parent.getClimbCountToParent(elements[0], element);
-						const climbSelector = this.getXPathSelector(climb);
-						const newSelector = `${locator.css} >> ${climbSelector}`;
-						locator.css = newSelector;
-						unique.push(locator);
-					}
-				} else {
-					locator.priority = 2;
-					locator.elements = elements;
-					nonUnique.push(locator);
-				}
-			}
-		} catch (error) {
-			console.error("Error categorizing locators:", error);
-		}
-		return { unique, nonUnique };
-	}
-
-	getUniqueLocators(element, locatorGenerator = this.getNoTextLocators, options = {}) {
-		return this.getUniqueLocators2(element, locatorGenerator, options);
-	}
-	getUniqueLocators1(element, locatorGenerator = this.getNoTextLocators, options = {}) {
-		try {
-			const { maxLocators = 5, root = window.document.body, next = "LCA", minLocators = 3 } = options;
-
-			if (!element) {
-				return [];
-			}
-			if (element === root) {
-				if (element === window.document.documentElement) {
-					return [
-						{
-							css: "html",
-							score: 1,
-							priority: 1,
-						},
-						{
-							css: ":root",
-							score: 1,
-							priority: 1,
-						},
-					];
-				} else {
-					return [
-						{
-							css: ":root",
-							score: 1,
-							priority: 1,
-							// }, {
-							// 	css: ":root",
-							// 	score: 1,
-							// 	priority: 1,
-						},
-					];
-				}
-			}
-
-			console.log("Generating locators for element:", element);
-			const locators = locatorGenerator(element, options);
-			console.log("Generated locators:", locators);
-			if (!locators || !Array.isArray(locators)) {
-				// throw new Error("Locator generator did not return an array of locators");
-				console.error("Locator generator did not return an array of locators");
-				return [];
-			}
-
-			console.log("Categorizing locators for element:", element);
-			const categorizedLocators = this.categorizeLocators(element, locators, options);
-			console.log("Categorized locators:", categorizedLocators);
-			// categorizedLocators.unique = limitLocators(categorizedLocators.unique, options);
-			// categorizedLocators.nonUnique = limitLocators(categorizedLocators.nonUnique, options);
-
-			const { unique, nonUnique } = categorizedLocators;
-			const result = [];
-			if (unique.length > 0) {
-				result.push(...unique);
-			}
-			if (result.length >= maxLocators) {
-				return result.slice(0, maxLocators);
-			}
-			let nextElement = null;
-			for (const locator of nonUnique) {
-				const selector = locator.css ?? locator.selector;
-				const elements = locator.elements || this.getMatchingElements(selector, options);
-
-				if (next === "parent") {
-					nextElement = this.dom_Parent.getActualParent(element);
-				} else {
-					// find the branching element the child of common parent that contains the element
-					const branchingParent = this.dom_Parent.findBranchingParent(elements, element);
-					nextElement = branchingParent;
-				}
-
-				if (nextElement && nextElement !== element) {
-					if (root.contains(nextElement)) {
-						const _result = this.getUniqueLocators(nextElement, locatorGenerator, {
-							...options,
-							root,
-						});
-						for (const _locator of _result) {
-							if (result.length >= maxLocators) {
-								return result.slice(0, maxLocators);
-							}
-							const _selector = _locator.css ?? _locator.selector;
-							const fullSelector = `${_selector} >> ${selector}`;
-							const _elements = this.getMatchingElements(fullSelector, options);
-							const effectiveScore = (_locator.score + locator.score) / 2 + 100;
-							if (_elements.length === 1 && _elements[0] === element) {
-								_locator.css = fullSelector;
-								_locator.score = effectiveScore;
-								_locator.priority = 1; // unique locators have higher priority
-								result.push(_locator);
-							} else {
-								const index = _elements.indexOf(element);
-								if (index !== -1 && index < 5) {
-									// _locator.selector = fullSelector;
-									_locator.css = fullSelector;
-									_locator.index = index;
-									_locator.priority = 2; // non-unique locators have lower priority
-									_locator.score = effectiveScore;
-									result.push(_locator);
-								}
-							}
-						}
-					} else {
-						const index = elements.indexOf(element);
-						if (index !== -1 && index < 5) {
-							locator.index = index;
-							locator.priority = 2; // non-unique locators have lower priority
-							result.push(locator);
-						}
-					}
-				} else {
-					const index = elements.indexOf(element);
-					if (index !== -1 && index < 5) {
-						locator.index = index;
-						locator.priority = 2; // non-unique locators have lower priority
-						result.push(locator);
-					}
-				}
-
-				delete locator.elements; // remove elements to avoid memory leak
-				delete locator.strategy;
-				delete locator.engine;
-				delete locator.selector;
-			}
-
-			if (result.length < minLocators && root && root.contains(element)) {
-				const parent = this.dom_Parent.getActualParent(element);
-				const locs = this.getUniqueLocators(parent, locatorGenerator, {
-					...options,
-					root,
-				});
-				result.push(...locs);
-			}
-
-			result.sort((a, b) => a.score - b.score);
-			console.log("Final locators:", result, element);
-			console.groupEnd();
-			return result.slice(0, maxLocators);
-		} catch (error) {
-			console.error("Error in getUniqueLocators:", error);
-			return [];
-		}
-	}
-
-	getUniqueLocators2(element, locatorGenerator = this.getNoTextLocators, options = {}) {
-		try {
-			const { maxLocators = 5, root = window.document.body } = options;
-
-			if (!element) {
-				return [];
-			}
-			if (element === root) {
-				if (element === window.document.documentElement) {
-					return [
-						{
-							css: "html",
-							score: 1,
-							priority: 1,
-						},
-						{
-							css: ":root",
-							score: 1,
-							priority: 1,
-						},
-					];
-				} else {
-					return [
-						{
-							css: ":root",
-							score: 1,
-							priority: 1,
-						},
-					];
-				}
-			}
-
-			console.log("Generating locators for element:", element);
-			const locators = locatorGenerator(element, options);
-			console.log("Generated locators:", locators);
-			if (!locators || !Array.isArray(locators)) {
-				console.error("Locator generator did not return an array of locators");
-				return [];
-			}
-
-			console.log("Categorizing locators for element:", element);
-			const categorizedLocators = this.categorizeLocators(element, locators, options);
-			console.log("Categorized locators:", categorizedLocators);
-
-			const { unique, nonUnique } = categorizedLocators;
-			const result = [];
-			if (unique.length > 0) {
-				result.push(...unique);
-			}
-			if (result.length >= maxLocators) {
-				return result.slice(0, maxLocators);
-			}
-
-			const elementsCache = new Map();
-
-			const allAncestors = this.dom_Parent.getFullAncestorChainToRoot(element, root);
-			allAncestors.shift(); // remove the element itself from the ancestors
-
-			const ancestorLocators = [];
-			for (const ancestor of allAncestors) {
-				const _locators = locatorGenerator(ancestor, options);
-				if (!_locators || !Array.isArray(_locators) || _locators.length === 0) {
-					continue;
-				}
-				const _categorized = this.categorizeLocators(ancestor, _locators, options);
-				ancestorLocators.push({
-					element: ancestor,
-					locators: _categorized,
-				});
-				elementsCache.set(ancestor, _categorized);
-				if (_categorized.unique.length > 0) {
-					break;
-				}
-			}
-
-			const uniqueAncestor = ancestorLocators[ancestorLocators.length - 1];
-
-			for (const locator of nonUnique) {
-				const selector = locator.css ?? locator.selector;
-				const elements = locator.elements || this.getMatchingElements(selector, options);
-				if (elements.length === 0) {
-					console.warn(`No elements found for locator: ${selector}`);
-					continue;
-				}
-
-				for (const unique_locator of uniqueAncestor.locators.unique) {
-					const fullSelector = `${unique_locator.css} >> ${selector}`;
-					const elements = this.getMatchingElements(fullSelector, options);
-					if (elements.length === 1 && elements[0] === element) {
-						const effectiveScore = (unique_locator.score + locator.score) / 2 + 100;
-						const newLocator = {
-							...unique_locator,
-							css: fullSelector,
-							score: effectiveScore,
-							priority: 1, // unique locators have higher priority
-						};
-						result.push(newLocator);
-					} else {
-						const index = elements.indexOf(element);
-						if (index !== -1 && index < 5) {
-							const effectiveScore = (unique_locator.score + locator.score) / 2;
-							const newLocator = {
-								...unique_locator,
-								css: fullSelector,
-								index,
-								score: effectiveScore + 200,
-								priority: 2, // non-unique locators have lower priority
-							};
-							result.push(newLocator);
-						}
-					}
-				}
-			}
-			result.sort((a, b) => a.score - b.score);
-			console.log("Final locators:", result, element);
-			console.groupEnd();
-			return result.slice(0, maxLocators);
-		} catch (error) {
-			console.error("Error in getUniqueLocators:", error);
-			return [];
-		}
-	}
-	getElementLocators(element, options = {}) {
-		try {
-			const { excludeText = false } = options;
-
-			const allStrategyLocators = {};
-			if (this.options?.customAttributes) {
-				console.groupCollapsed("Generating Custom locators for element:", element);
-				const customLocators = this.getUniqueLocators(element, this.getCustomLocators.bind(this), options);
-				if (customLocators.length > 0) {
-					allStrategyLocators[this.locatorStrategies.custom] = customLocators;
-				}
-			}
-			console.groupEnd();
-			if (!excludeText) {
-				console.groupCollapsed("Generating Text locators for element:", element);
-				const basicLocators = this.getUniqueLocators(element, this.getTextLocators.bind(this), options);
-				console.groupEnd();
-				if (basicLocators.length > 0) {
-					allStrategyLocators[this.locatorStrategies.text] = basicLocators;
-				}
-
-				const textWithIndexLocators = this.getTextwithIndexLocators(basicLocators);
-				if (textWithIndexLocators.length > 0) {
-					allStrategyLocators[this.locatorStrategies.text_with_index] = textWithIndexLocators;
-				}
-				const digitIgnoreLocators = this.getDigitIgnoreLocators(element, basicLocators);
-				if (digitIgnoreLocators.length > 0) {
-					allStrategyLocators[this.locatorStrategies.digitIgnore] = digitIgnoreLocators;
-				}
-				const contextLocators = this.getContextLocators(element, basicLocators);
-				if (contextLocators.length > 0) {
-					allStrategyLocators[this.locatorStrategies.context] = contextLocators;
-				}
-			}
-			console.groupCollapsed("Generating No Text locators for element:", element);
-			const noTextLocators = this.getUniqueLocators(element, this.getNoTextLocators.bind(this), options);
-
-			if (noTextLocators.length > 0) {
-				allStrategyLocators[this.locatorStrategies.no_text] = noTextLocators;
-			} else {
-				const _locators = [];
-				_locators.push({
-					css: this.generateUniqueCSSSelector(element, options),
-					score: 500,
-					priority: 3,
-				});
-				if (_locators.length > 0) {
-					allStrategyLocators[this.locatorStrategies.no_text] = _locators;
-				}
-			}
-			console.groupEnd();
-
-			let bestStrategy = this.getBestStrategy(allStrategyLocators);
-			if (!bestStrategy) {
-				throw new Error("No locators found for element: " + element);
-			}
-			allStrategyLocators.strategy = bestStrategy;
-
-			const locators = allStrategyLocators[allStrategyLocators.strategy] ?? [];
-			const result = {
-				locators,
-				element_name: "",
-			};
-			if (Object.keys(allStrategyLocators).length > 1) {
-				result.allStrategyLocators = allStrategyLocators;
-			}
-			console.log("Generated locators:", result);
-			return result;
-		} catch (error) {
-			console.error("Error in getElementLocators:", error);
-			return {
-				locators: [],
-				element_name: "",
-			};
-		}
-	}
-	getBestStrategy(allStrategyLocators) {
-		const orderedPriorities = [
-			this.locatorStrategies.custom,
-			this.locatorStrategies.context,
-			this.locatorStrategies.text,
-			this.locatorStrategies.text_with_index,
-			this.locatorStrategies.digitIgnore,
-			this.locatorStrategies.no_text,
-		];
-		for (const strategy of orderedPriorities) {
-			if (allStrategyLocators[strategy] && allStrategyLocators[strategy].length > 0) {
-				return strategy;
-			}
-		}
-		return null;
-	}
+  constructor(injectedScript, options = {}) {
+    this.locatorStrategies = {
+      text: "basic",
+      no_text: "no_text",
+      custom: "custom",
+      context: "context",
+      digitIgnore: "ignore_digit",
+      text_with_index: "text_with_index",
+    };
+    this.options = options;
+    this.dom_Parent = new DOM_Parent();
+    this.PW = __PW;
+    this.injectedScript = injectedScript;
+    this.cache = new Map();
+  }
+
+  generateUniqueCSSSelector(element, options) {
+    const root = options?.root || window.document;
+    const separator = options?.separator || " > ";
+    const isUnique = options?.isunique || ((selector) => this.getMatchingElements(selector, options).length === 1);
+    const noCSSId = options?.noCSSId || false;
+
+    if (!(element instanceof Element)) return "";
+
+    if (!root.contains(element)) return "";
+
+    let selector = "";
+    const id = element.getAttribute("id");
+    if (id && !/\d/.test(id) && !noCSSId) {
+      selector = makeSelectorForId(id);
+      if (isUnique(selector)) return selector;
+    }
+    if (element.tagName) {
+      selector = element.tagName.toLowerCase() + selector;
+      if (isUnique(selector)) return selector;
+    }
+
+    const classList = Array.from(element.classList).filter((c) => !/\d/.test(c));
+    if (classList.length) {
+      selector += classList.map((c) => "." + escapeClassName(c)).join("");
+      if (isUnique(selector)) return selector;
+    }
+
+    for (let attr of candidateAttributes) {
+      if (element.hasAttribute(attr)) {
+        let value = element.getAttribute(attr);
+        if (value === "") continue;
+        if (/\d/.test(value)) continue;
+        // Escape special characters in attribute value
+        value = value.replace(/[!"#$%&'()*+,./:;<=>?@[\]^`{|}~]/g, "\\$&");
+        selector += `[${attr}=${this.PW.stringUtils.escapeForAttributeSelector(value)}]`;
+      }
+    }
+    if (isUnique(selector)) return selector;
+
+    if (element === root) return selector;
+
+    let parentElement = element.parentElement;
+    if (!parentElement) {
+      // if element is shadowRoot
+      if (element.parentNode instanceof ShadowRoot) {
+        const parentElement = element.parentNode.host;
+        if (parentElement && parentElement !== root) {
+          const parentSelector = this.generateUniqueCSSSelector(parentElement, options);
+          selector = parentSelector + " >>> " + selector;
+          if (isUnique(selector)) return selector;
+        }
+      }
+    } else if (parentElement !== root) {
+      // if is a slotted element
+      if (element.assignedSlot) {
+        parentElement = element.assignedSlot.parentElement ?? element.assignedSlot.parentNode.host;
+      }
+
+      if (parentElement && parentElement !== root) {
+        const parentSelector = this.generateUniqueCSSSelector(parentElement, options);
+
+        selector = parentSelector + separator + selector;
+        if (isUnique(selector)) return selector;
+      }
+    }
+
+    const siblings = element.parentElement?.children;
+    if (siblings) {
+      for (let i = 0; i < siblings.length; i++) {
+        if (siblings[i] === element) {
+          return selector + `:nth-child(${i + 1})`;
+        }
+      }
+    }
+    return "";
+  }
+
+  getMatchingElements(selector, options = {}) {
+    const { root = window.document, prefix, visible = true } = options;
+    if (visible) {
+      selector = `${selector} >> visible=true`;
+    }
+    if (prefix) {
+      selector = `${prefix} >> ${selector}`;
+    }
+    return this.injectedScript.querySelectorAll(this.injectedScript.parseSelector(selector), root);
+  }
+
+  getLocatorStrategies() {
+    return this.locatorStrategies;
+  }
+  getTextLocators(element, options) {
+    const injectedScript = this.injectedScript;
+    const { textToIgnore = null } = options;
+    const selectorPartLists = this.PW.selectorGenerator.buildTextCandidates(injectedScript, element, options);
+    const result = [];
+    for (const selectorPartList of selectorPartLists) {
+      let tScore = 0;
+      const tSelectorList = [];
+      for (const selectorPart of selectorPartList) {
+        const { engine, selector } = selectorPart;
+        if (textToIgnore && selector.includes(textToIgnore)) {
+          continue;
+        }
+        if (engine === "css") {
+          tSelectorList.push(selector);
+        } else {
+          tSelectorList.push(`${engine}=${selector}`);
+        }
+        tScore += selectorPart.score;
+      }
+      const selector = tSelectorList.join(" >> ");
+      const score = tScore / selectorPartList.length;
+      result.push({
+        css: selector,
+        score,
+      });
+    }
+    return result;
+  }
+  getNoTextLocators(element, options) {
+    const injectedScript = this.injectedScript;
+    const locators = this.PW.selectorGenerator.buildNoTextCandidates(injectedScript, element, options);
+    for (const locator of locators) {
+      if (locator.engine === "css") {
+        locator.css = locator.selector;
+      } else {
+        locator.css = `${locator.engine}=${locator.selector}`;
+      }
+      delete locator.engine; // remove engine to avoid memory leak
+      delete locator.selector; // remove selector to avoid memory leak
+    }
+    return locators;
+  }
+  getCustomLocators(element, options) {
+    const { customAttributes = [] } = this.options;
+    if (!customAttributes || !Array.isArray(customAttributes)) {
+      console.error("Custom attributes must be an array");
+      return [];
+    }
+
+    const result = [];
+    let hasAttribures = [];
+    for (const customAttribute of customAttributes) {
+      if (!customAttribute || typeof customAttribute !== "string") {
+        console.error("Custom attribute must be a string");
+        continue;
+      }
+      const val = element.getAttribute(customAttribute);
+      if (val !== null) {
+        hasAttribures.push(customAttribute);
+        result.push({
+          css: `[${customAttribute}=${this.PW.stringUtils.escapeForAttributeSelector(val)}]`,
+          score: 1,
+          priority: 1,
+        });
+      }
+    }
+    return result;
+  }
+  toContextLocators(element, contextElement) {
+    const commonParent = this.dom_Parent.findLowestCommonAncestor([contextElement, element]);
+    const climb = this.dom_Parent.getClimbCountToParent(contextElement, commonParent);
+    const text = contextElement.innerText.trim();
+
+    const prefix = `internal:text="${text}" >> ${this.getXPathSelector(climb)}`;
+    const result = this.getElementLocators(element, {
+      root: commonParent,
+      strategies: {
+        [this.locatorStrategies.custom]: true,
+        [this.locatorStrategies.text]: true,
+        [this.locatorStrategies.no_text]: true,
+      },
+      prefix,
+    });
+
+    const attachContextToLocators = (locs) => {
+      locs.forEach((loc) => {
+        loc.climb = climb;
+        loc.text = text;
+      });
+    };
+
+    const allStrategyLocators = result.allStrategyLocators;
+    const locators = result.locators;
+    if (allStrategyLocators) {
+      const allLocators = [];
+      for (const strategy in allStrategyLocators) {
+        if (strategy === "strategy") continue;
+        const locators = allStrategyLocators[strategy];
+        if (locators.length === 0) continue;
+        allLocators.push(...locators);
+        allStrategyLocators[strategy] = [];
+      }
+      attachContextToLocators(allLocators);
+      allStrategyLocators[this.locatorStrategies.context] = allLocators;
+      allStrategyLocators.strategy = this.locatorStrategies.context;
+      result.locators = allLocators;
+      return result;
+    }
+    if (locators) {
+      attachContextToLocators(locators);
+      return result;
+    }
+    return result;
+  }
+  getContextLocators(element, locators) {
+    if (!locators || !Array.isArray(locators)) {
+      console.error("Locators must be an array");
+      return [];
+    }
+    const result = [];
+    try {
+      const textSet = new Set();
+      for (const locator of locators) {
+        const selector = locator.css;
+        if (!selector || typeof selector !== "string") {
+          console.error("Locator must have a valid css selector");
+          continue;
+        }
+        const parseResult = this.injectedScript.parseSelector(selector);
+        const parts = parseResult.parts;
+        if (!parts || !Array.isArray(parts) || parts.length === 0) {
+          console.error("Locator must have a valid css selector");
+          continue;
+        }
+        // ignore parts.length < 3
+        if (parts.length < 3) {
+          // console.warn("Locator must have at least 3 parts to be a context locator");
+          continue;
+        }
+        const firstPart = parts[0];
+        if (firstPart.name !== "internal:text") {
+          // console.warn("Locator must have internal:text as the first part to be a context locator");
+          continue;
+        }
+        const textBody = firstPart.body;
+        if (!textBody || typeof textBody !== "string" || textBody.length === 0) {
+          console.error("Locator must have a valid text in the first part to be a context locator");
+          continue;
+        }
+        const secondPart = parts[1];
+        if (secondPart.name !== "xpath") {
+          continue;
+        }
+        const xpath = secondPart.body;
+        if (!xpath || typeof xpath !== "string" || xpath.length === 0) {
+          // console.error("Locator must have a valid xpath in the second part to be a context locator");
+          continue;
+        }
+        const climbString = secondPart.body;
+        if (!climbString || typeof climbString !== "string" || climbString.length === 0) {
+          continue;
+        }
+        const climbStringRegex = /(\.\.)(\/\.\.)*/;
+        try {
+          const match = climbStringRegex.test(climbString);
+          if (match) {
+            const climbCount = climbString.split("..").length - 1;
+            const lastIndex = selector.indexOf(climbString);
+            const restOfSelector = selector.substring(lastIndex + climbString.length + 3).trim();
+            if (restOfSelector.length === 0) {
+              // console.warn("Locator must have a valid rest of selector after the xpath part to
+              // be a context locator");
+              continue;
+            }
+
+            const textLocator = `internal:text=${textBody}`;
+            const elements = this.getMatchingElements(textLocator, {});
+            if (elements.length !== 1) {
+              // throw new Error("Context locator must have exactly one element matching the text part");
+              console.error("Context locator must have exactly one element matching the text part");
+              continue;
+            }
+            const textElement = elements[0];
+            // const text = this.PW.selectorUtils.elementText(textElement);
+            const text = this.injectedScript.utils.elementText(new Map(), textElement).full.trim();
+
+            const fullSelector = `${textLocator} >> xpath=${xpath} >> ${restOfSelector}`;
+            const fullElements = this.getMatchingElements(fullSelector, {});
+            if (fullElements.length !== 1) {
+              // throw new Error("Context locator must have exactly one element matching the full selector");
+              console.error("Context locator must have exactly one element matching the full selector");
+              continue;
+            }
+            const fullElement = fullElements[0];
+            if (fullElement !== element) {
+              // throw new Error("Context locator must have the text element as the full element");
+              console.error("Context locator must have the text element as the full element");
+              continue;
+            }
+            if (!textSet.has(text)) {
+              textSet.add(text);
+              const loc = {
+                css: restOfSelector,
+                climb: climbCount,
+                text,
+                priority: 1,
+              };
+              if (locator.index !== undefined) {
+                loc.index = locator.index;
+              }
+              result.push(loc);
+            }
+          }
+        } catch (error) {
+          console.error("Error parsing climb string:", error);
+          continue;
+        }
+      }
+    } catch (error) {
+      console.error("Error generating context locators:", error);
+    }
+    // Sort by text length to prioritize shorter texts
+    result.sort((a, b) => a.text.length - b.text.length);
+    return result;
+  }
+  getDigitIgnoreLocators(element, locators) {
+    const result = [];
+    try {
+      if (!locators || !Array.isArray(locators)) {
+        console.error("Locators must be an array");
+        return [];
+      }
+
+      for (const locator of locators) {
+        const selector = locator.css;
+        if (!selector || typeof selector !== "string") {
+          console.error("Locator must have a valid css selector");
+          continue;
+        }
+        const parseresult = this.injectedScript.parseSelector(selector);
+        const parts = parseresult.parts;
+        if (!parts || !Array.isArray(parts) || parts.length === 0) {
+          console.error("Locator must have a valid css selector");
+          continue;
+        }
+        let finalSelector = "";
+        let hasDigitsInText = false;
+        for (const part of parts) {
+          if (part.name !== "internal:text") {
+            finalSelector += `${part.name === "css" ? "" : part.name + "="}${part.source} >> `;
+            continue;
+          }
+          if (typeof part.body !== "string" || part.body.length === 0) {
+            // console.error("Locator must have a valid text in the first part to be a digit ignore locator");
+            finalSelector += `${part.name === "css" ? "" : part.name + "="}${part.source} >> `;
+            continue;
+          }
+          const text = part.body;
+          const digitsRegex = /\d+/g;
+          hasDigitsInText = digitsRegex.test(text);
+
+          let pattern = this.PW.stringUtils.escapeRegExp(text.substring(1, text.length - 2));
+          const re = new RegExp(pattern);
+
+          finalSelector += `internal:text=${escapeRegexForSelector(re).replace(digitsRegex, "\\d+")} >> `;
+        }
+        if (!hasDigitsInText) {
+          continue;
+        }
+        if (finalSelector.endsWith(` >> `)) {
+          finalSelector = finalSelector.slice(0, -4);
+        }
+        if (finalSelector) {
+          const elements = this.getMatchingElements(finalSelector, {});
+          if (elements.length !== 1) {
+            console.error("Digit ignore locator must have exactly one element matching the final selector");
+            continue;
+          }
+          if (elements[0] !== element) {
+            console.error("Digit ignore locator must match the original element");
+            continue;
+          }
+          result.push({
+            css: finalSelector,
+            priority: locator.priority || 1,
+          });
+        }
+      }
+    } catch (error) {
+      console.error("Error generating digit ignore locators:", error);
+    }
+
+    return result;
+  }
+  getTextwithIndexLocators(locators) {
+    if (!locators || !Array.isArray(locators)) {
+      console.error("Locators must be an array");
+      return [];
+    }
+    const result = [];
+    try {
+      for (const locator of locators) {
+        if (!locator || !locator.css || typeof locator.css !== "string") {
+          console.error("Locator must have a valid css selector");
+          continue;
+        }
+        const index = locator.index;
+        if (typeof index !== "number" || index < 0) {
+          // console.error("Locator must have a valid index");
+          continue;
+        }
+        result.push(locator);
+      }
+    } catch (error) {
+      console.error("Error getting text with index locators:", error);
+    }
+    return result;
+  }
+
+  getXPathSelector(climb) {
+    if (typeof climb !== "number" || climb < 0) {
+      // throw new Error("Climb must be a non-negative integer");
+      console.error("Climb must be a non-negative integer");
+      return "";
+    }
+    if (climb === 0) return "";
+    let selector = "xpath=..";
+    if (climb === 1) {
+      return selector;
+    }
+    for (let i = 1; i < climb; i++) {
+      selector += "/..";
+    }
+    return selector;
+  }
+  categorizeLocators(element, locators, options) {
+    const unique = [];
+    const nonUnique = [];
+    const visible = options?.visible ?? true;
+    try {
+      for (const locator of locators) {
+        if (!locator || !locator.css || typeof locator.css !== "string") {
+          console.error("Locator must have a valid css selector found: ", locator);
+          continue;
+        }
+        if (visible === false) {
+          locator.visible = false;
+        }
+        const elements = this.getMatchingElements(locator.css, options);
+        if (elements.length === 0) {
+          console.warn(`No elements found for locator: ${locator.css}`);
+          continue;
+        } else if (elements.length === 1) {
+          if (element === elements[0]) {
+            locator.priority = 1;
+            unique.push(locator);
+          } else if (element.contains(elements[0])) {
+            locator.priority = 1;
+            const climb = this.dom_Parent.getClimbCountToParent(elements[0], element);
+            const climbSelector = this.getXPathSelector(climb);
+            const newSelector = `${locator.css} >> ${climbSelector}`;
+            locator.css = newSelector;
+            unique.push(locator);
+          }
+        } else {
+          locator.priority = 2;
+          locator.elements = elements;
+          nonUnique.push(locator);
+        }
+      }
+    } catch (error) {
+      console.error("Error categorizing locators:", error);
+    }
+    return { unique, nonUnique };
+  }
+
+  getUniqueLocators(element, locatorGenerator = this.getNoTextLocators, options = {}) {
+    return this.getUniqueLocators2(element, locatorGenerator, options);
+  }
+  getUniqueLocators1(element, locatorGenerator = this.getNoTextLocators, options = {}) {
+    try {
+      const { maxLocators = 5, root = window.document.body, next = "LCA", minLocators = 3 } = options;
+
+      if (!element) {
+        return [];
+      }
+      if (element === root) {
+        if (element === window.document.documentElement) {
+          return [
+            {
+              css: "html",
+              score: 1,
+              priority: 1,
+            },
+            {
+              css: ":root",
+              score: 1,
+              priority: 1,
+            },
+          ];
+        } else {
+          return [
+            {
+              css: ":root",
+              score: 1,
+              priority: 1,
+              // }, {
+              // 	css: ":root",
+              // 	score: 1,
+              // 	priority: 1,
+            },
+          ];
+        }
+      }
+
+      console.log("Generating locators for element:", element);
+      const locators = locatorGenerator(element, options);
+      console.log("Generated locators:", locators);
+      if (!locators || !Array.isArray(locators)) {
+        // throw new Error("Locator generator did not return an array of locators");
+        console.error("Locator generator did not return an array of locators");
+        return [];
+      }
+
+      console.log("Categorizing locators for element:", element);
+      const categorizedLocators = this.categorizeLocators(element, locators, options);
+      console.log("Categorized locators:", categorizedLocators);
+      // categorizedLocators.unique = limitLocators(categorizedLocators.unique, options);
+      // categorizedLocators.nonUnique = limitLocators(categorizedLocators.nonUnique, options);
+
+      const { unique, nonUnique } = categorizedLocators;
+      const result = [];
+      if (unique.length > 0) {
+        result.push(...unique);
+      }
+      if (result.length >= maxLocators) {
+        return result.slice(0, maxLocators);
+      }
+      let nextElement = null;
+      for (const locator of nonUnique) {
+        const selector = locator.css ?? locator.selector;
+        const elements = locator.elements || this.getMatchingElements(selector, options);
+
+        if (next === "parent") {
+          nextElement = this.dom_Parent.getActualParent(element);
+        } else {
+          // find the branching element the child of common parent that contains the element
+          const branchingParent = this.dom_Parent.findBranchingParent(elements, element);
+          nextElement = branchingParent;
+        }
+
+        if (nextElement && nextElement !== element) {
+          if (root.contains(nextElement)) {
+            const _result = this.getUniqueLocators(nextElement, locatorGenerator, {
+              ...options,
+              root,
+            });
+            for (const _locator of _result) {
+              if (result.length >= maxLocators) {
+                return result.slice(0, maxLocators);
+              }
+              const _selector = _locator.css ?? _locator.selector;
+              const fullSelector = `${_selector} >> ${selector}`;
+              const _elements = this.getMatchingElements(fullSelector, options);
+              const effectiveScore = (_locator.score + locator.score) / 2 + 100;
+              if (_elements.length === 1 && _elements[0] === element) {
+                _locator.css = fullSelector;
+                _locator.score = effectiveScore;
+                _locator.priority = 1; // unique locators have higher priority
+                result.push(_locator);
+              } else {
+                const index = _elements.indexOf(element);
+                if (index !== -1 && index < 5) {
+                  // _locator.selector = fullSelector;
+                  _locator.css = fullSelector;
+                  _locator.index = index;
+                  _locator.priority = 2; // non-unique locators have lower priority
+                  _locator.score = effectiveScore;
+                  result.push(_locator);
+                }
+              }
+            }
+          } else {
+            const index = elements.indexOf(element);
+            if (index !== -1 && index < 5) {
+              locator.index = index;
+              locator.priority = 2; // non-unique locators have lower priority
+              result.push(locator);
+            }
+          }
+        } else {
+          const index = elements.indexOf(element);
+          if (index !== -1 && index < 5) {
+            locator.index = index;
+            locator.priority = 2; // non-unique locators have lower priority
+            result.push(locator);
+          }
+        }
+
+        delete locator.elements; // remove elements to avoid memory leak
+        delete locator.strategy;
+        delete locator.engine;
+        delete locator.selector;
+      }
+
+      if (result.length < minLocators && root && root.contains(element)) {
+        const parent = this.dom_Parent.getActualParent(element);
+        const locs = this.getUniqueLocators(parent, locatorGenerator, {
+          ...options,
+          root,
+        });
+        result.push(...locs);
+      }
+
+      result.sort((a, b) => a.score - b.score);
+      console.log("Final locators:", result, element);
+      console.groupEnd();
+      return result.slice(0, maxLocators);
+    } catch (error) {
+      console.error("Error in getUniqueLocators:", error);
+      return [];
+    }
+  }
+
+  getUniqueLocators2(element, locatorGenerator = this.getNoTextLocators, options = {}) {
+    try {
+      const { maxLocators = 5, root = window.document.body, prefix } = options;
+
+      if (!element) {
+        return [];
+      }
+      if (element === root) {
+        if (element === window.document.documentElement) {
+          return [
+            {
+              css: "html",
+              score: 1,
+              priority: 1,
+            },
+            {
+              css: ":root",
+              score: 1,
+              priority: 1,
+            },
+          ];
+        } else {
+          return [];
+        }
+      }
+
+      console.log("Generating locators for element:", element);
+      const locators = locatorGenerator(element, options);
+      console.log("Generated locators:", locators);
+      if (!locators || !Array.isArray(locators)) {
+        console.error("Locator generator did not return an array of locators");
+        return [];
+      }
+
+      console.log("Categorizing locators for element:", element);
+      const categorizedLocators = this.categorizeLocators(element, locators, options);
+      console.log("Categorized locators:", categorizedLocators);
+
+      const { unique, nonUnique } = categorizedLocators;
+      const result = [];
+      if (unique.length > 0) {
+        result.push(...unique);
+      }
+      if (result.length >= maxLocators) {
+        return result.slice(0, maxLocators);
+      }
+
+      const elementsCache = new Map();
+
+      const allAncestors = prefix ? [element] : this.dom_Parent.getFullAncestorChainToRoot(element, root);
+      allAncestors.shift(); // remove the element itself from the ancestors
+
+      const cache = new Map();
+      const textToIgnore = this.PW.selectorUtils.elementText(cache, element).full.trim();
+      const ancestorLocators = [];
+      let uniqueAncestor = null;
+      for (const ancestor of allAncestors) {
+        const _locators = locatorGenerator(ancestor, { ...options, textToIgnore });
+        if (!_locators || !Array.isArray(_locators) || _locators.length === 0) {
+          continue;
+        }
+        const _categorized = this.categorizeLocators(ancestor, _locators, options);
+        ancestorLocators.push({
+          element: ancestor,
+          locators: _categorized,
+        });
+        elementsCache.set(ancestor, _categorized);
+        if (_categorized.unique.length > 0) {
+          uniqueAncestor = {
+            element: ancestor,
+            locators: _categorized,
+          };
+          break;
+        }
+      }
+
+      // const uniqueAncestor = ancestorLocators[ancestorLocators.length - 1];
+
+      for (const locator of nonUnique) {
+        const selector = locator.css ?? locator.selector;
+        const elements = locator.elements || this.getMatchingElements(selector, options);
+        if (elements.length === 0) {
+          console.warn(`No elements found for locator: ${selector}`);
+          continue;
+        }
+        if (!uniqueAncestor) {
+          const elements = this.getMatchingElements(selector, options);
+          if (elements.length === 1 && elements[0] === element) {
+            result.push({
+              css: selector,
+              score: locator.score,
+              priority: 1,
+            });
+          } else {
+            const index = elements.indexOf(element);
+            if (index !== -1) {
+              result.push({
+                css: selector,
+                index,
+                score: locator.score + 200,
+                priority: 2,
+              });
+            }
+          }
+          continue;
+        }
+
+        for (const unique_locator of uniqueAncestor.locators.unique) {
+          const fullSelector = `${unique_locator.css} >> ${selector}`;
+          const elements = this.getMatchingElements(fullSelector, options);
+          if (elements.length === 1 && elements[0] === element) {
+            const effectiveScore = (unique_locator.score + locator.score) / 2 + 100;
+            const newLocator = {
+              ...unique_locator,
+              css: fullSelector,
+              score: effectiveScore,
+              priority: 1, // unique locators have higher priority
+            };
+            result.push(newLocator);
+          } else {
+            const index = elements.indexOf(element);
+            if (index !== -1 && index < 5) {
+              const effectiveScore = (unique_locator.score + locator.score) / 2;
+              const newLocator = {
+                ...unique_locator,
+                css: fullSelector,
+                index,
+                score: effectiveScore + 200,
+                priority: 2, // non-unique locators have lower priority
+              };
+              result.push(newLocator);
+            }
+          }
+        }
+      }
+      result.sort((a, b) => a.score - b.score);
+      console.log("Final locators:", result, element);
+      console.groupEnd();
+      return result.slice(0, maxLocators);
+    } catch (error) {
+      console.error("Error in getUniqueLocators:", error);
+      return [];
+    }
+  }
+  isElementVisible(element) {
+    if (!(element instanceof Element)) return false;
+    const style = window.getComputedStyle(element);
+    if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") return false;
+    const rect = element.getBoundingClientRect();
+    if (rect.width === 0 || rect.height === 0) return false;
+    return true;
+  }
+  getElementLocators(element, options = {}) {
+    const isVisible = this.isElementVisible(element);
+    if (isVisible === false) {
+      console.warn("Element is not visible: ", element);
+      options.visible = isVisible;
+    }
+    try {
+      const {
+        excludeText = false,
+        strategies = {
+          [this.locatorStrategies.custom]: true,
+          [this.locatorStrategies.context]: true,
+          [this.locatorStrategies.text]: true,
+          [this.locatorStrategies.text_with_index]: true,
+          [this.locatorStrategies.digitIgnore]: true,
+          [this.locatorStrategies.no_text]: true,
+        },
+      } = options;
+
+      const allStrategyLocators = {
+        [this.locatorStrategies.custom]: [],
+        [this.locatorStrategies.context]: [],
+        [this.locatorStrategies.text]: [],
+        [this.locatorStrategies.text_with_index]: [],
+        [this.locatorStrategies.digitIgnore]: [],
+        [this.locatorStrategies.no_text]: [],
+      };
+      if (
+        strategies[this.locatorStrategies.custom] &&
+        this.options?.customAttributes &&
+        Array.isArray(this.options.customAttributes) &&
+        this.options.customAttributes.length > 0
+      ) {
+        console.groupCollapsed("Generating Custom locators for element:", element);
+        const customLocators = this.getUniqueLocators(element, this.getCustomLocators.bind(this), options);
+        if (customLocators.length > 0) {
+          allStrategyLocators[this.locatorStrategies.custom] = customLocators;
+        }
+      }
+      console.groupEnd();
+      if (!excludeText) {
+        if (strategies[this.locatorStrategies.text]) {
+          console.groupCollapsed("Generating Text locators for element:", element);
+
+          const basicLocators = this.getUniqueLocators(element, this.getTextLocators.bind(this), options);
+          console.groupEnd();
+          if (basicLocators.length > 0) {
+            allStrategyLocators[this.locatorStrategies.text] = basicLocators;
+          }
+          if (strategies[this.locatorStrategies.text_with_index]) {
+            const textWithIndexLocators = this.getTextwithIndexLocators(basicLocators);
+            if (textWithIndexLocators.length > 0) {
+              allStrategyLocators[this.locatorStrategies.text_with_index] = textWithIndexLocators;
+            }
+          }
+          if (strategies[this.locatorStrategies.digitIgnore]) {
+            const digitIgnoreLocators = this.getDigitIgnoreLocators(element, basicLocators);
+            if (digitIgnoreLocators.length > 0) {
+              allStrategyLocators[this.locatorStrategies.digitIgnore] = digitIgnoreLocators;
+            }
+          }
+          if (strategies[this.locatorStrategies.context]) {
+            const contextLocators = this.getContextLocators(element, basicLocators);
+            if (contextLocators.length > 0) {
+              allStrategyLocators[this.locatorStrategies.context] = contextLocators;
+            }
+          }
+        }
+      }
+      if (strategies[this.locatorStrategies.no_text]) {
+        console.groupCollapsed("Generating No Text locators for element:", element);
+        const noTextLocators = this.getUniqueLocators(element, this.getNoTextLocators.bind(this), options);
+
+        if (noTextLocators.length > 0) {
+          allStrategyLocators[this.locatorStrategies.no_text] = noTextLocators;
+        } else {
+          const _locators = [];
+          _locators.push({
+            css: this.generateUniqueCSSSelector(element, options),
+            score: 500,
+            priority: 3,
+          });
+          if (_locators.length > 0) {
+            allStrategyLocators[this.locatorStrategies.no_text] = _locators;
+          }
+        }
+        console.groupEnd();
+      }
+
+      let bestStrategy = this.getBestStrategy(allStrategyLocators);
+      if (!bestStrategy) {
+        throw new Error("No locators found for element: " + element);
+      }
+      allStrategyLocators.strategy = bestStrategy;
+
+      const locators = allStrategyLocators[allStrategyLocators.strategy] ?? [];
+      const result = {
+        locators,
+        element_name: "",
+      };
+      if (Object.keys(allStrategyLocators).length > 1) {
+        result.allStrategyLocators = allStrategyLocators;
+      }
+      console.log("Generated locators:", result);
+      return result;
+    } catch (error) {
+      console.error("Error in getElementLocators:", error);
+      return {
+        locators: [],
+        element_name: "",
+      };
+    }
+  }
+  getBestStrategy(allStrategyLocators) {
+    const orderedPriorities = [
+      this.locatorStrategies.custom,
+      this.locatorStrategies.context,
+      this.locatorStrategies.text,
+      this.locatorStrategies.text_with_index,
+      this.locatorStrategies.digitIgnore,
+      this.locatorStrategies.no_text,
+    ];
+    for (const strategy of orderedPriorities) {
+      if (allStrategyLocators[strategy] && allStrategyLocators[strategy].length > 0) {
+        return strategy;
+      }
+    }
+    return null;
+  }
 }
 
 export default LocatorGenerator;