@intuned/browser-dev 0.1.9-dev.0 → 0.1.10-dev.0

package/dist/common/frame_utils/tests/testGetContentWithNestedIframes.spec.js

@@ -0,0 +1,241 @@
+"use strict";
+
+var _extendedTest = require("../../extendedTest");
+var _playwrightCore = require("playwright-core");
+var _getContentWithNestedIframes = require("../getContentWithNestedIframes");
+var _nodeHtmlParser = require("node-html-parser");
+var path = _interopRequireWildcard(require("path"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+(0, _extendedTest.describe)("Test getContentWithNestedIframes", () => {
+  let browser;
+  let page;
+  (0, _extendedTest.beforeAll)(async () => {
+    browser = await _playwrightCore.chromium.launch({
+      headless: true
+    });
+  });
+  (0, _extendedTest.afterAll)(async () => {
+    await browser.close();
+  });
+  (0, _extendedTest.beforeEach)(async () => {
+    page = await browser.newPage();
+  });
+  (0, _extendedTest.afterEach)(async () => {
+    await page.close();
+  });
+  async function getTestPageWithIframes(waitForDynamicContent = false) {
+    const testHtmlPath = path.resolve(__dirname, "fixtures", "test_with_iframes.html");
+    await page.goto(`file://${testHtmlPath}`);
+    if (waitForDynamicContent) {
+      await page.waitForTimeout(1500);
+    }
+    return page;
+  }
+  (0, _extendedTest.test)("should get content with nested iframes stitched - basic", async () => {
+    await getTestPageWithIframes();
+    const content = await (0, _getContentWithNestedIframes.getContentWithNestedIframes)(page);
+    (0, _extendedTest.expect)(content).toContain("Static Iframe Content");
+    (0, _extendedTest.expect)(content).toContain("Srcdoc Iframe");
+    (0, _extendedTest.expect)(content).toContain("Outer Iframe");
+    const iframeContentCount = (content.match(/<iframe-content/g) || []).length;
+    (0, _extendedTest.expect)(iframeContentCount).toBeGreaterThanOrEqual(4);
+    (0, _extendedTest.expect)(content).toContain('id="static-iframe"');
+    (0, _extendedTest.expect)(content).toContain("<h2>Static Iframe Content</h2>");
+    (0, _extendedTest.expect)(content).toContain("iframe-element");
+    (0, _extendedTest.expect)(content).toContain("srcdoc-span");
+  });
+  (0, _extendedTest.test)("should handle nested iframes recursively", async () => {
+    await getTestPageWithIframes();
+    const content = await (0, _getContentWithNestedIframes.getContentWithNestedIframes)(page);
+    (0, _extendedTest.expect)(content).toContain("Outer Iframe");
+    (0, _extendedTest.expect)(content).toContain("Inner Iframe");
+    (0, _extendedTest.expect)(content).toContain("Deep Element");
+    const iframeContentCount = (content.match(/<iframe-content/g) || []).length;
+    (0, _extendedTest.expect)(iframeContentCount).toBeGreaterThanOrEqual(4);
+    (0, _extendedTest.expect)(content).toContain("deep-element");
+  });
+  (0, _extendedTest.test)("should handle dynamically created iframes", async () => {
+    await getTestPageWithIframes(true);
+    const content = await (0, _getContentWithNestedIframes.getContentWithNestedIframes)(page);
+    (0, _extendedTest.expect)(content).toContain("Dynamic Iframe");
+    (0, _extendedTest.expect)(content).toContain("dynamic-element");
+  });
+  (0, _extendedTest.test)("should handle empty iframes gracefully", async () => {
+    await getTestPageWithIframes();
+    const content = await (0, _getContentWithNestedIframes.getContentWithNestedIframes)(page);
+    (0, _extendedTest.expect)(content).toContain("empty-iframe-id");
+    const emptyIframeCount = (content.match(/empty-iframe-id/g) || []).length;
+    (0, _extendedTest.expect)(emptyIframeCount).toBe(1);
+  });
+  (0, _extendedTest.test)("should preserve main page content", async () => {
+    await getTestPageWithIframes();
+    const content = await (0, _getContentWithNestedIframes.getContentWithNestedIframes)(page);
+    (0, _extendedTest.expect)(content).toContain("Main Page Content");
+    (0, _extendedTest.expect)(content).toContain("This is the main page content");
+    (0, _extendedTest.expect)(content).toContain("content-after-iframes");
+    (0, _extendedTest.expect)(content).toContain("Item 1");
+    (0, _extendedTest.expect)(content).toContain("Item 2");
+  });
+  (0, _extendedTest.test)("should handle cross-origin iframes gracefully", async () => {
+    await page.setContent(`
+      <html>
+        <body element_id="main-body">
+          <h1>Main Content</h1>
+          <iframe id="cross-origin-iframe"
+                  element_id="cross-origin-id"
+                  src="https://example.com"
+                  width="300"
+                  height="200">
+          </iframe>
+          <p>Content after iframe</p>
+        </body>
+      </html>
+    `);
+    await page.waitForTimeout(500);
+    const content = await (0, _getContentWithNestedIframes.getContentWithNestedIframes)(page);
+    (0, _extendedTest.expect)(content).toContain("Main Content");
+    (0, _extendedTest.expect)(content).toContain("Content after iframe");
+    (0, _extendedTest.expect)(content).toContain("cross-origin-id");
+  });
+  (0, _extendedTest.test)("should handle malformed HTML in iframe content", async () => {
+    await page.setContent(`
+      <html>
+        <body element_id="main-body">
+          <h1>Malformed HTML Test</h1>
+          <iframe id="malformed-iframe"
+                  element_id="malformed-id"
+                  srcdoc="<html><body><h2>Malformed</h2><p>Unclosed tag<div>Missing closing</p></body></html>"
+                  width="300"
+                  height="200">
+          </iframe>
+        </body>
+      </html>
+    `);
+    const content = await (0, _getContentWithNestedIframes.getContentWithNestedIframes)(page);
+    (0, _extendedTest.expect)(content).toContain("Malformed HTML Test");
+    (0, _extendedTest.expect)(content).toContain("malformed-id");
+    (0, _extendedTest.expect)(content).toContain("Malformed");
+  });
+  (0, _extendedTest.test)("should handle problematic iframe sources without hanging", async () => {
+    await page.setContent(`
+      <html>
+        <body element_id="main-body">
+          <h1>Main Content</h1>
+          <iframe id="empty-javascript-iframe"
+                  element_id="empty-javascript-id"
+                  src="javascript:"
+                  width="300"
+                  height="200">
+          </iframe>
+          <iframe id="invalid-blob-iframe"
+                  element_id="invalid-blob-id"
+                  src="blob:null/invalid"
+                  width="300"
+                  height="200">
+          </iframe>
+          <p>Content after iframes</p>
+        </body>
+      </html>
+    `, {
+      waitUntil: "domcontentloaded",
+      timeout: 5000
+    });
+    const startTime = Date.now();
+    const content = await (0, _getContentWithNestedIframes.getContentWithNestedIframes)(page, 2.0);
+    const elapsedTime = Date.now() - startTime;
+    (0, _extendedTest.expect)(elapsedTime).toBeLessThan(10000);
+    (0, _extendedTest.expect)(content).toContain("Main Content");
+    (0, _extendedTest.expect)(content).toContain("Content after iframes");
+    (0, _extendedTest.expect)(content).toContain("empty-javascript-id");
+    (0, _extendedTest.expect)(content).toContain("invalid-blob-id");
+  });
+  (0, _extendedTest.test)("should handle legacy frame elements", async () => {
+    await page.setContent(`
+      <html>
+        <head><title>Legacy Frameset</title></head>
+        <frameset cols="50%,50%">
+          <frame id="frame-1"
+                 element_id="frame-1-id"
+                 src="data:text/html,<html><body><h2>Frame 1</h2><p>Frame 1 Content</p></body></html>">
+          </frame>
+          <frame id="frame-2"
+                 element_id="frame-2-id"
+                 src="data:text/html,<html><body><h2>Frame 2</h2><p>Frame 2 Content</p></body></html>">
+          </frame>
+        </frameset>
+      </html>
+    `, {
+      waitUntil: "domcontentloaded"
+    });
+    const content = await (0, _getContentWithNestedIframes.getContentWithNestedIframes)(page);
+    (0, _extendedTest.expect)(content.includes("frame-1-id") || content.includes("frame-2-id") || content.length > 0).toBe(true);
+  });
+  (0, _extendedTest.test)("should support custom HTML extractor to skip tags", async () => {
+    await page.setContent(`
+      <html>
+        <body element_id="main-body">
+          <h1>Main Content</h1>
+          <p>This is main page paragraph that should remain.</p>
+          <iframe id="test-iframe"
+                  element_id="test-iframe-id"
+                  srcdoc="<html><body><h2>Iframe Title</h2><p>This paragraph should be removed.</p><div>This div should remain.</div><p>Another paragraph to remove.</p></body></html>"
+                  width="300"
+                  height="200">
+          </iframe>
+          <p>Another main page paragraph that should remain.</p>
+        </body>
+      </html>
+    `, {
+      waitUntil: "domcontentloaded"
+    });
+    const customExtractor = async root => {
+      let htmlContent;
+      if ("content" in root && typeof root.content === "function") {
+        htmlContent = await root.content();
+      } else {
+        htmlContent = await root.evaluate(el => el.outerHTML);
+      }
+      const parsed = (0, _nodeHtmlParser.parse)(htmlContent);
+      const pTags = parsed.querySelectorAll("p");
+      pTags.forEach(p => p.remove());
+      return parsed.toString();
+    };
+    const content = await (0, _getContentWithNestedIframes.getContentWithNestedIframes)(page, 10000, customExtractor);
+    (0, _extendedTest.expect)(content).toContain("Main Content");
+    (0, _extendedTest.expect)(content).toContain("test-iframe-id");
+    (0, _extendedTest.expect)(content).toContain("Iframe Title");
+    (0, _extendedTest.expect)(content).toContain("This div should remain");
+    const pTagCount = (content.match(/<p>/g) || []).length;
+    (0, _extendedTest.expect)(pTagCount).toBe(0);
+    (0, _extendedTest.expect)(content).toContain("<h2>Iframe Title</h2>");
+    (0, _extendedTest.expect)(content).toContain("<div>This div should remain.</div>");
+    const iframeContentMatch = content.match(/<iframe-content[^>]*>(.*?)<\/iframe-content>/s);
+    (0, _extendedTest.expect)(iframeContentMatch).toBeTruthy();
+    if (iframeContentMatch) {
+      const nestedContent = iframeContentMatch[1];
+      (0, _extendedTest.expect)(nestedContent).not.toContain("<p>");
+    }
+  });
+  (0, _extendedTest.test)("should work with locator", async () => {
+    await page.setContent(`
+      <html>
+        <body>
+          <div id="container">
+            <h1>Container Content</h1>
+            <iframe srcdoc="<html><body><h2>Iframe in Container</h2></body></html>"></iframe>
+          </div>
+          <div id="other">
+            <p>Other content</p>
+          </div>
+        </body>
+      </html>`, {
+      waitUntil: "domcontentloaded"
+    });
+    await page.waitForSelector("#container iframe");
+    const locator = page.locator("#container");
+    const content = await (0, _getContentWithNestedIframes.getContentWithNestedIframes)(locator);
+    (0, _extendedTest.expect)(content).toContain("Container Content");
+    (0, _extendedTest.expect)(content).toContain("Iframe in Container");
+    (0, _extendedTest.expect)(content).not.toContain("Other content");
+  });
+});

package/dist/common/frame_utils/utils.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IFRAME_TAGS = exports.IFRAME_SRC_ATTRS = exports.IFRAME_REPLACEMENT_TAG = exports.IFRAME_PIXEL_SRC_DOMAINS = exports.IFRAME_CAPTCHA_SRC_PATTERNS = exports.ALL_IFRAMES_CSS_SELECTOR = void 0;
+exports.findTopLevelIframeElements = findTopLevelIframeElements;
+const IFRAME_TAGS = exports.IFRAME_TAGS = ["iframe", "frame"];
+const ALL_IFRAMES_CSS_SELECTOR = exports.ALL_IFRAMES_CSS_SELECTOR = IFRAME_TAGS.join(", ");
+const IFRAME_SRC_ATTRS = exports.IFRAME_SRC_ATTRS = ["src", "data-src", "data-lazy-src", "data-original-src", "data-url", "data-iframe-src"];
+const IFRAME_CAPTCHA_SRC_PATTERNS = exports.IFRAME_CAPTCHA_SRC_PATTERNS = ["google.com/recaptcha", "recaptcha.net/recaptcha", "gstatic.com/recaptcha", "hcaptcha.com", "hcaptcha.net", "funcaptcha.com", "arkoselabs.com", "challenges.cloudflare.com", "cloudflare.com/cdn-cgi/challenge", "cloudflare.com/turnstile", "geetest.com", "awswaf", "aws-waf", "leminnow.com", "captcha"];
+const IFRAME_PIXEL_SRC_DOMAINS = exports.IFRAME_PIXEL_SRC_DOMAINS = ["facebook.com/tr", "doubleclick.net", "google-analytics.com", "bat.bing.com", "analytics.twitter.com", "px.ads.linkedin.com", "t.co/i/adsct", "adsrvr.org", "demdex.net", "crwdcntrl.net"];
+const IFRAME_REPLACEMENT_TAG = exports.IFRAME_REPLACEMENT_TAG = {
+  iframe: "iframe-content",
+  frame: "frame-content"
+};
+async function findTopLevelIframeElements(root, skipUseless = true) {
+  let jsCode;
+  if (skipUseless) {
+    const srcAttrs = JSON.stringify(IFRAME_SRC_ATTRS);
+    const captchaPatterns = JSON.stringify(IFRAME_CAPTCHA_SRC_PATTERNS.map(p => p.toLowerCase()));
+    const pixelDomains = JSON.stringify(IFRAME_PIXEL_SRC_DOMAINS);
+    jsCode = `(root) => {
+    const srcAttrs = ${srcAttrs};
+    const captchaPatterns = ${captchaPatterns};
+    const pixelDomains = ${pixelDomains};
+
+    return Array.from(root.querySelectorAll('${ALL_IFRAMES_CSS_SELECTOR}')).filter(el => {
+        let url = '';
+        for (const attr of srcAttrs) {
+            const val = el.getAttribute(attr);
+            if (val) { url = val; break; }
+        }
+        const urlLower = url.toLowerCase();
+
+        if (captchaPatterns.some(p => urlLower.includes(p))) return false;
+        if (pixelDomains.some(d => urlLower.includes(d))) return false;
+
+        const w = el.getAttribute('width');
+        const h = el.getAttribute('height');
+        const style = el.getAttribute('style') || '';
+
+        const parseNum = (val) => {
+            if (!val) return null;
+            const str = String(val).trim();
+            if (/[%a-zA-Z]/.test(str)) return null;
+            const n = parseFloat(str);
+            return isNaN(n) ? null : n;
+        };
+
+        let width = parseNum(w);
+        let height = parseNum(h);
+
+        if (width === null) {
+            const wMatch = style.match(/width\\s*:\\s*(\\d+)/);
+            if (wMatch) width = parseFloat(wMatch[1]);
+        }
+        if (height === null) {
+            const hMatch = style.match(/height\\s*:\\s*(\\d+)/);
+            if (hMatch) height = parseFloat(hMatch[1]);
+        }
+
+        return !(width === 0 || width === 1 || height === 0 || height === 1);
+    });
+}`;
+  } else {
+    jsCode = `(root) => Array.from(root.querySelectorAll('${ALL_IFRAMES_CSS_SELECTOR}'))`;
+  }
+  let arrayHandle;
+  if ("elementHandle" in root) {
+    const element = await root.elementHandle();
+    if (!element) {
+      return [];
+    }
+    arrayHandle = await element.evaluateHandle((el, code) => {
+      const fn = new Function("return " + code)();
+      return fn(el);
+    }, jsCode);
+  } else {
+    arrayHandle = await root.evaluateHandle(`(${jsCode})(document)`);
+  }
+  const properties = await arrayHandle.getProperties();
+  const handles = [];
+  for (const jsHandle of properties.values()) {
+    const el = jsHandle.asElement();
+    if (el) {
+      handles.push(el);
+    }
+  }
+  return handles;
+}

package/dist/common/getSimplifiedHtml.js

@@ -4,17 +4,26 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getSimplifiedHtml = getSimplifiedHtml;
-async function getSimplifiedHtml(containerHandle, options) {
-  const tagName = await containerHandle.evaluateHandle(element => element.tagName.toLowerCase());
-  const ALLOWED_ATTRIBUTES = ["aria-label", "data-name", "name", "type", "placeholder", "value", "role", "title", "href", "id", "alt", new RegExp(/^data-/)];
-  const shouldReturnFullHtml = (await tagName.jsonValue()) === "html";
+async function getSimplifiedHtml(root, options) {
+  let containerHandle;
+  if ("content" in root && typeof root.content === "function") {
+    containerHandle = await root.locator("html").elementHandle();
+  } else {
+    containerHandle = await root.elementHandle();
+  }
+  if (!containerHandle) {
+    return "";
+  }
+  const tagNameHandle = await containerHandle.evaluateHandle(element => element.tagName.toLowerCase());
+  const tagName = await tagNameHandle.jsonValue();
+  const shouldReturnFullHtml = tagName === "html";
   const optionsWithDefault = {
-    shouldIncludeOnClick: false,
-    shouldIncludeContentAsProp: false,
-    keepOnlyVisibleElements: true,
-    shouldReturnFullHtml,
-    ...options
+    shouldIncludeOnClick: (options === null || options === void 0 ? void 0 : options.shouldIncludeOnClick) ?? false,
+    shouldIncludeContentAsProp: (options === null || options === void 0 ? void 0 : options.shouldIncludeContentAsProp) ?? false,
+    keepOnlyVisibleElements: (options === null || options === void 0 ? void 0 : options.keepOnlyVisibleElements) ?? true,
+    shouldReturnFullHtml
   };
+  const ALLOWED_ATTRIBUTES = ["aria-label", "data-name", "name", "type", "placeholder", "value", "role", "title", "href", "id", "alt", new RegExp(/^data-/)];
   const simplifiedHtml = await containerHandle.evaluate((element, {
     optionsWithDefault,
     ALLOWED_ATTRIBUTES
@@ -42,15 +51,6 @@ async function getSimplifiedHtml(containerHandle, options) {
     function isElementInteractive(element, style) {
       return element.tagName === "A" || element.tagName === "INPUT" || element.tagName === "BUTTON" || element.tagName === "SELECT" || element.tagName === "TEXTAREA" || element.hasAttribute("onclick") || element.hasAttribute("onmousedown") || element.hasAttribute("onmouseup") || element.hasAttribute("onkeydown") || element.hasAttribute("onkeyup") || style.cursor === "pointer";
     }
-    function getDocumentFromIframeElementSafely(element) {
-      try {
-        if (element.contentWindow && element.contentWindow.document) {
-          return element.contentWindow.document.documentElement;
-        }
-      } catch (error) {
-        return undefined;
-      }
-    }
     function isInputWithValue(element) {
       return element.tagName === "INPUT" && element.value && element.value.trim();
     }
@@ -59,7 +59,7 @@ async function getSimplifiedHtml(containerHandle, options) {
       if (element.nodeType === 3 && (_element$textContent = element.textContent) !== null && _element$textContent !== void 0 && _element$textContent.trim()) {
         return document.createTextNode(element.textContent + " ");
       }
-      const shouldSkipElementChecks = optionsWithDefault.shouldIncludeIframes ? ["BODY", "HTML", "IFRAME"] : ["BODY", "HTML"].includes(element.nodeName);
+      const shouldSkipElementChecks = ["BODY", "HTML"].includes(element.nodeName);
       if (!isElementNode(element)) {
         return null;
       }
@@ -68,7 +68,7 @@ async function getSimplifiedHtml(containerHandle, options) {
       if (keepOnlyVisibleElements && !isVisible && !isInputWithValue(element)) {
         return null;
       }
-      let children = optionsWithDefault.shouldIncludeIframes && element.nodeName === "IFRAME" ? [getDocumentFromIframeElementSafely(element)].filter(Boolean) : Array.from(element.childNodes).map(c => generateSimplifiedDom(c, interactiveElements, document, allowedAttributes, shouldIncludeContentAsProp, keepOnlyVisibleElements)).filter(truthyFilter);
+      let children = Array.from(element.childNodes).map(c => generateSimplifiedDom(c, interactiveElements, document, allowedAttributes, shouldIncludeContentAsProp, keepOnlyVisibleElements)).filter(truthyFilter);
       if (element.tagName === "BODY") children = children.filter(c => c.nodeType !== 3);
       const interactive = isElementInteractive(element, style) || element.hasAttribute("role");
       const hasLabel = element.hasAttribute("aria-label") || element.hasAttribute("name");

package/dist/common/matching/matching.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.createMatchesMapping = createMatchesMapping;
 exports.filterAndRankMatches = filterAndRankMatches;
 exports.isMatchExact = isMatchExact;
 exports.matchStringsWithDomContent = matchStringsWithDomContent;
@@ -12,7 +13,9 @@ exports.rankMatch = rankMatch;
 exports.removePunctuationAndSpaces = removePunctuationAndSpaces;
 exports.replaceWithBestMatches = replaceWithBestMatches;
 exports.selectBestMatch = selectBestMatch;
+exports.validateMatchesMapping = validateMatchesMapping;
 var _utils = require("../../helpers/utils");
+var _frame_utils = require("../frame_utils");
 const logger = {
   info: message => console.info(message),
   warning: message => console.warn(message),
@@ -153,22 +156,18 @@ function selectBestMatch({
 }
 async function matchStringsWithDomContent({
   pageObject,
-  stringsList,
-  container = null
+  stringsList
 }) {
   try {
     await (0, _utils.ensureBrowserScripts)(pageObject);
-    let handle;
-    if (container) {
-      handle = container;
-    } else {
-      handle = await pageObject.locator("html").elementHandle();
-    }
-    const matches = await pageObject.evaluate(async args => {
-      const [container, searchTexts] = args;
+    const htmlContent = await (0, _frame_utils.getContentWithNestedIframes)(pageObject);
+    const matches = await pageObject.evaluate(([htmlContent, searchTexts]) => {
       try {
         if (typeof window.__INTUNED__ !== "undefined" && typeof window.__INTUNED__.matchStringsWithDomContent === "function") {
-          return await window.__INTUNED__.matchStringsWithDomContent(container, searchTexts);
+          const parser = new DOMParser();
+          const doc = parser.parseFromString(htmlContent, "text/html");
+          const domNode = doc.body || doc.documentElement;
+          return window.__INTUNED__.matchStringsWithDomContent(domNode, searchTexts);
         } else {
           return searchTexts.reduce((acc, text) => {
             acc[text] = [];
@@ -182,7 +181,7 @@ async function matchStringsWithDomContent({
           return acc;
         }, {});
       }
-    }, [handle, stringsList]);
+    }, [htmlContent, stringsList]);
     return matches;
   } catch (error) {
     logger.warning(`Error matching strings with DOM content: ${error}`);
@@ -194,13 +193,11 @@ async function matchStringsWithDomContent({
 }
 async function replaceWithBestMatches({
   stringsToMatch,
-  pageObject,
-  container = null
+  pageObject
 }) {
   const matchesMap = await matchStringsWithDomContent({
     pageObject,
-    stringsList: stringsToMatch,
-    container
+    stringsList: stringsToMatch
   });
   const replacements = {};
   const xpathMapping = {};
@@ -222,6 +219,84 @@ async function replaceWithBestMatches({
     xpathMapping
   };
 }
+async function createMatchesMapping(page, extractedData) {
+  const uniqueValues = new Set();
+  if (Array.isArray(extractedData)) {
+    if (extractedData.length > 0 && typeof extractedData[0] === "string") {
+      extractedData.forEach(value => uniqueValues.add(String(value)));
+    } else {
+      extractedData.forEach(obj => {
+        if (typeof obj === "object" && obj !== null) {
+          Object.values(obj).forEach(value => uniqueValues.add(String(value)));
+        }
+      });
+    }
+  } else if (typeof extractedData === "object" && extractedData !== null) {
+    Object.values(extractedData).forEach(value => uniqueValues.add(String(value)));
+  }
+  const matchesMap = await matchStringsWithDomContent({
+    pageObject: page,
+    stringsList: Array.from(uniqueValues)
+  });
+  const mapping = {};
+  for (const [value, matches] of Object.entries(matchesMap)) {
+    const filteredMatches = matches.filter(match => {
+      if (match.match_mode !== "fuzzy") {
+        return true;
+      }
+      const rank = rankMatch({
+        original: value,
+        match: match.matched_value
+      });
+      return rank === "HIGH";
+    });
+    mapping[value] = filteredMatches.map(match => ({
+      xpath: match.xpath || "",
+      matched_value: match.matched_value || ""
+    }));
+  }
+  return mapping;
+}
+async function validateMatchesMapping(page, cachedMapping) {
+  try {
+    const stringsToCheck = Object.keys(cachedMapping);
+    const currentMatches = await matchStringsWithDomContent({
+      pageObject: page,
+      stringsList: stringsToCheck
+    });
+    for (const [value, cachedMatchList] of Object.entries(cachedMapping)) {
+      if (!(value in currentMatches)) {
+        return false;
+      }
+      const currentMatchList = currentMatches[value].map(match => ({
+        xpath: match.xpath || "",
+        matched_value: match.matched_value || ""
+      }));
+      const cachedSorted = [...cachedMatchList].sort((a, b) => {
+        const aKey = `${a.xpath}|${a.matched_value}`;
+        const bKey = `${b.xpath}|${b.matched_value}`;
+        return aKey.localeCompare(bKey);
+      });
+      const currentSorted = [...currentMatchList].sort((a, b) => {
+        const aKey = `${a.xpath}|${a.matched_value}`;
+        const bKey = `${b.xpath}|${b.matched_value}`;
+        return aKey.localeCompare(bKey);
+      });
+      if (cachedSorted.length !== currentSorted.length) {
+        return false;
+      }
+      for (let i = 0; i < cachedSorted.length; i++) {
+        if (cachedSorted[i].xpath !== currentSorted[i].xpath || cachedSorted[i].matched_value !== currentSorted[i].matched_value) {
+          return false;
+        }
+      }
+    }
+    return true;
+  } catch (error) {
+    logger.error(`Error validating matches mapping: ${error}`);
+    return false;
+  }
+}
 async function filterAndRankMatches(frame, matches) {
   const filteredMatches = matches.filter(match => {
     const xpath = match.xpath;