mcp-scraper 0.64.0 → 0.65.0

package/dist/{extract-bundle-FW23CEMG.js → extract-bundle-UWKJT4MU.js}

@@ -1,7 +1,10 @@
 import {
+  commonsEmbedDim,
+  commonsEmbedModel,
   downloadAsset,
+  embedCommonsTexts,
   publicizeExtractionFailure
-} from "./chunk-5QYSY5KI.js";
+} from "./chunk-AMLFKPLL.js";
 import "./chunk-UN4LZVCB.js";
 import {
   computeIssues,
@@ -16,16 +19,16 @@ import {
   createSiteExtractContentReader,
   createSiteExtractImageArtifact,
   extractJobLimitInfo
-} from "./chunk-BRKCPONM.js";
+} from "./chunk-5PIO7QBG.js";
 import "./chunk-EKJ65E3Z.js";
-import "./chunk-TRSZEK2D.js";
+import "./chunk-2XUXVKT4.js";
 import {
   getDb
 } from "./chunk-4VG3NUUY.js";
 
 // src/api/extract-bundle.ts
 import { createWriteStream, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "fs";
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { basename, join } from "path";
 import { tmpdir } from "os";
 import { createGzip } from "zlib";
@@ -33,6 +36,229 @@ import { once } from "events";
 import { finished } from "stream/promises";
 import { ZipFile } from "yazl";
 import pLimit from "p-limit";
+
+// src/api/site-content-similarity.ts
+import { createHash } from "crypto";
+var MAX_SIMILARITY_PAGES = 500;
+var DEFAULT_SIMILARITY_THRESHOLD = 0.9;
+var DEFAULT_SIMILARITY_MAX_PAIRS = 1e4;
+var MAX_SIMILARITY_PAIRS = 5e4;
+function round(value, places) {
+  const scale = 10 ** places;
+  return Math.round(value * scale) / scale;
+}
+function cosineSimilarity(a, b) {
+  if (a.length === 0 || a.length !== b.length) throw new Error("Similarity vectors must have the same non-zero dimension.");
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let index = 0; index < a.length; index++) {
+    dot += a[index] * b[index];
+    normA += a[index] * a[index];
+    normB += b[index] * b[index];
+  }
+  if (normA === 0 || normB === 0) return 0;
+  return Math.max(-1, Math.min(1, dot / (Math.sqrt(normA) * Math.sqrt(normB))));
+}
+function corpusHash(pages) {
+  const digest = createHash("sha256");
+  for (const page of [...pages].sort((a, b) => a.url.localeCompare(b.url))) {
+    digest.update(page.url);
+    digest.update("\0");
+    digest.update(page.contentHash);
+    digest.update("\0");
+  }
+  return digest.digest("hex");
+}
+function markdownBlockSignature(block) {
+  const normalized = block.replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/https?:\/\/\S+/gi, " ").replace(/&(?:amp|nbsp|quot|#39);/gi, " ").replace(/[#>*_`~|\\-]+/g, " ").replace(/[^\p{L}\p{N}]+/gu, " ").replace(/\s+/g, " ").trim().toLowerCase();
+  return normalized.length >= 12 ? normalized : null;
+}
+function prepareEmbeddingTexts(pages) {
+  const blocksByPage = pages.map((page) => page.bodyMarkdown.split(/\n{2,}/).map((block) => block.trim()).filter(Boolean));
+  const minimumPageCount = pages.length >= 4 ? Math.max(3, Math.ceil(pages.length * 0.5)) : null;
+  const pageFrequency = /* @__PURE__ */ new Map();
+  for (const blocks of blocksByPage) {
+    const pageSignatures = new Set(blocks.map(markdownBlockSignature).filter((value) => Boolean(value)));
+    for (const signature of pageSignatures) pageFrequency.set(signature, (pageFrequency.get(signature) ?? 0) + 1);
+  }
+  const repeated = /* @__PURE__ */ new Set();
+  if (minimumPageCount != null) {
+    for (const [signature, count] of pageFrequency) {
+      if (count >= minimumPageCount) repeated.add(signature);
+    }
+  }
+  let removedCharacters = 0;
+  const texts = pages.map((page, pageIndex) => {
+    const kept = [];
+    for (const block of blocksByPage[pageIndex]) {
+      const signature = markdownBlockSignature(block);
+      if (signature && repeated.has(signature)) {
+        removedCharacters += block.length;
+        continue;
+      }
+      kept.push(block);
+    }
+    const cleaned = kept.join("\n\n").trim();
+    const content = cleaned.length >= 60 ? cleaned : page.bodyMarkdown;
+    return `${page.title?.trim() || "Untitled page"}
+
+${content}`;
+  });
+  return {
+    texts,
+    minimumPageCount,
+    removedBlockSignatures: repeated.size,
+    removedCharacters
+  };
+}
+var DisjointSet = class {
+  parent;
+  constructor(size) {
+    this.parent = Array.from({ length: size }, (_, index) => index);
+  }
+  find(value) {
+    const parent = this.parent[value];
+    if (parent !== value) this.parent[value] = this.find(parent);
+    return this.parent[value];
+  }
+  union(a, b) {
+    const rootA = this.find(a);
+    const rootB = this.find(b);
+    if (rootA !== rootB) this.parent[rootB] = rootA;
+  }
+};
+async function analyzeSiteContentSimilarity(pages, options = {}) {
+  const eligible = pages.filter((page) => page.bodyMarkdown.trim().length > 0).slice(0, MAX_SIMILARITY_PAGES);
+  const requestedThreshold = Number.isFinite(options.threshold) ? options.threshold : DEFAULT_SIMILARITY_THRESHOLD;
+  const requestedMaxPairs = Number.isFinite(options.maxPairs) ? options.maxPairs : DEFAULT_SIMILARITY_MAX_PAIRS;
+  const threshold = Math.max(0, Math.min(1, requestedThreshold));
+  const maxPairs = Math.max(1, Math.min(MAX_SIMILARITY_PAIRS, Math.floor(requestedMaxPairs)));
+  const model = options.model ?? commonsEmbedModel();
+  const dimensions = options.dimensions ?? commonsEmbedDim();
+  const embedTexts = options.embedTexts ?? embedCommonsTexts;
+  const prepared = prepareEmbeddingTexts(eligible);
+  const uniqueTexts = [];
+  const textIndexByHash = /* @__PURE__ */ new Map();
+  const pageTextIndexes = [];
+  for (const [pageIndex, page] of eligible.entries()) {
+    const key = page.contentHash || createHash("sha256").update(page.bodyMarkdown).digest("hex");
+    let textIndex = textIndexByHash.get(key);
+    if (textIndex == null) {
+      textIndex = uniqueTexts.length;
+      textIndexByHash.set(key, textIndex);
+      uniqueTexts.push(prepared.texts[pageIndex]);
+    }
+    pageTextIndexes.push(textIndex);
+  }
+  const uniqueVectors = [];
+  for (let offset = 0; offset < uniqueTexts.length; offset += 64) {
+    uniqueVectors.push(...await embedTexts(uniqueTexts.slice(offset, offset + 64)));
+  }
+  if (uniqueVectors.length !== uniqueTexts.length) {
+    throw new Error(`Embedding provider returned ${uniqueVectors.length} vectors for ${uniqueTexts.length} unique page bodies.`);
+  }
+  const vectors = pageTextIndexes.map((index) => uniqueVectors[index]);
+  const sets = new DisjointSet(eligible.length);
+  const allScores = [];
+  const qualifying = [];
+  for (let source = 0; source < eligible.length; source++) {
+    for (let target = source + 1; target < eligible.length; target++) {
+      const score = cosineSimilarity(vectors[source], vectors[target]);
+      allScores.push(score);
+      if (score < threshold) continue;
+      qualifying.push({ source, target, score });
+      sets.union(source, target);
+    }
+  }
+  qualifying.sort((a, b) => b.score - a.score || eligible[a.source].url.localeCompare(eligible[b.source].url) || eligible[a.target].url.localeCompare(eligible[b.target].url));
+  const sortedScores = [...allScores].sort((a, b) => a - b);
+  const quantile = (value) => {
+    if (!sortedScores.length) return null;
+    return round(sortedScores[Math.floor((sortedScores.length - 1) * value)], 6);
+  };
+  const membersByRoot = /* @__PURE__ */ new Map();
+  for (let index = 0; index < eligible.length; index++) {
+    const root = sets.find(index);
+    const members = membersByRoot.get(root) ?? [];
+    members.push(index);
+    membersByRoot.set(root, members);
+  }
+  const clusterIdByPage = /* @__PURE__ */ new Map();
+  const clusters = [...membersByRoot.values()].filter((members) => members.length > 1).sort((a, b) => b.length - a.length || eligible[a[0]].url.localeCompare(eligible[b[0]].url)).map((members, index) => {
+    const clusterId = `cluster-${String(index + 1).padStart(3, "0")}`;
+    for (const member of members) clusterIdByPage.set(member, clusterId);
+    return {
+      clusterId,
+      pageCount: members.length,
+      urls: members.map((member) => eligible[member].url).sort()
+    };
+  });
+  const rows = qualifying.slice(0, maxPairs).map((pair, pairIndex) => {
+    const source = eligible[pair.source];
+    const target = eligible[pair.target];
+    const similarity = round(pair.score, 6);
+    return {
+      sourceUrl: source.url,
+      sourceTitle: source.title,
+      targetUrl: target.url,
+      targetTitle: target.title,
+      similarity,
+      similarityPercent: round(similarity * 100, 2),
+      corpusPercentile: sortedScores.length <= 1 ? 100 : round((1 - pairIndex / (sortedScores.length - 1)) * 100, 2),
+      exactContentDuplicate: Boolean(source.contentHash && source.contentHash === target.contentHash),
+      sourceWordCount: source.wordCount,
+      targetWordCount: target.wordCount,
+      clusterId: clusterIdByPage.get(pair.source) ?? null
+    };
+  });
+  const corpusSha256 = corpusHash(eligible);
+  const analysisSha256 = createHash("sha256").update(JSON.stringify({
+    corpusSha256,
+    model,
+    dimensions,
+    threshold,
+    maxPairs,
+    boilerplateRemoval: {
+      method: "corpus_repeated_markdown_blocks",
+      minimumPageCount: prepared.minimumPageCount,
+      removedBlockSignatures: prepared.removedBlockSignatures
+    }
+  })).digest("hex");
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    provider: "jina",
+    model,
+    dimensions,
+    threshold,
+    requestedMaxPairs: maxPairs,
+    comparedPages: eligible.length,
+    possiblePairs: eligible.length * Math.max(0, eligible.length - 1) / 2,
+    qualifyingPairs: qualifying.length,
+    returnedPairs: rows.length,
+    pairsTruncated: qualifying.length > rows.length,
+    corpusSha256,
+    analysisSha256,
+    scoreDistribution: {
+      min: quantile(0),
+      p25: quantile(0.25),
+      median: quantile(0.5),
+      p75: quantile(0.75),
+      p90: quantile(0.9),
+      max: quantile(1)
+    },
+    boilerplateRemoval: {
+      method: "corpus_repeated_markdown_blocks",
+      minimumPageCount: prepared.minimumPageCount,
+      removedBlockSignatures: prepared.removedBlockSignatures,
+      removedCharacters: prepared.removedCharacters
+    },
+    rows,
+    clusters
+  };
+}
+
+// src/api/extract-bundle.ts
 var SITE_EXTRACT_PAGE_CHUNK = 25;
 var MAX_IMAGES_PER_PAGE = 20;
 var MAX_IMAGES_PER_SITE = 500;
