@intuned/browser-dev 2.2.3-test-build.0

package/dist/optimized-extractors/listExtractionHelpers/utils/getSimplifiedHtmlPerListItem.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSimplifiedHtmlPerListItem = getSimplifiedHtmlPerListItem;
+var _getSimplifiedHtml = require("../../objectExtractionHelpers/getSimplifiedHtml");
+async function getSimplifiedHtmlPerListItem(itemsLocators) {
+  const result = [];
+  for (let i = 0; i < itemsLocators.length; i++) {
+    const locator = itemsLocators[i];
+    const handle = await locator.elementHandle();
+    const htmlForItem = await (0, _getSimplifiedHtml.getSimplifiedHtml)(handle, {
+      keepOnlyVisibleElements: false,
+      shouldIncludeContentAsProp: true,
+      shouldIncludeOnClick: true
+    });
+    result.push(htmlForItem);
+  }
+  return result;
+}

package/dist/optimized-extractors/listExtractionHelpers/utils/tablesUtils.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createJsonFromTable = createJsonFromTable;
+exports.isListTable = isListTable;
+async function isListTable(containerLocator, itemsSimplifiedHtml) {
+  const parentTableLocator = containerLocator.locator("xpath=ancestor::table[1]");
+  const hasParentTable = (await parentTableLocator.all()).length !== 0;
+  if (!hasParentTable) {
+    return {
+      tableLocater: undefined,
+      isTable: false
+    };
+  }
+  const table = await parentTableLocator.elementHandle({
+    timeout: 1_000
+  });
+  const allItemsContainTr = itemsSimplifiedHtml.every(item => item.includes("<tr"));
+  return {
+    tableLocater: table,
+    isTable: !!table && !!allItemsContainTr
+  };
+}
+async function createJsonFromTable(page) {
+  return await page.evaluate(() => {
+    function compressStringSpaces(str) {
+      return str.replace(/\s+/g, " ").trim();
+    }
+    const table = document.querySelector("table");
+    if (!table) {
+      return [];
+    }
+    const headers = Array.from(table.querySelectorAll("th")).map(th => th === null || th === void 0 ? void 0 : th.textContent).map(header => header && compressStringSpaces(header));
+    const rows = Array.from(table.querySelectorAll("tr"));
+    const jsonArray = rows.slice(1).map(tr => {
+      const cells = Array.from(tr.querySelectorAll("td"));
+      const rowObject = headers.reduce((obj, header, index) => {
+        var _cells$index;
+        if (header) obj[header] = ((_cells$index = cells[index]) === null || _cells$index === void 0 ? void 0 : _cells$index.textContent) ?? "";
+        return obj;
+      }, {});
+      return rowObject;
+    });
+    return jsonArray;
+  });
+}

