@nodebug/browser-element-finder 1.0.8 → 1.1.5

package/index.js

@@ -21,14 +21,18 @@ var ElementFinder = (() => {
   var element_finder_exports = {};
   __export(element_finder_exports, {
     ELEMENT_DEFINITIONS: () => ELEMENT_DEFINITIONS,
-    findElement: () => findElement,
+    findElementByAttributes: () => findElementByAttributes,
+    findElementByType: () => findElementByType,
+    findElements: () => findElements,
+    findProbableElements: () => findProbableElements,
     getAllElements: () => getAllElements,
     getAllFrames: () => getAllFrames,
     getBoundingBox: () => getBoundingBox,
     getSearchableAttributes: () => getSearchableAttributes,
+    getValidAttributes: () => getValidAttributes,
     getValidTypes: () => getValidTypes,
     highlight: () => highlight,
-    matchesContent: () => matchesContent,
+    matchesAttribute: () => matchesAttribute,
     matchesType: () => matchesType,
     parseCondition: () => parseCondition,
     parseXPath: () => parseXPath,
@@ -37,25 +41,6 @@ var ElementFinder = (() => {
     unhighlight: () => unhighlight
   });
 
-  // src/searchable-attributes.json
-  var searchable_attributes_default = [
-    "placeholder",
-    "value",
-    "data-test-id",
-    "data-testid",
-    "id",
-    "resource-id",
-    "name",
-    "aria-label",
-    "class",
-    "hint",
-    "title",
-    "tooltip",
-    "alt",
-    "src",
-    "aria-labelledby"
-  ];
-
   // src/element-definitions.json
   var element_definitions_default = {
     link: "self::a or @role='link' or @href",
@@ -65,9 +50,11 @@ var ElementFinder = (() => {
     checkbox: "(self::input and @type='checkbox') or @role='checkbox'",
     switch: "(self::input and @type='checkbox') or @role='switch' or (self::button and (contains(@class, 'switch') or @data-state))",
     slider: "self::input[@type='range'] or @role='slider'",
+    datepicker: "self::input and @type='date'",
+    colorpicker: "self::input and @type='color'",
     radio: "(self::input and @type='radio') or @role='radio'",
     dropdown: "(self::select[descendant::option] or @role='combobox' or @role='listbox' or contains(@class, 'dropdown') or contains(@class, 'trigger') or ancestor::*[contains(@class, 'dropdown') or @role='combobox'])",
-    textbox: "self::textarea or (self::input and (@type='text' or @type='password' or @type='search' or @type='email')) or @role='textbox'",
+    textbox: "self::textarea or (self::input and (@type='text' or @type='password' or @type='search' or @type='email' or @type='number' or @type='tel' or @type='url')) or @role='textbox'",
     file: "self::input and @type='file'",
     list: "self::ul or self::ol or @role='list'",
     listitem: "self::li or @role='listitem'",
@@ -78,10 +65,29 @@ var ElementFinder = (() => {
     table: "self::table or @role='table'",
     row: "self::tr or @role='row'",
     column: "self::td or self::th or @role='cell' or @role='gridcell' or @role='columnheader'",
+    cell: "self::td or @role='cell' or @role='gridcell'",
     image: "self::img or @role='img' or @alt",
     element: "true()"
   };
 
+  // src/searchable-attributes.json
+  var searchable_attributes_default = [
+    "placeholder",
+    "value",
+    "data-test-id",
+    "data-testid",
+    "id",
+    "resource-id",
+    "name",
+    "aria-label",
+    "hint",
+    "title",
+    "tooltip",
+    "alt",
+    "src",
+    "aria-labelledby"
+  ];
+
   // src/element-finder.js
   var REGEX_PATTERNS = {
     selfWithTag: /^self::([a-zA-Z0-9-]+)(?:\[([^\]]+)\])?$/,
@@ -94,29 +100,43 @@ var ElementFinder = (() => {
     operatorAnd: /^\s*\band\b\s*/i
   };
   var MAX_RECURSION_DEPTH = 100;
-  function parseXPath(expr, el, depth = 0) {
-    if (expr == null || el == null) {
-      return false;
+  var TYPE_MATCHERS = /* @__PURE__ */ new Map();
+  for (const [type, expr] of Object.entries(element_definitions_default)) {
+    if (expr === "true()") {
+      TYPE_MATCHERS.set(type, () => true);
+    } else {
+      TYPE_MATCHERS.set(type, (el) => parseXPath(expr, el));
     }
+  }
+  var SEARCHABLE_ATTRIBUTES = searchable_attributes_default;
+  function setSearchableAttributes(attributes) {
+    if (!Array.isArray(attributes)) {
+      throw new TypeError("attributes must be an array");
+    }
+    SEARCHABLE_ATTRIBUTES = attributes;
+  }
+  function getSearchableAttributes() {
+    return [...SEARCHABLE_ATTRIBUTES];
+  }
+  function parseXPath(expr, el, depth = 0) {
+    if (expr == null || el == null) return false;
     if (depth > MAX_RECURSION_DEPTH) {
       throw new Error("XPath expression exceeds maximum recursion depth");
     }
     expr = expr.trim();
     if (expr === "true()") return true;
-    if (expr.startsWith("(") && expr.endsWith(")")) {
-      let parenDepth = 0;
+    if (expr[0] === "(" && expr[expr.length - 1] === ")") {
+      let parenDepth = 1;
       let matchedAll = true;
-      for (let i = 0; i < expr.length; i++) {
+      for (let i = 1; i < expr.length - 1; i++) {
         if (expr[i] === "(") parenDepth++;
         else if (expr[i] === ")") parenDepth--;
-        if (parenDepth === 0 && i < expr.length - 1) {
+        if (parenDepth === 0) {
           matchedAll = false;
           break;
         }
       }
-      if (matchedAll) {
-        return parseXPath(expr.slice(1, -1), el, depth + 1);
-      }
+      if (matchedAll) return parseXPath(expr.slice(1, -1), el, depth + 1);
     }
     const orParts = splitByOperator(expr, "or");
     if (orParts.length > 1) {
@@ -171,41 +191,36 @@ var ElementFinder = (() => {
     return parts;
   }
   function parseCondition(expr, el, depth = 0) {
-    if (expr == null || el == null) {
-      return false;
-    }
+    if (expr == null || el == null) return false;
     expr = expr.trim();
-    let match = expr.match(REGEX_PATTERNS.selfWithTag);
-    if (match) {
-      const tagName = match[1].toUpperCase();
+    const selfMatch = expr.match(REGEX_PATTERNS.selfWithTag);
+    if (selfMatch) {
+      const tagName = selfMatch[1].toUpperCase();
       if (el.tagName !== tagName) return false;
-      if (match[2]) {
-        return parseXPath(match[2], el, depth + 1);
-      }
-      return true;
+      return selfMatch[2] ? parseXPath(selfMatch[2], el, depth + 1) : true;
     }
-    match = expr.match(REGEX_PATTERNS.contains);
-    if (match) {
-      const attr = el.getAttribute(match[1]) || "";
-      return attr.toLowerCase().includes(match[2].toLowerCase());
+    const containsMatch = expr.match(REGEX_PATTERNS.contains);
+    if (containsMatch) {
+      const attr = el.getAttribute(containsMatch[1]) || "";
+      return attr.toLowerCase().includes(containsMatch[2].toLowerCase());
     }
-    match = expr.match(REGEX_PATTERNS.attrEquals);
-    if (match) {
-      return el.getAttribute(match[1]) === match[2];
+    const attrEqualsMatch = expr.match(REGEX_PATTERNS.attrEquals);
+    if (attrEqualsMatch) {
+      return el.getAttribute(attrEqualsMatch[1]) === attrEqualsMatch[2];
     }
-    match = expr.match(REGEX_PATTERNS.attrExists);
-    if (match) {
-      return el.hasAttribute(match[1]);
+    const attrExistsMatch = expr.match(REGEX_PATTERNS.attrExists);
+    if (attrExistsMatch) {
+      return el.hasAttribute(attrExistsMatch[1]);
     }
-    match = expr.match(REGEX_PATTERNS.descendant);
-    if (match) {
-      return el.querySelector(match[1]) !== null;
+    const descendantMatch = expr.match(REGEX_PATTERNS.descendant);
+    if (descendantMatch) {
+      return el.querySelector(descendantMatch[1]) !== null;
     }
-    match = expr.match(REGEX_PATTERNS.ancestor);
-    if (match) {
+    const ancestorMatch = expr.match(REGEX_PATTERNS.ancestor);
+    if (ancestorMatch) {
       let parent = el.parentElement;
       while (parent) {
-        if (parseXPath(match[1], parent, depth + 1)) return true;
+        if (parseXPath(ancestorMatch[1], parent, depth + 1)) return true;
         parent = parent.parentElement;
       }
       return false;
@@ -213,26 +228,39 @@ var ElementFinder = (() => {
     return false;
   }
   var ELEMENT_DEFINITIONS = Object.freeze(element_definitions_default);
-  var SEARCHABLE_ATTRIBUTES = searchable_attributes_default;
-  function setSearchableAttributes(attributes) {
-    if (!Array.isArray(attributes)) {
-      throw new TypeError("attributes must be an array");
+  function getDirectText(el) {
+    let text = "";
+    for (let i = 0; i < el.childNodes.length; i++) {
+      const node = el.childNodes[i];
+      if (node.nodeType === Node.TEXT_NODE) {
+        text += node.textContent;
+      }
     }
-    SEARCHABLE_ATTRIBUTES = attributes;
-  }
-  function getSearchableAttributes() {
-    return [...SEARCHABLE_ATTRIBUTES];
+    return text.trim();
   }
-  function matchesType(el, type) {
-    if (el == null) return false;
-    const expr = ELEMENT_DEFINITIONS[type];
-    return expr ? parseXPath(expr, el) : false;
+  function isInsideStyleOrScript(el) {
+    if (el.tagName === "STYLE" || el.tagName === "SCRIPT") {
+      return true;
+    }
+    if (el.querySelector("STYLE, SCRIPT")) {
+      return true;
+    }
+    let parent = el.parentElement;
+    while (parent) {
+      if (parent.tagName === "STYLE" || parent.tagName === "SCRIPT") {
+        return true;
+      }
+      parent = parent.parentElement;
+    }
+    return false;
   }
-  function matchesContent(el, value, exact = false) {
+  function matchesAttribute(el, value, exact = false) {
     if (el == null) return false;
     if (value === void 0 || value === null || value === "") return true;
-    const normalizedValue = value.toLowerCase().trim();
-    for (const attr of SEARCHABLE_ATTRIBUTES) {
+    if (isInsideStyleOrScript(el)) return false;
+    const attrs = SEARCHABLE_ATTRIBUTES;
+    for (let i = 0; i < attrs.length; i++) {
+      const attr = attrs[i];
       let attrValue;
       try {
         attrValue = el.getAttribute(attr);
@@ -240,81 +268,59 @@ var ElementFinder = (() => {
         continue;
       }
       if (attrValue) {
-        const normalized = attrValue.toLowerCase().trim();
-        if (exact ? normalized === normalizedValue : normalized.includes(normalizedValue)) {
+        if (exact ? attrValue === value : attrValue.includes(value)) {
           return true;
         }
       }
     }
-    const directText = Array.from(el.childNodes).filter((node) => node.nodeType === Node.TEXT_NODE).map((node) => node.textContent).join("").toLowerCase().trim();
-    if (exact ? directText === normalizedValue : directText.includes(normalizedValue)) {
+    const directText = getDirectText(el);
+    if (exact ? directText === value : directText.includes(value)) {
       return true;
     }
-    const textContent = el.textContent.toLowerCase().trim();
-    if (exact ? textContent === normalizedValue : textContent.includes(normalizedValue)) {
+    const textContent = el.textContent;
+    if (exact ? textContent.trim() === value : textContent.includes(value)) {
       return true;
     }
-    if (el.tagName === "SELECT") {
-      const options = el.querySelectorAll("option");
-      for (const option of options) {
-        const optionText = option.textContent.toLowerCase().trim();
-        if (exact ? optionText === normalizedValue : optionText.includes(normalizedValue)) {
-          return true;
-        }
-      }
-    }
     return false;
   }
-  function getBoundingBox(el) {
-    const rect = el.getBoundingClientRect();
-    return {
-      x: rect.x,
-      y: rect.y,
-      width: rect.width,
-      height: rect.height,
-      top: rect.top,
-      bottom: rect.bottom,
-      left: rect.left,
-      right: rect.right,
-      midx: rect.x + rect.width / 2,
-      midy: rect.y + rect.height / 2,
-      tagName: el.tagName.toLowerCase()
-    };
+  function matchesType(el, type) {
+    if (el == null) return false;
+    const matcher = TYPE_MATCHERS.get(type);
+    return matcher ? matcher(el) : false;
   }
   function getAllElements(root = document) {
     const elements = [];
+    if (root == null) return elements;
     const rootNode = root.nodeType === Node.DOCUMENT_NODE ? root.documentElement : root;
     if (!rootNode) return elements;
-    const walker = (rootNode.ownerDocument || rootNode).createTreeWalker(
-      rootNode,
-      NodeFilter.SHOW_ELEMENT,
-      {
-        acceptNode: (node2) => {
-          if (node2.tagName === "SCRIPT" || node2.tagName === "STYLE") {
-            return NodeFilter.FILTER_REJECT;
-          }
-          return NodeFilter.FILTER_ACCEPT;
-        }
-      }
-    );
-    let node;
-    while (node = walker.nextNode()) {
+    const stack = [rootNode];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (node.nodeType !== Node.ELEMENT_NODE) continue;
+      if (node.tagName === "SCRIPT" || node.tagName === "STYLE") continue;
       elements.push(node);
+      const children = node.children;
+      for (let i = children.length - 1; i >= 0; i--) {
+        stack.push(children[i]);
+      }
       try {
         if (node.shadowRoot) {
-          elements.push(...getAllElements(node.shadowRoot));
+          const shadowChildren = node.shadowRoot.children;
+          for (let i = shadowChildren.length - 1; i >= 0; i--) {
+            stack.push(shadowChildren[i]);
+          }
         }
       } catch (e) {
       }
     }
     return elements;
   }
-  function getAllFrames(root = window, maxFrames = Infinity) {
+  function getAllFrames(root = window) {
     const frames = [];
     try {
       frames.push({ window: root, document: root.document, isMainFrame: true, frameIndex: -1 });
       const iframes = root.document.querySelectorAll("iframe");
-      for (let i = 0; i < iframes.length && frames.length < maxFrames; i++) {
+      for (let i = 0; i < iframes.length; i++) {
         const iframe = iframes[i];
         try {
           if (iframe.contentWindow && iframe.contentDocument) {
@@ -339,69 +345,23 @@ var ElementFinder = (() => {
     }
     return frames;
   }
-  function expandColumnMatches(matches, text, exact, includeHidden) {
-    var _a;
-    if (!text) return matches;
-    const expandedMatches = [];
-    const seenElements = /* @__PURE__ */ new Set();
-    for (const match of matches) {
-      const el = match.element;
-      const frame = match.frame;
-      if (!seenElements.has(el)) {
-        expandedMatches.push(match);
-        seenElements.add(el);
-      }
-      if (el.tagName.toLowerCase() === "th") {
-        const table = el.closest("table");
-        if (!table) continue;
-        const headerRow = el.closest("tr");
-        if (!headerRow) continue;
-        const headerCells = Array.from(headerRow.children);
-        const colPositions = [];
-        let currentCol = 0;
-        for (const cell of headerCells) {
-          const colspan = parseInt(cell.getAttribute("colspan")) || 1;
-          colPositions.push({ cell, colStart: currentCol, colEnd: currentCol + colspan - 1 });
-          currentCol += colspan;
-        }
-        const headerInfo = colPositions.find((info) => info.cell === el);
-        if (!headerInfo) continue;
-        const allRows = table.querySelectorAll("tr");
-        for (const row of allRows) {
-          const cells = Array.from(row.children);
-          const rowColMap = /* @__PURE__ */ new Map();
-          let rowCol = 0;
-          for (const cell of cells) {
-            const colspan = parseInt(cell.getAttribute("colspan")) || 1;
-            for (let i = 0; i < colspan; i++) {
-              rowColMap.set(rowCol + i, cell);
-            }
-            rowCol += colspan;
-          }
-          for (let col = headerInfo.colStart; col <= headerInfo.colEnd; col++) {
-            const cell = rowColMap.get(col);
-            if (!cell) continue;
-            if (seenElements.has(cell)) continue;
-            if (!includeHidden) {
-              const cellWindow = ((_a = cell.ownerDocument) == null ? void 0 : _a.defaultView) || frame.window;
-              const style = cellWindow.getComputedStyle(cell);
-              if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") {
-                continue;
-              }
-              if (cell.offsetWidth === 0 || cell.offsetHeight === 0) {
-                continue;
-              }
-            }
-            expandedMatches.push({ element: cell, frame });
-            seenElements.add(cell);
-          }
-        }
-      }
-    }
-    return expandedMatches;
+  function getBoundingBox(el) {
+    const rect = el.getBoundingClientRect();
+    return {
+      x: rect.x,
+      y: rect.y,
+      width: rect.width,
+      height: rect.height,
+      top: rect.top,
+      bottom: rect.bottom,
+      left: rect.left,
+      right: rect.right,
+      midx: rect.x + rect.width / 2,
+      midy: rect.y + rect.height / 2,
+      tagName: el.tagName.toLowerCase()
+    };
   }
-  function findElement(type = "element", text = null, exact = false, includeHidden = false, parent = null, maxFrames = Infinity) {
-    var _a;
+  function findElementByType(type = "element", parent = null) {
     if (type === null || type === void 0) {
       type = "element";
     }
@@ -413,22 +373,12 @@ var ElementFinder = (() => {
       return { elements: [] };
     }
     const matches = [];
-    const frames = getAllFrames(window, maxFrames);
+    const frames = getAllFrames(window);
     for (const frame of frames) {
       const allElements = getAllElements(parent || frame.document);
-      for (const el of allElements) {
+      for (let i = 0; i < allElements.length; i++) {
+        const el = allElements[i];
         if (type && !matchesType(el, type)) continue;
-        if (text !== void 0 && !matchesContent(el, text, exact)) continue;
-        if (!includeHidden) {
-          const elWindow = ((_a = el.ownerDocument) == null ? void 0 : _a.defaultView) || frame.window;
-          const style = elWindow.getComputedStyle(el);
-          if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0") {
-            continue;
-          }
-          if (el.offsetWidth === 0 || el.offsetHeight === 0) {
-            continue;
-          }
-        }
         matches.push({ element: el, frame });
       }
     }
@@ -441,18 +391,274 @@ var ElementFinder = (() => {
         const el = match.element;
         if (!excludedElements.has(el)) {
           innermostMatches.unshift(match);
-          let parent2 = el.parentElement;
-          while (parent2) {
-            if (matchedElements.has(parent2)) {
-              excludedElements.add(parent2);
+          let parentEl = el.parentElement;
+          while (parentEl) {
+            if (matchedElements.has(parentEl)) {
+              excludedElements.add(parentEl);
             }
-            parent2 = parent2.parentElement;
+            parentEl = parentEl.parentElement;
           }
         }
       }
     }
-    const expandedMatches = expandColumnMatches(innermostMatches, text, exact, includeHidden);
-    const qualified = expandedMatches.map((item) => {
+    const qualified = innermostMatches.map((item) => {
+      const boundingBox = getBoundingBox(item.element);
+      const tagName = item.element.tagName.toLowerCase();
+      if (!item.frame.isMainFrame) {
+        return {
+          boundingBox,
+          tagName,
+          frameIndex: item.frame.frameIndex
+        };
+      }
+      return {
+        element: item.element,
+        boundingBox,
+        tagName,
+        frameIndex: item.frame.frameIndex
+      };
+    });
+    return { elements: qualified };
+  }
+  function findElementByAttributes(value, exact = false, parent = null) {
+    if (value === null || value === void 0) {
+      value = "";
+    }
+    if (typeof value !== "string") {
+      throw new TypeError(`value must be a string, got ${typeof value}`);
+    }
+    const matches = [];
+    const frames = getAllFrames(window);
+    for (const frame of frames) {
+      const allElements = getAllElements(parent || frame.document);
+      for (let i = 0; i < allElements.length; i++) {
+        const el = allElements[i];
+        if (!matchesAttribute(el, value, exact)) continue;
+        matches.push({ element: el, frame });
+      }
+    }
+    const filteredMatches = matches.filter((item) => {
+      const el = item.element;
+      const hasDirectMatch = hasOwnMatch(el, value, exact);
+      if (hasDirectMatch) return true;
+      for (const other of matches) {
+        if (other.element !== el && el.contains(other.element)) {
+          return false;
+        }
+      }
+      return true;
+    });
+    const qualified = filteredMatches.map((item) => {
+      const boundingBox = getBoundingBox(item.element);
+      const tagName = item.element.tagName.toLowerCase();
+      if (!item.frame.isMainFrame) {
+        return {
+          boundingBox,
+          tagName,
+          frameIndex: item.frame.frameIndex
+        };
+      }
+      return {
+        element: item.element,
+        boundingBox,
+        tagName,
+        frameIndex: item.frame.frameIndex
+      };
+    });
+    return { elements: qualified };
+  }
+  function hasOwnMatch(el, value, exact = false) {
+    if (value === void 0 || value === null || value === "") return true;
+    const attrs = SEARCHABLE_ATTRIBUTES;
+    for (let i = 0; i < attrs.length; i++) {
+      const attr = attrs[i];
+      let attrValue;
+      try {
+        attrValue = el.getAttribute(attr);
+      } catch (e) {
+        continue;
+      }
+      if (attrValue) {
+        if (exact ? attrValue === value : attrValue.includes(value)) {
+          return true;
+        }
+      }
+    }
+    const directText = getDirectText(el);
+    if (exact ? directText === value : directText.includes(value)) {
+      return true;
+    }
+    return false;
+  }
+  function findElements(type = null, text = null, exact = false, parent = null) {
+    if (text === null || text === void 0) {
+      text = "";
+    }
+    if (type !== null && type !== void 0) {
+      if (typeof type !== "string") {
+        throw new TypeError(`type must be a string, got ${typeof type}`);
+      }
+      if (!ELEMENT_DEFINITIONS[type]) {
+        console.warn(`Unknown element type: ${type}. Valid types: ${Object.keys(ELEMENT_DEFINITIONS).join(", ")}`);
+        return { elements: [] };
+      }
+    }
+    if (text !== "" && typeof text !== "string") {
+      throw new TypeError(`text must be a string, got ${typeof text}`);
+    }
+    const matches = [];
+    const frames = getAllFrames(window);
+    for (const frame of frames) {
+      const allElements = getAllElements(parent || frame.document);
+      for (let i = 0; i < allElements.length; i++) {
+        const el = allElements[i];
+        if (type !== null && type !== void 0 && !matchesType(el, type)) continue;
+        if (text !== "" && !matchesAttribute(el, text, exact)) continue;
+        matches.push({ element: el, frame });
+      }
+    }
+    const filteredMatches = text !== "" ? matches.filter((item) => {
+      const el = item.element;
+      const hasDirectMatch = hasOwnMatch(el, text, exact);
+      if (hasDirectMatch) return true;
+      for (const other of matches) {
+        if (other.element !== el && el.contains(other.element)) {
+          return false;
+        }
+      }
+      return true;
+    }) : matches;
+    const qualified = filteredMatches.map((item) => {
+      const boundingBox = getBoundingBox(item.element);
+      const tagName = item.element.tagName.toLowerCase();
+      if (!item.frame.isMainFrame) {
+        return {
+          boundingBox,
+          tagName,
+          frameIndex: item.frame.frameIndex
+        };
+      }
+      return {
+        element: item.element,
+        boundingBox,
+        tagName,
+        frameIndex: item.frame.frameIndex
+      };
+    });
+    return { elements: qualified };
+  }
+  function getParentElement(el) {
+    if (el.parentElement) {
+      return el.parentElement;
+    }
+    try {
+      const rootNode = el.getRootNode();
+      if (rootNode && rootNode.host) {
+        return rootNode.host;
+      }
+    } catch (e) {
+    }
+    return null;
+  }
+  function getSiblingElements(el) {
+    const parent = getParentElement(el);
+    if (!parent) return [];
+    if (parent.shadowRoot) {
+      try {
+        return Array.from(parent.shadowRoot.children);
+      } catch (e) {
+        return [];
+      }
+    }
+    return Array.from(parent.children);
+  }
+  function findNearbyElementType(el, targetType) {
+    let parent = getParentElement(el);
+    while (parent) {
+      if (matchesType(parent, targetType)) {
+        return parent;
+      }
+      parent = getParentElement(parent);
+    }
+    const immediateChildren = el.children || [];
+    for (const child of immediateChildren) {
+      if (matchesType(child, targetType)) {
+        return child;
+      }
+    }
+    const siblings = getSiblingElements(el);
+    for (const sibling of siblings) {
+      if (sibling !== el && matchesType(sibling, targetType)) {
+        return sibling;
+      }
+    }
+    return null;
+  }
+  function findProbableElements(elementType, attributeText, exact = false, parent = null) {
+    const hasType = elementType !== null && elementType !== void 0 && elementType !== "";
+    const hasText = attributeText !== null && attributeText !== void 0 && attributeText !== "";
+    if (hasType && !hasText) {
+      return findElementByType(elementType, parent);
+    }
+    if (!hasType && hasText) {
+      return findElementByAttributes(attributeText, exact, parent);
+    }
+    if (hasType) {
+      if (typeof elementType !== "string") {
+        throw new TypeError(`elementType must be a string, got ${typeof elementType}`);
+      }
+      if (!ELEMENT_DEFINITIONS[elementType]) {
+        console.warn(`Unknown element type: ${elementType}. Valid types: ${Object.keys(ELEMENT_DEFINITIONS).join(", ")}`);
+        return { elements: [] };
+      }
+    }
+    if (hasText) {
+      if (typeof attributeText !== "string") {
+        throw new TypeError(`attributeText must be a string, got ${typeof attributeText}`);
+      }
+    }
+    const matches = [];
+    const frames = getAllFrames(window);
+    for (const frame of frames) {
+      const allElements = getAllElements(parent || frame.document);
+      for (let i = 0; i < allElements.length; i++) {
+        const el = allElements[i];
+        if (hasType && !matchesType(el, elementType)) continue;
+        if (hasText && !matchesAttribute(el, attributeText, exact)) continue;
+        matches.push({ element: el, frame });
+      }
+    }
+    if (matches.length === 0 && hasType && hasText) {
+      const attributeMatches = [];
+      for (const frame of frames) {
+        const allElements = getAllElements(parent || frame.document);
+        for (let i = 0; i < allElements.length; i++) {
+          const el = allElements[i];
+          if (!matchesAttribute(el, attributeText, exact)) continue;
+          attributeMatches.push({ element: el, frame });
+        }
+      }
+      const foundElements = /* @__PURE__ */ new Set();
+      for (const match of attributeMatches) {
+        const nearbyElement = findNearbyElementType(match.element, elementType);
+        if (nearbyElement && !foundElements.has(nearbyElement)) {
+          foundElements.add(nearbyElement);
+          matches.push({ element: nearbyElement, frame: match.frame });
+        }
+      }
+    }
+    const filteredMatches = hasText ? matches.filter((item) => {
+      const el = item.element;
+      const hasDirectMatch = hasOwnMatch(el, attributeText, exact);
+      if (hasDirectMatch) return true;
+      for (const other of matches) {
+        if (other.element !== el && el.contains(other.element)) {
+          return false;
+        }
+      }
+      return true;
+    }) : matches;
+    const qualified = filteredMatches.map((item) => {
       const boundingBox = getBoundingBox(item.element);
       const tagName = item.element.tagName.toLowerCase();
       if (!item.frame.isMainFrame) {
@@ -480,7 +686,8 @@ var ElementFinder = (() => {
   }
   function highlight(elements, color = "red", width = 3) {
     const items = extractElements(elements);
-    items.forEach((item) => {
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
       const el = item.element ? item.element : item;
       if (el && el.style) {
         el.style.outline = `${width}px solid ${color}`;
@@ -488,11 +695,12 @@ var ElementFinder = (() => {
         el.style.boxShadow = `0 0 0 2px rgba(255, 255, 255, 0.8)`;
         el.classList.add("elementfinder-highlighted");
       }
-    });
+    }
   }
   function unhighlight(elements) {
     const items = extractElements(elements);
-    items.forEach((item) => {
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
       const el = item.element ? item.element : item;
       if (el && el.style) {
         el.style.outline = "";
@@ -500,10 +708,13 @@ var ElementFinder = (() => {
         el.style.boxShadow = "";
         el.classList.remove("elementfinder-highlighted");
       }
-    });
+    }
   }
   function getValidTypes() {
     return Object.keys(ELEMENT_DEFINITIONS);
   }
+  function getValidAttributes() {
+    return [...SEARCHABLE_ATTRIBUTES];
+  }
   return __toCommonJS(element_finder_exports);
 })();