@detiq/crawler 1.1.9 → 1.1.11

package/dist/pdf-extractor.js

@@ -1,99 +1,81 @@
-/**
- * PDF extraction — discovers and extracts text from PDF URLs found during crawl.
- *
- * When the HTTP engine or browser engine discovers a link to a .pdf file,
- * this module fetches the PDF, extracts its text content, and returns it
- * as a screen-compatible markdown string for test generation.
- *
- * Uses pdf-parse (already installed in API package, accessible via dynamic import).
- */
 const PDF_EXT = /\.pdf(\?.*)?$/i;
-const PDF_MIME = 'application/pdf';
-export function isPdfUrl(url, contentType) {
-    return PDF_EXT.test(url) || (contentType?.includes(PDF_MIME) ?? false);
+const PDF_MIME = "application/pdf";
+function isPdfUrl(url, contentType) {
+  return PDF_EXT.test(url) || (contentType?.includes(PDF_MIME) ?? false);
 }
-export async function extractPdfFromUrl(url, opts = {}) {
-    const { userAgent = 'ZeTa-Crawler/1.0', timeoutMs = 30_000, maxSizeBytes = 50 * 1024 * 1024 } = opts;
-    let buffer;
-    let sizeBytes;
-    try {
-        const response = await fetch(url, {
-            headers: { 'User-Agent': userAgent, 'Accept': 'application/pdf,*/*' },
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        if (!response.ok)
-            return null;
-        const contentType = response.headers.get('content-type') ?? '';
-        if (!contentType.includes('pdf') && !PDF_EXT.test(url))
-            return null;
-        const arrayBuffer = await response.arrayBuffer();
-        sizeBytes = arrayBuffer.byteLength;
-        if (sizeBytes > maxSizeBytes) {
-            console.warn(`[pdf-extractor] PDF too large (${sizeBytes} bytes), skipping: ${url}`);
-            return null;
-        }
-        buffer = Buffer.from(arrayBuffer);
-    }
-    catch (e) {
-        console.error(`[pdf-extractor] Failed to fetch PDF ${url}: ${e.message}`);
-        return null;
-    }
-    try {
-        // pdf-parse is installed in the API package — use dynamic import
-        // so this file compiles without adding pdf-parse to crawler's package.json
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore – no types for pdf-parse/lib/pdf-parse.js
-        const pdfParse = await import('pdf-parse/lib/pdf-parse.js').catch(() => import('pdf-parse'));
-        const parse = pdfParse.default ?? pdfParse;
-        const data = await parse(buffer, { max: 0 }); // max: 0 = all pages
-        const title = data.info?.Title || extractTitleFromUrl(url);
-        const markdown = pdfTextToMarkdown(data.text ?? '', title);
-        return {
-            url,
-            title,
-            markdown,
-            pageCount: data.numpages ?? 0,
-            info: {
-                author: data.info?.Author ?? '',
-                subject: data.info?.Subject ?? '',
-                keywords: data.info?.Keywords ?? '',
-                creator: data.info?.Creator ?? '',
-            },
-            sizeBytes,
-        };
-    }
-    catch (e) {
-        console.error(`[pdf-extractor] Failed to parse PDF ${url}: ${e.message}`);
-        return null;
+async function extractPdfFromUrl(url, opts = {}) {
+  const { userAgent = "ZeTa-Crawler/1.0", timeoutMs = 3e4, maxSizeBytes = 50 * 1024 * 1024 } = opts;
+  let buffer;
+  let sizeBytes;
+  try {
+    const response = await fetch(url, {
+      headers: { "User-Agent": userAgent, "Accept": "application/pdf,*/*" },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!response.ok) return null;
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.includes("pdf") && !PDF_EXT.test(url)) return null;
+    const arrayBuffer = await response.arrayBuffer();
+    sizeBytes = arrayBuffer.byteLength;
+    if (sizeBytes > maxSizeBytes) {
+      console.warn(`[pdf-extractor] PDF too large (${sizeBytes} bytes), skipping: ${url}`);
+      return null;
     }
+    buffer = Buffer.from(arrayBuffer);
+  } catch (e) {
+    console.error(`[pdf-extractor] Failed to fetch PDF ${url}: ${e.message}`);
+    return null;
+  }
+  try {
+    const pdfParse = await import("pdf-parse/lib/pdf-parse.js").catch(
+      () => import("pdf-parse")
+    );
+    const parse = pdfParse.default ?? pdfParse;
+    const data = await parse(buffer, { max: 0 });
+    const title = data.info?.Title || extractTitleFromUrl(url);
+    const markdown = pdfTextToMarkdown(data.text ?? "", title);
+    return {
+      url,
+      title,
+      markdown,
+      pageCount: data.numpages ?? 0,
+      info: {
+        author: data.info?.Author ?? "",
+        subject: data.info?.Subject ?? "",
+        keywords: data.info?.Keywords ?? "",
+        creator: data.info?.Creator ?? ""
+      },
+      sizeBytes
+    };
+  } catch (e) {
+    console.error(`[pdf-extractor] Failed to parse PDF ${url}: ${e.message}`);
+    return null;
+  }
 }
 function extractTitleFromUrl(url) {
-    try {
-        const { pathname } = new URL(url);
-        const filename = pathname.split('/').pop() ?? 'document';
-        return filename.replace(/\.pdf$/i, '').replace(/[-_]/g, ' ').trim();
-    }
-    catch {
-        return 'PDF Document';
-    }
+  try {
+    const { pathname } = new URL(url);
+    const filename = pathname.split("/").pop() ?? "document";
+    return filename.replace(/\.pdf$/i, "").replace(/[-_]/g, " ").trim();
+  } catch {
+    return "PDF Document";
+  }
 }
 function pdfTextToMarkdown(text, title) {
-    if (!text.trim())
-        return `# ${title}\n\n*No extractable text content.*`;
-    // Clean up common PDF extraction artifacts
-    const cleaned = text
-        .replace(/\f/g, '\n\n---\n\n') // form feed = page break
-        .replace(/\r\n/g, '\n')
-        .replace(/\r/g, '\n')
-        .replace(/\n{3,}/g, '\n\n')
-        .replace(/[ \t]{2,}/g, ' ')
-        .trim();
-    return `# ${title}\n\n${cleaned}`;
+  if (!text.trim()) return `# ${title}
+
+*No extractable text content.*`;
+  const cleaned = text.replace(/\f/g, "\n\n---\n\n").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n{3,}/g, "\n\n").replace(/[ \t]{2,}/g, " ").trim();
+  return `# ${title}
+
+${cleaned}`;
 }
-/**
- * Filter a list of discovered URLs to find PDF links.
- * Used by http-engine and browser crawler to decide which links to pass to extractPdfFromUrl.
- */
-export function filterPdfUrls(urls) {
-    return urls.filter(u => PDF_EXT.test(u));
+function filterPdfUrls(urls) {
+  return urls.filter((u) => PDF_EXT.test(u));
 }
+export {
+  extractPdfFromUrl,
+  filterPdfUrls,
+  isPdfUrl
+};
+//# sourceMappingURL=pdf-extractor.js.map

package/dist/performance-metrics.js

@@ -1,105 +1,83 @@
-/**
- * Performance metrics collection via CDP + Playwright page.evaluate().
- *
- * Collects Core Web Vitals and resource timing after page navigation.
- * Stored alongside screen data for test generation context and regression detection.
- *
- * Metrics:
- * - LCP (Largest Contentful Paint) — via PerformanceObserver in page
- * - CLS (Cumulative Layout Shift) — via PerformanceObserver in page
- * - TTFB (Time to First Byte) — from navigation timing
- * - DOMContentLoaded — from navigation timing
- * - Resource count and size by type
- */
-export async function collectPerfMetrics(page, url) {
-    const measuredAt = new Date().toISOString();
-    // Inject PerformanceObserver for LCP + CLS, wait up to 3s
-    let vitals = {};
-    try {
-        vitals = await page.evaluate(() => {
-            return new Promise((resolve) => {
-                const result = {};
-                // Navigation timing
-                const nav = performance.getEntriesByType('navigation')[0];
-                if (nav) {
-                    result.ttfb = Math.round(nav.responseStart - nav.requestStart);
-                    result.domContentLoaded = Math.round(nav.domContentLoadedEventEnd);
-                    result.loadEventEnd = Math.round(nav.loadEventEnd);
-                }
-                let lcpDone = false;
-                let clsDone = false;
-                const tryResolve = () => { if (lcpDone && clsDone)
-                    resolve(result); };
-                // LCP
-                try {
-                    new PerformanceObserver((list) => {
-                        const entries = list.getEntries();
-                        if (entries.length > 0)
-                            result.lcp = Math.round(entries[entries.length - 1].startTime);
-                        lcpDone = true;
-                        tryResolve();
-                    }).observe({ type: 'largest-contentful-paint', buffered: true });
-                }
-                catch {
-                    lcpDone = true;
-                }
-                // CLS
-                try {
-                    let cls = 0;
-                    new PerformanceObserver((list) => {
-                        for (const e of list.getEntries()) {
-                            if (!e.hadRecentInput)
-                                cls += e.value;
-                        }
-                        result.cls = Math.round(cls * 1000) / 1000;
-                        clsDone = true;
-                        tryResolve();
-                    }).observe({ type: 'layout-shift', buffered: true });
-                }
-                catch {
-                    clsDone = true;
-                }
-                // FCP
-                try {
-                    const fcp = performance.getEntriesByName('first-contentful-paint')[0];
-                    if (fcp)
-                        result.fcp = Math.round(fcp.startTime);
-                }
-                catch { }
-                // Fallback resolve after 3s
-                setTimeout(() => resolve(result), 3_000);
-            });
-        }).catch(() => ({}));
-    }
-    catch { /* page closed or navigate already */ }
-    // Resource timing
-    let resources = {
-        scripts: { count: 0, totalBytes: 0 },
-        styles: { count: 0, totalBytes: 0 },
-        images: { count: 0, totalBytes: 0 },
-        fonts: { count: 0, totalBytes: 0 },
-        other: { count: 0, totalBytes: 0 },
-    };
-    let totalTransferBytes = 0;
-    let requestCount = 0;
-    try {
-        const entries = await page.evaluate(() => performance.getEntriesByType('resource').map((e) => ({
-            name: e.name,
-            initiatorType: e.initiatorType,
-            transferSize: e.transferSize ?? 0,
-        }))).catch(() => []);
-        for (const e of entries) {
-            requestCount++;
-            totalTransferBytes += e.transferSize;
-            const cat = e.initiatorType === 'script' ? 'scripts'
-                : e.initiatorType === 'css' || e.name?.endsWith('.css') ? 'styles'
-                    : e.initiatorType === 'img' ? 'images'
-                        : e.name?.match(/\.(woff|woff2|ttf|otf|eot)/) ? 'fonts'
-                            : 'other';
-            resources[cat].count++;
-            resources[cat].totalBytes += e.transferSize;
+async function collectPerfMetrics(page, url) {
+  const measuredAt = (/* @__PURE__ */ new Date()).toISOString();
+  let vitals = {};
+  try {
+    vitals = await page.evaluate(() => {
+      return new Promise((resolve) => {
+        const result = {};
+        const nav = performance.getEntriesByType("navigation")[0];
+        if (nav) {
+          result.ttfb = Math.round(nav.responseStart - nav.requestStart);
+          result.domContentLoaded = Math.round(nav.domContentLoadedEventEnd);
+          result.loadEventEnd = Math.round(nav.loadEventEnd);
+        }
+        let lcpDone = false;
+        let clsDone = false;
+        const tryResolve = () => {
+          if (lcpDone && clsDone) resolve(result);
+        };
+        try {
+          new PerformanceObserver((list) => {
+            const entries = list.getEntries();
+            if (entries.length > 0) result.lcp = Math.round(entries[entries.length - 1].startTime);
+            lcpDone = true;
+            tryResolve();
+          }).observe({ type: "largest-contentful-paint", buffered: true });
+        } catch {
+          lcpDone = true;
+        }
+        try {
+          let cls = 0;
+          new PerformanceObserver((list) => {
+            for (const e of list.getEntries()) {
+              if (!e.hadRecentInput) cls += e.value;
+            }
+            result.cls = Math.round(cls * 1e3) / 1e3;
+            clsDone = true;
+            tryResolve();
+          }).observe({ type: "layout-shift", buffered: true });
+        } catch {
+          clsDone = true;
+        }
+        try {
+          const fcp = performance.getEntriesByName("first-contentful-paint")[0];
+          if (fcp) result.fcp = Math.round(fcp.startTime);
+        } catch {
         }
+        setTimeout(() => resolve(result), 3e3);
+      });
+    }).catch(() => ({}));
+  } catch {
+  }
+  let resources = {
+    scripts: { count: 0, totalBytes: 0 },
+    styles: { count: 0, totalBytes: 0 },
+    images: { count: 0, totalBytes: 0 },
+    fonts: { count: 0, totalBytes: 0 },
+    other: { count: 0, totalBytes: 0 }
+  };
+  let totalTransferBytes = 0;
+  let requestCount = 0;
+  try {
+    const entries = await page.evaluate(
+      () => performance.getEntriesByType("resource").map((e) => ({
+        name: e.name,
+        initiatorType: e.initiatorType,
+        transferSize: e.transferSize ?? 0
+      }))
+    ).catch(() => []);
+    for (const e of entries) {
+      requestCount++;
+      totalTransferBytes += e.transferSize;
+      const cat = e.initiatorType === "script" ? "scripts" : e.initiatorType === "css" || e.name?.endsWith(".css") ? "styles" : e.initiatorType === "img" ? "images" : e.name?.match(/\.(woff|woff2|ttf|otf|eot)/) ? "fonts" : "other";
+      resources[cat].count++;
+      resources[cat].totalBytes += e.transferSize;
     }
-    catch { }
-    return { url, vitals, resources, totalTransferBytes, requestCount, measuredAt };
+  } catch {
+  }
+  return { url, vitals, resources, totalTransferBytes, requestCount, measuredAt };
 }
+export {
+  collectPerfMetrics
+};
+//# sourceMappingURL=performance-metrics.js.map

package/dist/phash.js

@@ -1,155 +1,136 @@
-import sharp from 'sharp';
-/**
- * Composites neutral grey (128,128,128) over each ignoredRegion (fractional
- * 0-1 coordinates) so masked content — timestamps, live counters, ads —
- * contributes nothing to any downstream pixel comparison. Shared by every
- * comparison path (whole-image hash, per-cell grid hash, AI vision) so a
- * region masked once is actually ignored everywhere, not just in the
- * cheapest check.
- */
-export async function applyMask(imagePath, ignoredRegions) {
-    const meta = await sharp(imagePath).metadata();
-    const W = meta.width ?? 1200;
-    const H = meta.height ?? 800;
-    const overlays = await Promise.all(ignoredRegions.map(async (r) => {
-        const rW = Math.max(1, Math.round(r.width * W));
-        const rH = Math.max(1, Math.round(r.height * H));
-        const buf = await sharp({
-            create: { width: rW, height: rH, channels: 3, background: { r: 128, g: 128, b: 128 } },
-        }).png().toBuffer();
-        return { input: buf, top: Math.round(r.y * H), left: Math.round(r.x * W) };
-    }));
-    return sharp(imagePath).composite(overlays).png().toBuffer();
+import sharp from "sharp";
+async function applyMask(imagePath, ignoredRegions) {
+  const meta = await sharp(imagePath).metadata();
+  const W = meta.width ?? 1200;
+  const H = meta.height ?? 800;
+  const overlays = await Promise.all(
+    ignoredRegions.map(async (r) => {
+      const rW = Math.max(1, Math.round(r.width * W));
+      const rH = Math.max(1, Math.round(r.height * H));
+      const buf = await sharp({
+        create: { width: rW, height: rH, channels: 3, background: { r: 128, g: 128, b: 128 } }
+      }).png().toBuffer();
+      return { input: buf, top: Math.round(r.y * H), left: Math.round(r.x * W) };
+    })
+  );
+  return sharp(imagePath).composite(overlays).png().toBuffer();
 }
-/**
- * Compute an 8x8 average hash (aHash) of an image file, with optional mask overlays.
- * ignoredRegions are fractional (0-1 range), converted to pixels here.
- * Masked regions are filled with neutral grey (128,128,128) before hashing.
- */
 async function hashWithMasks(imagePath, ignoredRegions = []) {
-    const pipeline = ignoredRegions.length > 0
-        ? sharp(await applyMask(imagePath, ignoredRegions))
-        : sharp(imagePath);
-    const buf = await pipeline.resize(8, 8, { fit: 'fill' }).greyscale().raw().toBuffer();
-    const pixels = Array.from(buf);
-    const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
-    return pixels.reduce((h, p, i) => (p >= mean ? h | (1n << BigInt(63 - i)) : h), 0n);
+  const pipeline = ignoredRegions.length > 0 ? sharp(await applyMask(imagePath, ignoredRegions)) : sharp(imagePath);
+  const buf = await pipeline.resize(8, 8, { fit: "fill" }).greyscale().raw().toBuffer();
+  const pixels = Array.from(buf);
+  const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
+  return pixels.reduce((h, p, i) => p >= mean ? h | 1n << BigInt(63 - i) : h, 0n);
 }
 function hammingDistance(a, b) {
-    let xor = a ^ b;
-    let count = 0;
-    while (xor !== 0n) {
-        count += Number(xor & 1n);
-        xor >>= 1n;
-    }
-    return count;
+  let xor = a ^ b;
+  let count = 0;
+  while (xor !== 0n) {
+    count += Number(xor & 1n);
+    xor >>= 1n;
+  }
+  return count;
 }
-/**
- * Generates a pixelmatch diff image highlighting changed pixels in red.
- * Applies the same ignoredRegions mask as screenshotDiffPercent so masked
- * zones don't show as "changed" in the visual output.
- * Returns a PNG Buffer suitable for upload to S3.
- */
-export async function generatePixelmatchDiff(pathA, pathB, ignoredRegions = []) {
-    const metaA = await sharp(pathA).metadata();
-    const W = metaA.width ?? 1200;
-    const H = metaA.height ?? 800;
-    const toRawRGBA = async (path) => {
-        const base = ignoredRegions.length > 0 ? sharp(await applyMask(path, ignoredRegions)) : sharp(path);
-        const { data } = await base.resize(W, H, { fit: 'fill' }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-        return data;
-    };
-    const [rawA, rawB] = await Promise.all([toRawRGBA(pathA), toRawRGBA(pathB)]);
-    const { default: pixelmatch } = await import('pixelmatch');
-    const diffData = Buffer.alloc(W * H * 4);
-    pixelmatch(rawA, rawB, diffData, W, H, {
-        threshold: 0.1,
-        alpha: 0.3,
-        diffColor: [255, 0, 0],
-        aaColor: [255, 255, 0],
-    });
-    return sharp(diffData, { raw: { width: W, height: H, channels: 4 } }).png().toBuffer();
+async function generatePixelmatchDiff(pathA, pathB, ignoredRegions = []) {
+  const metaA = await sharp(pathA).metadata();
+  const W = metaA.width ?? 1200;
+  const H = metaA.height ?? 800;
+  const toRawRGBA = async (path) => {
+    const base = ignoredRegions.length > 0 ? sharp(await applyMask(path, ignoredRegions)) : sharp(path);
+    const { data } = await base.resize(W, H, { fit: "fill" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+    return data;
+  };
+  const [rawA, rawB] = await Promise.all([toRawRGBA(pathA), toRawRGBA(pathB)]);
+  const { default: pixelmatch } = await import("pixelmatch");
+  const diffData = Buffer.alloc(W * H * 4);
+  pixelmatch(rawA, rawB, diffData, W, H, {
+    threshold: 0.1,
+    alpha: 0.3,
+    diffColor: [255, 0, 0],
+    aaColor: [255, 255, 0]
+  });
+  return sharp(diffData, { raw: { width: W, height: H, channels: 4 } }).png().toBuffer();
 }
-export async function screenshotDiffPercent(pathA, pathB, ignoredRegions = []) {
-    const [hashA, hashB] = await Promise.all([
-        hashWithMasks(pathA, ignoredRegions),
-        hashWithMasks(pathB, ignoredRegions),
-    ]);
-    let xor = hashA ^ hashB;
-    let dist = 0;
-    while (xor !== 0n) {
-        dist += Number(xor & 1n);
-        xor >>= 1n;
-    }
-    const pct = parseFloat(((dist / 64) * 100).toFixed(1));
-    const changeLevel = pct === 0 ? 'IDENTICAL' : pct < 10 ? 'MINOR' : pct < 30 ? 'MODERATE' : 'SIGNIFICANT';
-    return { pHashDistance: pct, changeLevel };
+async function screenshotDiffPercent(pathA, pathB, ignoredRegions = []) {
+  const [hashA, hashB] = await Promise.all([
+    hashWithMasks(pathA, ignoredRegions),
+    hashWithMasks(pathB, ignoredRegions)
+  ]);
+  let xor = hashA ^ hashB;
+  let dist = 0;
+  while (xor !== 0n) {
+    dist += Number(xor & 1n);
+    xor >>= 1n;
+  }
+  const pct = parseFloat((dist / 64 * 100).toFixed(1));
+  const changeLevel = pct === 0 ? "IDENTICAL" : pct < 10 ? "MINOR" : pct < 30 ? "MODERATE" : "SIGNIFICANT";
+  return { pHashDistance: pct, changeLevel };
 }
-/**
- * Grid-based layout analysis: divides screenshots into a 3×3 grid and computes
- * pHash per cell. Returns which regions changed and where, for the VisualDiff.changes field.
- * Uses sharp's `extract` to crop each cell before hashing.
- */
-export async function gridLayoutDiff(pathA, pathB, ignoredRegions = []) {
-    const GRID_LABELS = [
-        'top-left', 'top-center', 'top-right',
-        'mid-left', 'mid-center', 'mid-right',
-        'bottom-left', 'bottom-center', 'bottom-right',
-    ];
-    try {
-        // Mask before cropping into cells — a masked region (e.g. a timestamp)
-        // then contributes nothing to any cell's hash, instead of only being
-        // ignored by the separate whole-image hash in screenshotDiffPercent().
-        const [sourceA, sourceB] = ignoredRegions.length > 0
-            ? await Promise.all([applyMask(pathA, ignoredRegions), applyMask(pathB, ignoredRegions)])
-            : [pathA, pathB];
-        const [metaA, metaB] = await Promise.all([
-            sharp(sourceA).metadata(),
-            sharp(sourceB).metadata(),
+async function gridLayoutDiff(pathA, pathB, ignoredRegions = []) {
+  const GRID_LABELS = [
+    "top-left",
+    "top-center",
+    "top-right",
+    "mid-left",
+    "mid-center",
+    "mid-right",
+    "bottom-left",
+    "bottom-center",
+    "bottom-right"
+  ];
+  try {
+    const [sourceA, sourceB] = ignoredRegions.length > 0 ? await Promise.all([applyMask(pathA, ignoredRegions), applyMask(pathB, ignoredRegions)]) : [pathA, pathB];
+    const [metaA, metaB] = await Promise.all([
+      sharp(sourceA).metadata(),
+      sharp(sourceB).metadata()
+    ]);
+    const W = Math.min(metaA.width ?? 1200, metaB.width ?? 1200);
+    const H = Math.min(metaA.height ?? 800, metaB.height ?? 800);
+    const cW = Math.floor(W / 3);
+    const cH = Math.floor(H / 3);
+    const changes = [];
+    for (let row = 0; row < 3; row++) {
+      for (let col = 0; col < 3; col++) {
+        const region = { left: col * cW, top: row * cH, width: cW, height: cH };
+        const label = GRID_LABELS[row * 3 + col];
+        const [hashA, hashB] = await Promise.all([
+          sharp(sourceA).extract(region).resize(8, 8, { fit: "fill" }).greyscale().raw().toBuffer().then((buf) => {
+            const pixels = Array.from(buf);
+            const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
+            return pixels.reduce((h, p, i) => p >= mean ? h | 1n << BigInt(63 - i) : h, 0n);
+          }),
+          sharp(sourceB).extract(region).resize(8, 8, { fit: "fill" }).greyscale().raw().toBuffer().then((buf) => {
+            const pixels = Array.from(buf);
+            const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
+            return pixels.reduce((h, p, i) => p >= mean ? h | 1n << BigInt(63 - i) : h, 0n);
+          })
         ]);
-        const W = Math.min(metaA.width ?? 1200, metaB.width ?? 1200);
-        const H = Math.min(metaA.height ?? 800, metaB.height ?? 800);
-        const cW = Math.floor(W / 3);
-        const cH = Math.floor(H / 3);
-        const changes = [];
-        for (let row = 0; row < 3; row++) {
-            for (let col = 0; col < 3; col++) {
-                const region = { left: col * cW, top: row * cH, width: cW, height: cH };
-                const label = GRID_LABELS[row * 3 + col];
-                const [hashA, hashB] = await Promise.all([
-                    sharp(sourceA).extract(region).resize(8, 8, { fit: 'fill' }).greyscale().raw().toBuffer()
-                        .then((buf) => {
-                        const pixels = Array.from(buf);
-                        const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
-                        return pixels.reduce((h, p, i) => p >= mean ? h | (1n << BigInt(63 - i)) : h, 0n);
-                    }),
-                    sharp(sourceB).extract(region).resize(8, 8, { fit: 'fill' }).greyscale().raw().toBuffer()
-                        .then((buf) => {
-                        const pixels = Array.from(buf);
-                        const mean = pixels.reduce((s, p) => s + p, 0) / pixels.length;
-                        return pixels.reduce((h, p, i) => p >= mean ? h | (1n << BigInt(63 - i)) : h, 0n);
-                    }),
-                ]);
-                let xor = hashA ^ hashB;
-                let dist = 0;
-                while (xor !== 0n) {
-                    dist += Number(xor & 1n);
-                    xor >>= 1n;
-                }
-                const pct = (dist / 64) * 100;
-                if (pct >= 5) {
-                    const severity = pct >= 20 ? 'HIGH' : pct >= 10 ? 'MEDIUM' : 'LOW';
-                    changes.push({
-                        location: label,
-                        severity,
-                        description: `${Math.round(pct)}% visual change in ${label.replace('-', ' ')} region`,
-                    });
-                }
-            }
+        let xor = hashA ^ hashB;
+        let dist = 0;
+        while (xor !== 0n) {
+          dist += Number(xor & 1n);
+          xor >>= 1n;
         }
-        return changes;
-    }
-    catch {
-        return [];
+        const pct = dist / 64 * 100;
+        if (pct >= 5) {
+          const severity = pct >= 20 ? "HIGH" : pct >= 10 ? "MEDIUM" : "LOW";
+          changes.push({
+            location: label,
+            severity,
+            description: `${Math.round(pct)}% visual change in ${label.replace("-", " ")} region`
+          });
+        }
+      }
     }
+    return changes;
+  } catch {
+    return [];
+  }
 }
+export {
+  applyMask,
+  generatePixelmatchDiff,
+  gridLayoutDiff,
+  screenshotDiffPercent
+};
+//# sourceMappingURL=phash.js.map