package/dist/optimized-extractors/listExtractionHelpers/utils/validateOptions.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateDynamicListExtractorOptions = validateDynamicListExtractorOptions;
+var _neverthrow = require("neverthrow");
+var Errors = _interopRequireWildcard(require("../errors"));
+var _locatorHelpers = require("../../../common/locatorHelpers");
+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); }
+async function validateDynamicListExtractorOptions(page, label, options) {
+  if (typeof label !== "string") {
+    return (0, _neverthrow.err)(Errors.invalidInput("Identifier must be a string."));
+  }
+  const searchRegion = options.searchRegion ?? page.locator("html");
+  const elementExist = (await searchRegion.count().catch(e => {
+    return 0;
+  })) > 0;
+  if (!elementExist) {
+    return (0, _neverthrow.err)(Errors.invalidSearchRegion());
+  }
+  const searchRegionHandler = await searchRegion.elementHandle();
+  if (!searchRegionHandler) {
+    return (0, _neverthrow.err)(Errors.invalidSearchRegion());
+  }
+  const pageUrl = page.url();
+  const getPageUrlOrigin = () => new URL(pageUrl).origin;
+  const safeGetPageUrlOrigin = (0, _neverthrow.fromThrowable)(getPageUrlOrigin, () => Errors.invalidAddressUrl("Cannot get page url origin."));
+  const variantKey = options.variantKey ? (0, _neverthrow.ok)(options.variantKey) : safeGetPageUrlOrigin();
+  if (variantKey.isErr()) {
+    return (0, _neverthrow.err)(variantKey.error);
+  }
+  const invalidate = options.optionalPropertiesInvalidator ?? (() => []);
+  const primaryProperty = Object.entries(options.itemEntitySchema.properties).find(([k, v]) => v.primary);
+  return (0, _neverthrow.ok)({
+    itemEntityName: options.itemEntityName,
+    itemEntitySchema: options.itemEntitySchema,
+    variantKey: variantKey.value ?? "about:blank",
+    invalidate,
+    pageUrl,
+    primaryProperty: primaryProperty,
+    searchRegionHandler,
+    searchRegion,
+    hasSearchRegionContainer: !!options.searchRegion,
+    label,
+    searchRegionKey: options.searchRegion ? (0, _locatorHelpers.getLocatorInternalKey)(options.searchRegion) : null,
+    strategy: options.strategy,
+    prompt: options.prompt,
+    searchRegionXpath: options.searchRegion ? await (0, _locatorHelpers.findXPathForLocator)(options.searchRegion) : undefined,
+    apiKey: options.apiKey
+  });
+}