@@ -57,6 +283,15 @@ function safeImageFilename(url, index) {
     return `image-${index}`;
   }
 }
+function slugFactory() {
+  const counts = /* @__PURE__ */ new Map();
+  return (url) => {
+    const base = url.replace(/^https?:\/\//, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "page";
+    const n = counts.get(base) ?? 0;
+    counts.set(base, n + 1);
+    return n ? `${base}-${n}` : base;
+  };
+}
 async function* pageChunks(jobId) {
   const db = getDb();
   let lastRowId = 0;
@@ -75,6 +310,25 @@ async function* pageChunks(jobId) {
     yield res.rows.map((r) => JSON.parse(String(r.page)));
   }
 }
+function csvCell(value) {
+  const text = value == null ? "" : String(value);
+  return /[",\r\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function similarityTableRow(row) {
+  return {
+    source_url: row.sourceUrl,
+    source_title: row.sourceTitle,
+    target_url: row.targetUrl,
+    target_title: row.targetTitle,
+    similarity: row.similarity,
+    similarity_percent: row.similarityPercent,
+    corpus_percentile: row.corpusPercentile,
+    exact_content_duplicate: row.exactContentDuplicate,
+    source_word_count: row.sourceWordCount,
+    target_word_count: row.targetWordCount,
+    cluster_id: row.clusterId
+  };
+}
 async function assembleExtractArtifacts(job, extras = {}) {
   const dir = join(tmpdir(), `extract-bundle-${job.id}-${Date.now()}`);
   const downloadImages = job.options.downloadImages === true;
@@ -82,8 +336,14 @@ async function assembleExtractArtifacts(job, extras = {}) {
   const readPageContent = createSiteExtractContentReader(String(job.userId));
   mkdirSync(dir, { recursive: true });
   if (downloadImages) mkdirSync(join(dir, "images"), { recursive: true });
+  const captureRenderedDom = job.options.captureRenderedDom === true;
+  const semanticSimilarity = job.options.semanticSimilarity === true;
+  if (captureRenderedDom) mkdirSync(join(dir, "rendered-dom"), { recursive: true });
   try {
     const metas = [];
+    const similarityPages = [];
+    const renderedDomManifest = [];
+    const domSlug = slugFactory();
     const pageExportEntries = [];
     const waybackTimeline = job.options.waybackTimeline;
     const statusByUrl = /* @__PURE__ */ new Map();
@@ -111,12 +371,32 @@ async function assembleExtractArtifacts(job, extras = {}) {
           schemaTypes: p.schemaTypes.length > 0 ? ["present"] : [],
           outlinks: []
         });
-        const pageId = p.pageId ?? createHash("sha256").update(p.archivedUrl ?? p.url).digest("hex");
+        const pageId = p.pageId ?? createHash2("sha256").update(p.archivedUrl ?? p.url).digest("hex");
         const pageDir = join(dir, "pages", pageId);
         mkdirSync(pageDir, { recursive: true });
         const content = p.contentRef ? await readPageContent(p.contentRef) : null;
         const html = content?.html ?? null;
         const markdown = content?.markdown ?? p.bodyMarkdown ?? null;
+        if (semanticSimilarity && p.extractionStatus === "successful" && markdown?.trim()) {
+          similarityPages.push({
+            url: p.url,
+            title: p.title,
+            bodyMarkdown: markdown,
+            contentHash: p.contentHash,
+            wordCount: p.wordCount
+          });
+        }
+        if (captureRenderedDom && html != null) {
+          const relativePath = `rendered-dom/${domSlug(p.url)}.html.txt`;
+          writeFileSync(join(dir, relativePath), html);
+          renderedDomManifest.push({
+            url: p.url,
+            path: relativePath,
+            bytes: Buffer.byteLength(html),
+            truncated: p.renderedDomTruncated === true,
+            sanitized: p.renderedDomSanitized === true
+          });
+        }
         const htmlPath = html == null ? null : `pages/${pageId}/page.html`;
         const markdownPath = markdown == null ? null : `pages/${pageId}/page.md`;
         const legacyMarkdownPath = markdown == null || !p.archiveRequestedMonth ? null : `pages/${p.archiveRequestedMonth}/${pageId}.md`;
@@ -136,8 +416,8 @@ async function assembleExtractArtifacts(job, extras = {}) {
             markdownPath,
             htmlBytes: html == null ? 0 : Buffer.byteLength(html),
             markdownBytes: markdown == null ? 0 : Buffer.byteLength(markdown),
-            htmlSha256: html == null ? null : createHash("sha256").update(html).digest("hex"),
-            markdownSha256: markdown == null ? null : createHash("sha256").update(markdown).digest("hex")
+            htmlSha256: html == null ? null : createHash2("sha256").update(html).digest("hex"),
+            markdownSha256: markdown == null ? null : createHash2("sha256").update(markdown).digest("hex")
           }
         };
         const pageJson = JSON.stringify(pageRecord, null, 2);
@@ -150,7 +430,7 @@ async function assembleExtractArtifacts(job, extras = {}) {
           htmlPath,
           markdownPath,
           legacyMarkdownPath,
-          jsonSha256: createHash("sha256").update(pageJson).digest("hex"),
+          jsonSha256: createHash2("sha256").update(pageJson).digest("hex"),
           htmlSha256: pageRecord.content.htmlSha256,
           markdownSha256: pageRecord.content.markdownSha256,
           htmlBytes: pageRecord.content.htmlBytes,
@@ -218,7 +498,7 @@ async function assembleExtractArtifacts(job, extras = {}) {
         }
         if (p.imageLinks?.length) {
           for (const [idx, imgUrl] of p.imageLinks.entries()) {
-            const imageId = createHash("sha256").update(`${p.url}\0${imgUrl}`).digest("hex");
+            const imageId = createHash2("sha256").update(`${p.url}\0${imgUrl}`).digest("hex");
             const record = {
               imageId,
               sourcePage: p.url,
@@ -272,7 +552,7 @@ async function assembleExtractArtifacts(job, extras = {}) {
                 record.artifactId = artifact.key;
                 record.mimeType = result.mimeType;
                 record.bytes = result.sizeBytes;
-                record.sha256 = createHash("sha256").update(bytes).digest("hex");
+                record.sha256 = createHash2("sha256").update(bytes).digest("hex");
               }, (error) => {
                 imagesFailed++;
                 record.status = "failed";
@@ -410,7 +690,7 @@ async function assembleExtractArtifacts(job, extras = {}) {
 
 ${renderImageSection(extras.imageAudit)}`;
     const metricValues = [...metrics.values()];
-    const round = (n) => Math.round(n * 10) / 10;
+    const round2 = (n) => Math.round(n * 10) / 10;
     const distribution = { zero: 0, oneToTwo: 0, threeToTen: 0, elevenPlus: 0 };
     let sumInlinks = 0;
     let sumOutlinks = 0;
@@ -430,8 +710,8 @@ ${renderImageSection(extras.imageAudit)}`;
           pages: metas.length,
           orphans: metricValues.filter((m) => m.orphan).length,
           brokenInternal,
-          avgInlinks: metas.length ? round(sumInlinks / metas.length) : 0,
-          avgOutlinks: metas.length ? round(sumOutlinks / metas.length) : 0,
+          avgInlinks: metas.length ? round2(sumInlinks / metas.length) : 0,
+          avgOutlinks: metas.length ? round2(sumOutlinks / metas.length) : 0,
           distribution,
           topByInlinks: [...metricValues].sort((a, b) => b.inlinks - a.inlinks).slice(0, 20).map((m) => ({ url: m.url, inlinks: m.inlinks, outlinksInternal: m.outlinksInternal, outlinksExternal: m.outlinksExternal }))
         },
@@ -536,6 +816,72 @@ ${renderImageSection(extras.imageAudit)}`;
     pagesOut.end();
     captureMatrixOut?.end();
     await Promise.all([pagesFinished, captureMatrixFinished]);
+    if (captureRenderedDom) {
+      writeFileSync(
+        join(dir, "rendered-dom", "manifest.jsonl"),
+        renderedDomManifest.map((row) => JSON.stringify(row)).join("\n")
+      );
+    }
+    if (semanticSimilarity) {
+      const analysis = await analyzeSiteContentSimilarity(similarityPages, {
+        threshold: Number(job.options.similarityThreshold ?? void 0),
+        maxPairs: Number(job.options.similarityMaxPairs ?? void 0),
+        embedTexts: extras.embedSimilarityTexts
+      });
+      const tableRows = analysis.rows.map(similarityTableRow);
+      const columns = tableRows.length > 0 ? Object.keys(tableRows[0]) : [
+        "source_url",
+        "source_title",
+        "target_url",
+        "target_title",
+        "similarity",
+        "similarity_percent",
+        "corpus_percentile",
+        "exact_content_duplicate",
+        "source_word_count",
+        "target_word_count",
+        "cluster_id"
+      ];
+      const csv = [
+        columns.join(","),
+        ...tableRows.map((row) => columns.map((column) => csvCell(row[column] ?? null)).join(","))
+      ].join("\n") + "\n";
+      const { rows: _rows, clusters: _clusters, ...summary } = analysis;
+      writeFileSync(join(dir, "similarity-table.csv"), csv);
+      writeFileSync(join(dir, "similarity.jsonl"), tableRows.map((row) => JSON.stringify(row)).join("\n"));
+      writeFileSync(join(dir, "similarity-table-schema.json"), JSON.stringify({
+        tableNameSuggestion: `site_similarity_${new URL(job.startUrl).hostname.replace(/[^a-z0-9]+/gi, "_").replace(/^_+|_+$/g, "").toLowerCase()}`,
+        defaultSort: [{ column: "similarity", direction: "desc" }],
+        columns: {
+          source_url: "text",
+          source_title: "text",
+          target_url: "text",
+          target_title: "text",
+          similarity: "number",
+          similarity_percent: "number",
+          corpus_percentile: "number",
+          exact_content_duplicate: "boolean",
+          source_word_count: "integer",
+          target_word_count: "integer",
+          cluster_id: "text"
+        }
+      }, null, 2));
+      writeFileSync(join(dir, "similarity-summary.json"), JSON.stringify(summary, null, 2));
+      writeFileSync(join(dir, "content-clusters.json"), JSON.stringify(analysis.clusters, null, 2));
+      reportMd += [
+        "",
+        "## Rendered content similarity",
+        `- Compared pages: ${analysis.comparedPages}`,
+        `- Raw cosine threshold: ${analysis.threshold}`,
+        `- Corpus score distribution: min ${analysis.scoreDistribution.min ?? "n/a"} / median ${analysis.scoreDistribution.median ?? "n/a"} / p90 ${analysis.scoreDistribution.p90 ?? "n/a"} / max ${analysis.scoreDistribution.max ?? "n/a"}`,
+        `- Qualifying pairs: ${analysis.qualifyingPairs}`,
+        `- Returned table rows: ${analysis.returnedPairs}${analysis.pairsTruncated ? " (capped)" : ""}`,
+        `- Multi-page clusters: ${analysis.clusters.length}`,
+        `- Embedding model: ${analysis.model} (${analysis.dimensions} dimensions)`,
+        `- Corpus boilerplate removed: ${analysis.boilerplateRemoval.removedBlockSignatures} repeated block signatures / ${analysis.boilerplateRemoval.removedCharacters} characters`,
+        `- Corpus SHA-256: ${analysis.corpusSha256}`
+      ].join("\n");
+    }
     writeFileSync(join(dir, "report.md"), reportMd);
     writeFileSync(join(dir, "crawl-summary.json"), JSON.stringify(crawlSummary, null, 2));
     writeFileSync(join(dir, "images-manifest.jsonl"), imageManifest.map((record) => JSON.stringify(record)).join("\n"));
@@ -601,6 +947,17 @@ ${renderImageSection(extras.imageAudit)}`;
       { name: "links-summary.json", type: "application/json" },
       { name: "external-domains.json", type: "application/json" }
     ];
+    if (captureRenderedDom) {
+      artifactFiles.push({ name: "rendered-dom/manifest.jsonl", type: "application/x-ndjson" });
+      for (const row of renderedDomManifest) artifactFiles.push({ name: row.path, type: "text/plain" });
+    }
+    if (semanticSimilarity) {
+      artifactFiles.push({ name: "similarity-table.csv", type: "text/csv" });
+      artifactFiles.push({ name: "similarity.jsonl", type: "application/x-ndjson" });
+      artifactFiles.push({ name: "similarity-table-schema.json", type: "application/json" });
+      artifactFiles.push({ name: "similarity-summary.json", type: "application/json" });
+      artifactFiles.push({ name: "content-clusters.json", type: "application/json" });
+    }
     if (waybackTimeline) {
       artifactFiles.push({ name: "wayback-manifest.json", type: "application/json" });
       artifactFiles.push({ name: "capture-matrix.jsonl", type: "application/x-ndjson" });
@@ -645,4 +1002,4 @@ export {
   SITE_EXTRACT_PAGE_CHUNK,
   assembleExtractArtifacts
 };
-//# sourceMappingURL=extract-bundle-FW23CEMG.js.map
+//# sourceMappingURL=extract-bundle-UWKJT4MU.js.map