package/dist/optimized-extractors/models/anthropicModel.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAnthropicInstance = createAnthropicInstance;
+var _dotenv = require("dotenv");
+var _jwtTokenManager = require("../../common/jwtTokenManager");
+var _sdk = _interopRequireDefault(require("@anthropic-ai/sdk"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+(0, _dotenv.config)();
+function createAnthropicInstance(options) {
+  if (options !== null && options !== void 0 && options.apiKey) {
+    return new _sdk.default({
+      apiKey: options.apiKey
+    });
+  }
+  return new _sdk.default({
+    apiKey: "--THI_VALUE_WILL_BE_REPLACED_BY_INTUNED_BE--",
+    baseURL: `${process.env.FUNCTIONS_DOMAIN}/api/${process.env.INTUNED_WORKSPACE_ID}/functions/${process.env.INTUNED_INTEGRATION_ID}/anthropic`,
+    fetch: _jwtTokenManager.backendFunctionsTokenManager.fetchWithToken.bind(_jwtTokenManager.backendFunctionsTokenManager)
+  });
+}

package/dist/optimized-extractors/models/openaiModel.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createOpenAIInstance = createOpenAIInstance;
+var _openai = require("openai");
+var _dotenv = require("dotenv");
+var _jwtTokenManager = require("../../common/jwtTokenManager");
+(0, _dotenv.config)();
+function createOpenAIInstance(options) {
+  if (options !== null && options !== void 0 && options.apiKey) {
+    return new _openai.OpenAI({
+      apiKey: options.apiKey
+    });
+  }
+  const openai = new _openai.OpenAI({
+    apiKey: "",
+    baseURL: `${process.env.FUNCTIONS_DOMAIN}/api/${process.env.INTUNED_WORKSPACE_ID}/functions/${process.env.INTUNED_INTEGRATION_ID}/openai`,
+    fetch: _jwtTokenManager.backendFunctionsTokenManager.fetchWithToken.bind(_jwtTokenManager.backendFunctionsTokenManager)
+  });
+  return openai;
+}

package/dist/optimized-extractors/objectExtractionHelpers/AIExtractors.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runAIExtraction = runAIExtraction;
+var _neverthrow = require("neverthrow");
+var z = _interopRequireWildcard(require("zod"));
+var Errors = _interopRequireWildcard(require("./errors"));
+var _findDomMatches = require("./findDomMatches");
+var _noEmpty = _interopRequireDefault(require("../../common/noEmpty"));
+var _common = require("../common");
+var _buildImagesFromPage = require("../common/buildImagesFromPage");
+var _Logger = require("../../common/Logger");
+var _utils = require("../common/matching/utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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); }
+async function runAIExtraction(pageAndSearchRegion, extractionInfo, snapshot, strategy, hasSearchRegionContainer, prompt, apiKey) {
+  const images = strategy.type === "IMAGE" ? await (0, _buildImagesFromPage.buildImagesFromPageOrHandle)(pageAndSearchRegion.page, hasSearchRegionContainer ? pageAndSearchRegion.searchRegionHandler : undefined) : undefined;
+  if (images && images.isErr()) {
+    return (0, _neverthrow.err)(Errors.other(images.error.context));
+  }
+  const textContent = [];
+  if (strategy.type === "HTML") {
+    textContent.push(snapshot.html);
+  }
+  const result = await (0, _common.extractStructuredDataUsingAi)({
+    entityName: extractionInfo.entityName,
+    jsonSchema: extractionInfo.entitySchema,
+    model: strategy.model,
+    text: textContent,
+    images: images === null || images === void 0 ? void 0 : images.value.map(image => ({
+      data: image,
+      image_type: "png"
+    })),
+    identifier: extractionInfo.identifier,
+    systemMessage: prompt,
+    apiKey
+  });
+  if (result.isErr()) {
+    return (0, _neverthrow.err)(Errors.invalidExtractionResult(result.error.context));
+  }
+  const extractedData = result.value.result;
+  _Logger.logger.debug("Extracted data from AI", extractedData);
+  const extractedDataParsingValidation = z.record(z.string(), z.string().nullable()).safeParse(extractedData);
+  if (!extractedDataParsingValidation.success) return (0, _neverthrow.err)(Errors.invalidExtractionResult(`Failed to parse extraction result. ${extractedDataParsingValidation.error.message}`));
+  const extractedObject = extractedDataParsingValidation.data;
+  const extractedValues = Object.values(extractedObject).filter(_noEmpty.default);
+  const matchResults = await (0, _neverthrow.fromPromise)((0, _findDomMatches.getDomMatches)(pageAndSearchRegion.page, pageAndSearchRegion.searchRegionHandler, extractedValues), e => Errors.other("Failed to get dom matches.", e));
+  if (matchResults.isErr()) return (0, _neverthrow.err)(matchResults.error);
+  const foundValues = matchResults.value;
+  const toReturn = {};
+  const xpathMapping = {};
+  Object.entries(extractedObject).forEach(([propertyName, extractedPropertyValue]) => {
+    const matches = extractedPropertyValue ? foundValues.get(extractedPropertyValue) : [];
+    const bestMatch = extractedPropertyValue && matches ? (0, _utils.selectBestMatch)(extractedPropertyValue, matches) : undefined;
+    if (bestMatch) {
+      toReturn[propertyName] = bestMatch.matchText;
+      xpathMapping[propertyName] = {
+        matchXpath: bestMatch.matchXpath,
+        matchText: bestMatch.matchText,
+        matchType: bestMatch.matchType
+      };
+    } else {
+      _Logger.logger.debug(`Property ${propertyName} not found in the page HTML, dropped for hallucination protection`);
+    }
+  });
+  return (0, _neverthrow.ok)({
+    extractionResultObject: toReturn,
+    valueDomMatches: matchResults.value,
+    xpathMapping
+  });
+}

package/dist/optimized-extractors/objectExtractionHelpers/__tests__/checksumUtils.test.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var _vitest = require("vitest");
+var _checksumUtils = require("../checksumUtils");
+(0, _vitest.describe)("hashObject", () => {
+  (0, _vitest.test)("should work regardless of property order", () => {
+    const obj1 = {
+      foo: [{
+        c: 1,
+        test: true
+      }, {
+        d: 2,
+        e: 3
+      }],
+      bar: {
+        a: 2,
+        b: undefined
+      }
+    };
+    const obj2 = {
+      bar: {
+        b: undefined,
+        a: 2
+      },
+      foo: [{
+        test: true,
+        c: 1
+      }, {
+        e: 3,
+        d: 2
+      }]
+    };
+    const res1 = (0, _checksumUtils.hashObject)(obj1);
+    (0, _vitest.expect)(res1).toBeTruthy();
+    (0, _vitest.expect)((0, _checksumUtils.hashObject)(obj1)).toEqual((0, _checksumUtils.hashObject)(obj2));
+  });
+  (0, _vitest.test)("should result in different hashes with a diff in a space in a string", () => {
+    const obj1 = {
+      foo: [{
+        c: 1,
+        test: "true"
+      }, {
+        d: 2,
+        e: 3
+      }],
+      bar: {
+        a: 2,
+        b: undefined
+      }
+    };
+    const obj2 = {
+      bar: {
+        b: undefined,
+        a: 2
+      },
+      foo: [{
+        test: "true ",
+        c: 1
+      }, {
+        e: 3,
+        d: 2
+      }]
+    };
+    const res1 = (0, _checksumUtils.hashObject)(obj1);
+    (0, _vitest.expect)(res1).toBeTruthy();
+    (0, _vitest.expect)((0, _checksumUtils.hashObject)(obj1)).not.toEqual((0, _checksumUtils.hashObject)(obj2));
+  });
+  (0, _vitest.test)("should work with Map<string, Match[]>", () => {
+    const map1 = new Map();
+    map1.set("foo", [{
+      nodeXpath: "foo",
+      matchXpath: "foo",
+      exact: true,
+      matchType: "direct-text",
+      matchText: "foo",
+      sourceText: "foo"
+    }, {
+      nodeXpath: "boo",
+      matchXpath: "coo",
+      exact: true,
+      matchType: "direct-text",
+      matchText: "doo",
+      sourceText: "foo"
+    }]);
+    const map2 = new Map();
+    map2.set("foo", [{
+      nodeXpath: "boo",
+      matchXpath: "coo",
+      exact: true,
+      matchType: "direct-text",
+      matchText: "doo",
+      sourceText: "foo"
+    }, {
+      nodeXpath: "foo",
+      matchXpath: "foo",
+      exact: true,
+      matchType: "direct-text",
+      matchText: "foo",
+      sourceText: "foo"
+    }]);
+    (0, _vitest.expect)((0, _checksumUtils.hashObject)(map1, true)).toEqual((0, _checksumUtils.hashObject)(map2, true));
+  });
+});

package/dist/optimized-extractors/objectExtractionHelpers/__tests__/testObjectExtractorFromLocator.spec.js

@@ -0,0 +1,107 @@
+"use strict";
+
+var _extendedTest = require("../../../common/extendedTest");
+var _ = require("../..");
+var _uuid = require("uuid");
+const productTemplate = `
+<div class="product-page">
+  <div class="product-info">
+    <h1 class="product-title">iPhone 14 Pro</h1>
+    <div class="price-container">
+      <span class="price">$999</span>
+    </div>
+    <div class="description">
+      <p class="product-description">Latest iPhone with advanced camera system</p>
+    </div>
+  </div>
+  <div class="additional-info">
+    <div class="shipping-info">Free shipping available</div>
+    <div class="warranty">2-year warranty included</div>
+  </div>
+  <div class="reviews-section">
+    <div class="review-count">125 reviews</div>
+    <div class="rating">4.8/5 stars</div>
+  </div>
+</div>
+`;
+(0, _extendedTest.describe)("Object Extractor Caching Tests", () => {
+  (0, _extendedTest.describe)("DOM Changes and Cache Behavior", () => {
+    (0, _extendedTest.test)("should demonstrate caching behavior with different types of DOM changes", async ({
+      page
+    }) => {
+      const testLabel = `product-cache-test-${(0, _uuid.v4)()}`;
+      const variantKey = testLabel;
+      const entitySchema = {
+        type: "object",
+        required: ["title", "price"],
+        properties: {
+          title: {
+            type: "string",
+            description: "Product title"
+          },
+          price: {
+            type: "string",
+            description: "Product price"
+          },
+          description: {
+            type: "string",
+            description: "Product description"
+          }
+        }
+      };
+      const extractionOptions = {
+        entityName: "product",
+        label: testLabel,
+        entitySchema,
+        strategy: {
+          model: "claude-3-5-sonnet-20240620",
+          type: "HTML"
+        },
+        variantKey: variantKey,
+        apiKey: process.env.ANTHROPIC_API_KEY
+      };
+      await page.setContent(productTemplate);
+      const firstResult = await (0, _.extractObjectFromLocator)(page.locator(".product-page"), extractionOptions);
+      console.log("First extraction result:", firstResult);
+      (0, _extendedTest.expect)(firstResult).toHaveProperty("title", "iPhone 14 Pro");
+      (0, _extendedTest.expect)(firstResult).toHaveProperty("price", "$999");
+      (0, _extendedTest.expect)(firstResult).toHaveProperty("description", "Latest iPhone with advanced camera system");
+      const modifiedTemplate = productTemplate.replace("iPhone 14 Pro", "iPhone 15 Pro Max").replace("$999", "$1199");
+      await page.setContent(modifiedTemplate);
+      const secondResult = await (0, _.extractObjectFromLocator)(page.locator(".product-page"), extractionOptions);
+      console.log("Second extraction result (after relevant change):", secondResult);
+      (0, _extendedTest.expect)(secondResult).not.toEqual(firstResult);
+      (0, _extendedTest.expect)(secondResult).toHaveProperty("title", "iPhone 15 Pro Max");
+      (0, _extendedTest.expect)(secondResult).toHaveProperty("price", "$1199");
+      const irrelevantChangeTemplate = modifiedTemplate.replace("Free shipping available", "Express shipping available").replace("2-year warranty included", "3-year warranty included").replace("125 reviews", "200 reviews");
+      await page.setContent(irrelevantChangeTemplate);
+      const thirdResult = await (0, _.extractObjectFromLocator)(page.locator(".product-page"), extractionOptions);
+      console.log("Third extraction result (after irrelevant change):", thirdResult);
+      (0, _extendedTest.expect)(thirdResult).toEqual(secondResult);
+      (0, _extendedTest.expect)(thirdResult).toHaveProperty("title", "iPhone 15 Pro Max");
+      (0, _extendedTest.expect)(thirdResult).toHaveProperty("price", "$1199");
+      const appendedTemplate = irrelevantChangeTemplate + `
+      <div class="newly-added-section">
+        <div class="social-media">
+          <button class="share-facebook">Share on Facebook</button>
+          <button class="share-twitter">Share on Twitter</button>
+        </div>
+        <div class="related-products">
+          <h3>Related Products</h3>
+          <div class="product-list">
+            <div class="related-item">AirPods Pro</div>
+            <div class="related-item">MacBook Air</div>
+          </div>
+        </div>
+      </div>
+      `;
+      await page.setContent(appendedTemplate);
+      const fourthResult = await (0, _.extractObjectFromLocator)(page.locator(".product-page"), extractionOptions);
+      console.log("Fourth extraction result (after appending content):", fourthResult);
+      (0, _extendedTest.expect)(fourthResult).toEqual(thirdResult);
+      (0, _extendedTest.expect)(fourthResult).toHaveProperty("title", "iPhone 15 Pro Max");
+      (0, _extendedTest.expect)(fourthResult).toHaveProperty("price", "$1199");
+      console.log("All cache behavior tests completed successfully!");
+    });
+  });
+});

package/dist/optimized-extractors/objectExtractionHelpers/__tests__/testObjectExtractorFromPage.spec.js

@@ -0,0 +1,107 @@
+"use strict";
+
+var _extendedTest = require("../../../common/extendedTest");
+var _ = require("../..");
+var _uuid = require("uuid");
+const productTemplate = `
+<div class="product-page">
+  <div class="product-info">
+    <h1 class="product-title">iPhone 14 Pro</h1>
+    <div class="price-container">
+      <span class="price">$999</span>
+    </div>
+    <div class="description">
+      <p class="product-description">Latest iPhone with advanced camera system</p>
+    </div>
+  </div>
+  <div class="additional-info">
+    <div class="shipping-info">Free shipping available</div>
+    <div class="warranty">2-year warranty included</div>
+  </div>
+  <div class="reviews-section">
+    <div class="review-count">125 reviews</div>
+    <div class="rating">4.8/5 stars</div>
+  </div>
+</div>
+`;
+(0, _extendedTest.describe)("Object Extractor Caching Tests", () => {
+  (0, _extendedTest.describe)("DOM Changes and Cache Behavior", () => {
+    (0, _extendedTest.test)("should demonstrate caching behavior with different types of DOM changes", async ({
+      page
+    }) => {
+      const testLabel = `product-cache-test-${(0, _uuid.v4)()}`;
+      const variantKey = testLabel;
+      const entitySchema = {
+        type: "object",
+        required: ["title", "price"],
+        properties: {
+          title: {
+            type: "string",
+            description: "Product title"
+          },
+          price: {
+            type: "string",
+            description: "Product price"
+          },
+          description: {
+            type: "string",
+            description: "Product description"
+          }
+        }
+      };
+      const extractionOptions = {
+        entityName: "product",
+        label: testLabel,
+        entitySchema,
+        strategy: {
+          model: "claude-3-5-sonnet-20240620",
+          type: "HTML"
+        },
+        variantKey: variantKey,
+        apiKey: process.env.ANTHROPIC_API_KEY
+      };
+      await page.setContent(productTemplate);
+      const firstResult = await (0, _.extractObjectFromPage)(page, extractionOptions);
+      console.log("First extraction result:", firstResult);
+      (0, _extendedTest.expect)(firstResult).toHaveProperty("title", "iPhone 14 Pro");
+      (0, _extendedTest.expect)(firstResult).toHaveProperty("price", "$999");
+      (0, _extendedTest.expect)(firstResult).toHaveProperty("description", "Latest iPhone with advanced camera system");
+      const modifiedTemplate = productTemplate.replace("iPhone 14 Pro", "iPhone 15 Pro Max").replace("$999", "$1199");
+      await page.setContent(modifiedTemplate);
+      const secondResult = await (0, _.extractObjectFromPage)(page, extractionOptions);
+      console.log("Second extraction result (after relevant change):", secondResult);
+      (0, _extendedTest.expect)(secondResult).not.toEqual(firstResult);
+      (0, _extendedTest.expect)(secondResult).toHaveProperty("title", "iPhone 15 Pro Max");
+      (0, _extendedTest.expect)(secondResult).toHaveProperty("price", "$1199");
+      const irrelevantChangeTemplate = modifiedTemplate.replace("Free shipping available", "Express shipping available").replace("2-year warranty included", "3-year warranty included").replace("125 reviews", "200 reviews");
+      await page.setContent(irrelevantChangeTemplate);
+      const thirdResult = await (0, _.extractObjectFromPage)(page, extractionOptions);
+      console.log("Third extraction result (after irrelevant change):", thirdResult);
+      (0, _extendedTest.expect)(thirdResult).toEqual(secondResult);
+      (0, _extendedTest.expect)(thirdResult).toHaveProperty("title", "iPhone 15 Pro Max");
+      (0, _extendedTest.expect)(thirdResult).toHaveProperty("price", "$1199");
+      const appendedTemplate = irrelevantChangeTemplate + `
+      <div class="newly-added-section">
+        <div class="social-media">
+          <button class="share-facebook">Share on Facebook</button>
+          <button class="share-twitter">Share on Twitter</button>
+        </div>
+        <div class="related-products">
+          <h3>Related Products</h3>
+          <div class="product-list">
+            <div class="related-item">AirPods Pro</div>
+            <div class="related-item">MacBook Air</div>
+          </div>
+        </div>
+      </div>
+      `;
+      await page.setContent(appendedTemplate);
+      const fourthResult = await (0, _.extractObjectFromPage)(page, extractionOptions);
+      console.log("Fourth extraction result (after appending content):", fourthResult);
+      (0, _extendedTest.expect)(fourthResult).toEqual(thirdResult);
+      (0, _extendedTest.expect)(fourthResult).toHaveProperty("title", "iPhone 15 Pro Max");
+      (0, _extendedTest.expect)(fourthResult).toHaveProperty("price", "$1199");
+      console.log("All cache behavior tests completed successfully!");
+    });
+  });
+});

package/dist/optimized-extractors/objectExtractionHelpers/calculateObjectExampleHash.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateObjectExampleHash = calculateObjectExampleHash;
+var _checksumUtils = require("./checksumUtils");
+function calculateObjectExampleHash({
+  currentPageUrl,
+  entityDescription,
+  entityName,
+  entitySchema,
+  strategy,
+  variantKey,
+  searchRegionLocator,
+  prompt
+}) {
+  return (0, _checksumUtils.hashObject)({
+    currentPageUrl,
+    entityName,
+    entityDescription,
+    entitySchema,
+    variantKey,
+    strategy,
+    searchRegionLocator,
+    prompt
+  }, true);
+}

package/dist/optimized-extractors/objectExtractionHelpers/captureSnapshot.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.captureSnapshot = captureSnapshot;
+var _neverthrow = require("neverthrow");
+var Errors = _interopRequireWildcard(require("./errors"));
+var _getSimplifiedHtml = require("./getSimplifiedHtml");
+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); }
+async function captureSnapshot(pageAndSearchRegion) {
+  const snapshot = (0, _neverthrow.fromPromise)((async () => {
+    const html = await (0, _getSimplifiedHtml.getSimplifiedHtml)(pageAndSearchRegion.searchRegionHandler);
+    return {
+      html,
+      dateCreated: new Date().toISOString(),
+      url: pageAndSearchRegion.page.url(),
+      extractionHtml: await pageAndSearchRegion.searchRegion.evaluate(element => element.outerHTML),
+      pageHtml: await pageAndSearchRegion.page.content()
+    };
+  })(), e => {
+    console.log(e);
+    return Errors.other("Failed to get simplified html.", e);
+  });
+  return snapshot;
+}

package/dist/optimized-extractors/objectExtractionHelpers/checksumUtils.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hashObject = hashObject;
+var crypto = _interopRequireWildcard(require("crypto"));
+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); }
+function _serialize(obj, treatArraysAsUnsortedLists) {
+  if (obj instanceof Map) {
+    return _serialize(Array.from(obj.entries()), treatArraysAsUnsortedLists);
+  } else if (Array.isArray(obj)) {
+    let serializedSortedArray = obj.map(el => _serialize(el, treatArraysAsUnsortedLists));
+    if (treatArraysAsUnsortedLists) {
+      serializedSortedArray = serializedSortedArray.sort();
+    }
+    return `[${serializedSortedArray.join(",")}]`;
+  } else if (typeof obj === "object" && obj !== null) {
+    let acc = "";
+    const keys = Object.keys(obj).sort();
+    acc += `{${JSON.stringify(keys)}`;
+    for (let i = 0; i < keys.length; i++) {
+      acc += `${_serialize(obj[keys[i]], treatArraysAsUnsortedLists)},`;
+    }
+    return `${acc}}`;
+  }
+  return `${JSON.stringify(obj)}`;
+}
+function hashObject(obj, treatArraysAsUnsortedLists = false, hashAlgorithm = "SHA256", encoding = "hex") {
+  const hash = crypto.createHash(hashAlgorithm);
+  return hash.update(_serialize(obj, treatArraysAsUnsortedLists)).digest(encoding);
+}

package/dist/optimized-extractors/objectExtractionHelpers/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ALLOWED_ATTRIBUTES = void 0;
+const ALLOWED_ATTRIBUTES = exports.ALLOWED_ATTRIBUTES = ["aria-label", "data-name", "name", "type", "placeholder", "value", "role", "title", "href", "id", "alt", new RegExp(/^data-/)];