docxodus 9.9.0 → 11.0.0

package/dist/index.js

@@ -20,8 +20,8 @@ export function openDocxSession(bytes, settings) {
 export function createBlankDocx() {
     return ensureInitialized().DocxSessionBridge.CreateBlankDocx();
 }
-import { CommentRenderMode, PaginationMode, AnnotationLabelMode, RevisionType, ComparisonEngine, DocxDiffRevisionGranularity, DocxDiffFormatComparison, ConflictResolution, ProjectionScopes, AnchorRenderMode, TableRenderMode, TrackedChangeMode, EmptyParagraphMode, AnchorIdRendering, ProjectionDepth, DocumentElementType, ComparisonLogLevel, ComparisonLogCodes, isInsertion, isDeletion, isMove, isMoveSource, isMoveDestination, findMovePair, isFormatChange, findElementById, findElementsByType, getParagraphs, getTables, getTableColumns, targetElement, targetParagraph, targetParagraphRange, targetRun, targetTable, targetTableRow, targetTableCell, targetTableColumn, targetSearch, targetSearchInElement, } from "./types.js";
-export { PaginationEngine, paginateHtml } from "./pagination.js";
+import { CommentRenderMode, PaginationMode, AnnotationLabelMode, RevisionType, DocxDiffRevisionGranularity, DocxDiffFormatComparison, ConflictResolution, ProjectionScopes, AnchorRenderMode, TableRenderMode, TrackedChangeMode, EmptyParagraphMode, AnchorIdRendering, ProjectionDepth, DocumentElementType, ComparisonLogLevel, ComparisonLogCodes, isInsertion, isDeletion, isMove, isFormatChange, findElementById, findElementsByType, getParagraphs, getTables, getTableColumns, targetElement, targetParagraph, targetParagraphRange, targetRun, targetTable, targetTableRow, targetTableCell, targetTableColumn, targetSearch, targetSearchInElement, } from "./types.js";
+export { PaginationEngine, clearPageCitationHighlight, createUnavailablePageMap, navigateToPageCitation, paginateHtml, } from "./pagination.js";
 // Page geometry is the document's own page setup (w:sectPr), read off the section wrappers
 // the converter stamps in every render mode, plus the fit-to-width zoom a view applies to it.
 export { DEFAULT_MARGIN, DEFAULT_PAGE_HEIGHT, DEFAULT_PAGE_WIDTH, fitScale, parseSectionDimensions, ptToPx, pxToPt, } from "./page-geometry.js";
@@ -31,7 +31,7 @@ export { DocxEditor } from "./editor.js";
 // loading overlay wired onto DocxEditor's command surface. `createRibbonEditor`
 // (docxodus/embed) is the one-call version that also boots WASM.
 export { mountRibbon } from "./ribbon.js";
-export { CommentRenderMode, PaginationMode, AnnotationLabelMode, RevisionType, ComparisonEngine, DocxDiffRevisionGranularity, DocxDiffFormatComparison, ConflictResolution, ProjectionScopes, AnchorRenderMode, TableRenderMode, TrackedChangeMode, EmptyParagraphMode, AnchorIdRendering, ProjectionDepth, DocumentElementType, ComparisonLogLevel, ComparisonLogCodes, isInsertion, isDeletion, isMove, isMoveSource, isMoveDestination, findMovePair, isFormatChange, 
+export { CommentRenderMode, PaginationMode, AnnotationLabelMode, RevisionType, DocxDiffRevisionGranularity, DocxDiffFormatComparison, ConflictResolution, ProjectionScopes, AnchorRenderMode, TableRenderMode, TrackedChangeMode, EmptyParagraphMode, AnchorIdRendering, ProjectionDepth, DocumentElementType, ComparisonLogLevel, ComparisonLogCodes, isInsertion, isDeletion, isMove, isFormatChange, 
 // Document structure helpers
 findElementById, findElementsByType, getParagraphs, getTables, getTableColumns, 
 // Annotation target factory functions
@@ -71,7 +71,7 @@ async function yieldToMain() {
 function getDefaultWasmBasePath() {
     try {
         // import.meta.url gives us the URL of this module
-        // e.g., "https://cdn.jsdelivr.net/npm/docxodus@3.1.1/dist/index.js"
+        // e.g., "https://cdn.jsdelivr.net/npm/docxodus@10.0.0/dist/index.js"
         // or "file:///path/to/node_modules/docxodus/dist/index.js"
         const moduleUrl = import.meta.url;
         // Remove the filename to get the directory
@@ -206,6 +206,71 @@ async function toBytes(input) {
     const buffer = await input.arrayBuffer();
     return new Uint8Array(buffer);
 }
+/**
+ * Generate a deterministic, non-mutating verification manifest from DOCX bytes.
+ * Invalid, malformed, and encrypted packages are represented by structured findings.
+ */
+export async function generatePackageManifest(document) {
+    const exports = ensureInitialized();
+    const bytes = await toBytes(document);
+    await yieldToMain();
+    return JSON.parse(exports.DocumentConverter.GeneratePackageManifest(bytes));
+}
+/**
+ * Run the default bounded deliverable-verification policy on exact DOCX bytes.
+ * Invalid, malformed, encrypted, and safety-limited packages are returned as
+ * structured report findings rather than editable-session errors. When supplied,
+ * the exact baseline bytes are used to classify pre-existing, new, and resolved findings.
+ */
+export async function verifyDeliverable(document, baseline) {
+    const exports = ensureInitialized();
+    const bytes = await toBytes(document);
+    const baselineBytes = baseline === undefined ? undefined : await toBytes(baseline);
+    await yieldToMain();
+    return JSON.parse(baselineBytes === undefined
+        ? exports.DocumentConverter.VerifyDeliverable(bytes)
+        : exports.DocumentConverter.VerifyDeliverableWithBaseline(baselineBytes, bytes));
+}
+/**
+ * Verify a portable JSON delivery change receipt against supplied artifact bytes.
+ *
+ * The receipt travels as its JSON envelope string; `artifacts` maps each artifact id
+ * the receipt records to the exact bytes to independently re-hash against it. Omitted
+ * artifacts report `"missing"`. Malformed input yields a structured invalid verdict
+ * whose findings carry the reason — never a thrown error.
+ */
+export async function verifyDeliveryReceipt(receiptJson, artifacts) {
+    const exports = ensureInitialized();
+    const artifactsJson = artifacts === undefined
+        ? ""
+        : JSON.stringify(Object.fromEntries(Object.entries(artifacts).map(([artifactId, bytes]) => [
+            artifactId,
+            bytesToBase64(bytes),
+        ])));
+    await yieldToMain();
+    return JSON.parse(exports.DocumentConverter.VerifyDeliveryReceipt(receiptJson, artifactsJson));
+}
+/**
+ * Prove that a redline's generated revisions accept to the intended final and reject to the
+ * selected baseline without consuming pre-existing review state.
+ *
+ * Three packages are inspected and two rebuilt, so on a UI thread prefer the worker proxy's
+ * `proveRedlineReversibility`. Malformed, encrypted, and safety-limited packages are reported as
+ * structured proof findings rather than thrown errors. The rebuilt packages are not returned:
+ * the proof carries their digests and the divergences between them and each expected document.
+ *
+ * @param baseline - The document the redline was generated against
+ * @param intendedFinal - The document accepting the generated revisions must reproduce
+ * @param redline - The generated redline under proof
+ */
+export async function proveRedlineReversibility(baseline, intendedFinal, redline) {
+    const exports = ensureInitialized();
+    const baselineBytes = await toBytes(baseline);
+    const intendedFinalBytes = await toBytes(intendedFinal);
+    const redlineBytes = await toBytes(redline);
+    await yieldToMain();
+    return JSON.parse(exports.DocumentConverter.ProveRedlineReversibility(baselineBytes, intendedFinalBytes, redlineBytes));
+}
 /**
  * Convert a DOCX document to HTML.
  *
@@ -319,12 +384,11 @@ export async function compareDocuments(original, modified, options) {
     // Yield to browser before heavy WASM work - allows loading states to render
     await yieldToMain();
     let result;
-    const engine = options?.engine ?? ComparisonEngine.DocxDiff;
-    if (options?.detailThreshold !== undefined || options?.caseInsensitive) {
-        result = exports.DocumentComparer.CompareDocumentsWithOptions(originalBytes, modifiedBytes, options?.authorName ?? "Docxodus", options?.detailThreshold ?? 0.15, options?.caseInsensitive ?? false, engine);
+    if (options?.caseInsensitive) {
+        result = exports.DocumentComparer.CompareDocumentsWithOptions(originalBytes, modifiedBytes, options?.authorName ?? "Docxodus", options.caseInsensitive);
     }
     else {
-        result = exports.DocumentComparer.CompareDocuments(originalBytes, modifiedBytes, options?.authorName ?? "Docxodus", engine);
+        result = exports.DocumentComparer.CompareDocuments(originalBytes, modifiedBytes, options?.authorName ?? "Docxodus");
     }
     if (result.length === 0) {
         throw new Error("Comparison failed - empty result");
@@ -347,14 +411,12 @@ export async function compareDocumentsToHtml(original, modified, options) {
     // Yield to browser before heavy WASM work - allows loading states to render
     await yieldToMain();
     const renderTrackedChanges = options?.renderTrackedChanges ?? true;
-    const engine = options?.engine ?? ComparisonEngine.DocxDiff;
     let result;
-    // Use full method when detailThreshold or caseInsensitive are specified
-    if (options?.detailThreshold !== undefined || options?.caseInsensitive !== undefined) {
-        result = exports.DocumentComparer.CompareDocumentsToHtmlFull(originalBytes, modifiedBytes, options?.authorName ?? "Docxodus", options?.detailThreshold ?? 0.15, options?.caseInsensitive ?? false, renderTrackedChanges, engine);
+    if (options?.caseInsensitive !== undefined) {
+        result = exports.DocumentComparer.CompareDocumentsToHtmlFull(originalBytes, modifiedBytes, options?.authorName ?? "Docxodus", options.caseInsensitive, renderTrackedChanges);
     }
     else {
-        result = exports.DocumentComparer.CompareDocumentsToHtmlWithOptions(originalBytes, modifiedBytes, options?.authorName ?? "Docxodus", renderTrackedChanges, engine);
+        result = exports.DocumentComparer.CompareDocumentsToHtmlWithOptions(originalBytes, modifiedBytes, options?.authorName ?? "Docxodus", renderTrackedChanges);
     }
     if (isErrorResponse(result)) {
         const error = parseError(result);
@@ -362,107 +424,6 @@ export async function compareDocumentsToHtml(original, modified, options) {
     }
     return result;
 }
-/**
- * Compare two DOCX documents with logging enabled.
- * Returns both the redlined document and a log of any warnings/errors encountered.
- * This allows the comparison to continue past recoverable issues (like orphaned footnotes)
- * while providing visibility into what was fixed or skipped.
- *
- * @param original - Original DOCX document
- * @param modified - Modified DOCX document
- * @param options - Comparison options
- * @returns Result with document bytes and log entries
- *
- * @example
- * ```typescript
- * const result = await compareDocumentsWithLog(original, modified, {
- *   authorName: "Reviewer",
- *   detailThreshold: 0.15
- * });
- *
- * if (result.success) {
- *   // Use result.document (Uint8Array)
- *   if (result.hasWarnings) {
- *     console.log("Warnings during comparison:");
- *     for (const entry of result.log) {
- *       console.log(`  [${entry.level}] ${entry.code}: ${entry.message}`);
- *     }
- *   }
- * } else {
- *   console.error(`Comparison failed: ${result.error}`);
- * }
- * ```
- */
-export async function compareDocumentsWithLog(original, modified, options) {
-    const exports = ensureInitialized();
-    const originalBytes = await toBytes(original);
-    const modifiedBytes = await toBytes(modified);
-    await yieldToMain();
-    const result = exports.DocumentComparer.CompareDocumentsWithLog(originalBytes, modifiedBytes, options?.authorName ?? "Docxodus", options?.detailThreshold ?? 0.15, options?.caseInsensitive ?? false);
-    const parsed = JSON.parse(result);
-    return {
-        success: parsed.Success ?? parsed.success ?? false,
-        document: parsed.DocumentBase64 || parsed.documentBase64
-            ? Uint8Array.from(atob(parsed.DocumentBase64 || parsed.documentBase64), c => c.charCodeAt(0))
-            : undefined,
-        error: parsed.Error ?? parsed.error,
-        log: convertLogEntries(parsed.Log || parsed.log || []),
-        hasWarnings: parsed.HasWarnings ?? parsed.hasWarnings ?? false,
-        hasErrors: parsed.HasErrors ?? parsed.hasErrors ?? false,
-    };
-}
-/**
- * Compare two DOCX documents to HTML with logging enabled.
- * Returns both the HTML output and a log of any warnings/errors encountered.
- *
- * @param original - Original DOCX document
- * @param modified - Modified DOCX document
- * @param options - Comparison options
- * @returns Result with HTML and log entries
- *
- * @example
- * ```typescript
- * const result = await compareDocumentsToHtmlWithLog(original, modified, {
- *   authorName: "Reviewer",
- *   renderTrackedChanges: true
- * });
- *
- * if (result.success) {
- *   document.getElementById("viewer").innerHTML = result.html;
- *   if (result.hasWarnings) {
- *     console.log(`${result.log.length} warnings during comparison`);
- *   }
- * }
- * ```
- */
-export async function compareDocumentsToHtmlWithLog(original, modified, options) {
-    const exports = ensureInitialized();
-    const originalBytes = await toBytes(original);
-    const modifiedBytes = await toBytes(modified);
-    await yieldToMain();
-    const result = exports.DocumentComparer.CompareDocumentsToHtmlWithLog(originalBytes, modifiedBytes, options?.authorName ?? "Docxodus", options?.detailThreshold ?? 0.15, options?.caseInsensitive ?? false, options?.renderTrackedChanges ?? true);
-    const parsed = JSON.parse(result);
-    return {
-        success: parsed.Success ?? parsed.success ?? false,
-        html: parsed.Html ?? parsed.html,
-        error: parsed.Error ?? parsed.error,
-        log: convertLogEntries(parsed.Log || parsed.log || []),
-        hasWarnings: parsed.HasWarnings ?? parsed.hasWarnings ?? false,
-        hasErrors: parsed.HasErrors ?? parsed.hasErrors ?? false,
-    };
-}
-/**
- * Convert log entries from PascalCase to camelCase.
- */
-function convertLogEntries(entries) {
-    return entries.map((e) => ({
-        level: e.Level ?? e.level ?? "Info",
-        code: e.Code ?? e.code ?? "",
-        message: e.Message ?? e.message ?? "",
-        details: e.Details ?? e.details,
-        location: e.Location ?? e.location,
-    }));
-}
 /**
  * Get revisions from a compared document.
  *
@@ -488,35 +449,18 @@ function convertLogEntries(entries) {
  * const revisions = await getRevisions(comparedDoc, { detectMoves: false });
  * ```
  */
-export async function getRevisions(document, options) {
+export async function getRevisions(document) {
     const exports = ensureInitialized();
     const bytes = await toBytes(document);
     // Yield to browser before WASM work - allows loading states to render
     await yieldToMain();
-    // Apply defaults for move detection options
-    const detectMoves = options?.detectMoves ?? true;
-    const moveSimilarityThreshold = options?.moveSimilarityThreshold ?? 0.8;
-    const moveMinimumWordCount = options?.moveMinimumWordCount ?? 3;
-    const caseInsensitive = options?.caseInsensitive ?? false;
-    const result = exports.DocumentComparer.GetRevisionsJsonWithOptions(bytes, detectMoves, moveSimilarityThreshold, moveMinimumWordCount, caseInsensitive);
+    const result = exports.DocumentComparer.GetRevisionsJson(bytes);
     if (isErrorResponse(result)) {
         const error = parseError(result);
         throw new Error(`Failed to get revisions: ${error.error}`);
     }
-    const parsed = JSON.parse(result);
-    return (parsed.Revisions || parsed.revisions || []).map((r) => ({
-        author: r.Author || r.author,
-        date: r.Date || r.date,
-        revisionType: r.RevisionType || r.revisionType,
-        text: r.Text || r.text,
-        moveGroupId: r.MoveGroupId ?? r.moveGroupId,
-        isMoveSource: r.IsMoveSource ?? r.isMoveSource,
-        formatChange: (r.FormatChange || r.formatChange) ? {
-            oldProperties: r.FormatChange?.OldProperties || r.formatChange?.oldProperties,
-            newProperties: r.FormatChange?.NewProperties || r.formatChange?.newProperties,
-            changedPropertyNames: r.FormatChange?.ChangedPropertyNames || r.formatChange?.changedPropertyNames,
-        } : undefined,
-    }));
+    // The payload is the session's own revision wire shape, so it needs no remapping.
+    return JSON.parse(result);
 }
 // ─── DocxDiff (IR diff engine) ──────────────────────────────────────────────
 //
@@ -569,20 +513,98 @@ export async function docxDiffGetRevisions(left, right, settings) {
         throw new Error(`Failed to get DocxDiff revisions: ${error.error}`);
     }
     const parsed = JSON.parse(result);
-    return (parsed.revisions || parsed.Revisions || []).map((r) => ({
-        revisionType: r.revisionType ?? r.RevisionType,
-        text: r.text ?? r.Text,
-        author: r.author ?? r.Author,
-        date: r.date ?? r.Date,
-        moveGroupId: r.moveGroupId ?? r.MoveGroupId ?? undefined,
-        isMoveSource: r.isMoveSource ?? r.IsMoveSource ?? undefined,
-        formatChange: (r.formatChange || r.FormatChange) ? {
-            oldProperties: r.formatChange?.oldProperties ?? r.FormatChange?.OldProperties,
-            newProperties: r.formatChange?.newProperties ?? r.FormatChange?.NewProperties,
-            changedPropertyNames: r.formatChange?.changedPropertyNames ?? r.FormatChange?.ChangedPropertyNames,
-        } : undefined,
-        leftAnchor: r.leftAnchor ?? r.LeftAnchor ?? undefined,
-        rightAnchor: r.rightAnchor ?? r.RightAnchor ?? undefined,
+    return (parsed.revisions || parsed.Revisions || []).map(mapDocxDiffRevision);
+}
+/**
+ * Compare two DOCX documents ONCE and return every requested data product from
+ * that single memoized pass (issue #594). Where a review pipeline calling
+ * {@link docxDiffCompare}, {@link docxDiffGetRevisions}, and
+ * {@link docxDiffGetEditScript} separately pays for the alignment per call, this
+ * runs it once — each product identical to its standalone counterpart (the edit
+ * script is handed over parsed rather than as the serialized string).
+ *
+ * @param left - The earlier/original document.
+ * @param right - The later/revised document.
+ * @param settings - Optional {@link DocxDiffSettings}; omit for engine defaults.
+ * @param products - Products to compute; omit for all four.
+ * @throws Error if the operation fails.
+ */
+export async function docxDiffCompareProducts(left, right, settings, products) {
+    const exports = ensureInitialized();
+    const leftBytes = await toBytes(left);
+    const rightBytes = await toBytes(right);
+    await yieldToMain();
+    const result = exports.DocxDiffBridge.CompareProductsJson(leftBytes, rightBytes, docxDiffSettingsJson(settings), products ? JSON.stringify(products) : "");
+    if (isErrorResponse(result)) {
+        const error = parseError(result);
+        throw new Error(`Failed to compare products: ${error.error}`);
+    }
+    const parsed = JSON.parse(result);
+    return {
+        redline: typeof parsed.redlineB64 === "string"
+            ? Uint8Array.from(atob(parsed.redlineB64), c => c.charCodeAt(0))
+            : undefined,
+        revisions: Array.isArray(parsed.revisions)
+            ? parsed.revisions.map(mapDocxDiffRevision)
+            : undefined,
+        editScript: parsed.editScript !== undefined
+            ? parsed.editScript
+            : undefined,
+        semanticChanges: parsed.semanticChanges !== undefined
+            ? parsed.semanticChanges
+            : undefined,
+    };
+}
+/**
+ * Compare ONE baseline against MANY candidates, reading the baseline once (issue #617).
+ *
+ * The read is the single largest stage of a comparison, and a fan-out — one negotiated
+ * draft against every counterparty's markup — otherwise re-reads the baseline for each
+ * one. This reads it once and compares every candidate against that snapshot; each
+ * result is identical to what {@link docxDiffCompareProducts} returns for the same pair.
+ *
+ * A candidate that fails carries an `error` instead of products; the rest of the batch
+ * still comes back, because one malformed markup should not cost the other ninety-nine.
+ *
+ * @param baseline - The shared left-hand document.
+ * @param candidates - The documents to compare against it, in order.
+ * @param settings - Optional {@link DocxDiffSettings}; omit for engine defaults.
+ * @param products - Products to compute; omit for all four.
+ * @throws Error if the batch itself fails (a bad baseline, malformed settings).
+ */
+export async function docxDiffCompareBatch(baseline, candidates, settings, products) {
+    const exports = ensureInitialized();
+    const baselineBytes = await toBytes(baseline);
+    const payload = [];
+    for (let i = 0; i < candidates.length; i++) {
+        const bytes = await toBytes(candidates[i].document);
+        payload.push({
+            name: candidates[i].name ?? String(i),
+            docB64: bytesToBase64(bytes),
+        });
+    }
+    await yieldToMain();
+    const result = exports.DocxDiffBridge.CompareBatchJson(baselineBytes, JSON.stringify(payload), docxDiffSettingsJson(settings), products ? JSON.stringify(products) : "");
+    if (isErrorResponse(result)) {
+        const error = parseError(result);
+        throw new Error(`Failed to compare batch: ${error.error}`);
+    }
+    const parsed = JSON.parse(result);
+    return (parsed.results ?? []).map((entry) => ({
+        name: String(entry.name ?? ""),
+        error: typeof entry.error === "string" ? entry.error : undefined,
+        redline: typeof entry.redlineB64 === "string"
+            ? Uint8Array.from(atob(entry.redlineB64), c => c.charCodeAt(0))
+            : undefined,
+        revisions: Array.isArray(entry.revisions)
+            ? entry.revisions.map(mapDocxDiffRevision)
+            : undefined,
+        editScript: entry.editScript !== undefined
+            ? entry.editScript
+            : undefined,
+        semanticChanges: entry.semanticChanges !== undefined
+            ? entry.semanticChanges
+            : undefined,
     }));
 }
 /**
@@ -609,6 +631,23 @@ export async function docxDiffGetEditScript(left, right, settings) {
     }
     return result;
 }
+/**
+ * Compare two DOCX documents and return the stable, versioned semantic-change
+ * schema. This is the audit/verification surface; it classifies document meaning
+ * beyond the renderer's internal edit script and preserves unknown package changes.
+ */
+export async function docxDiffGetSemanticChanges(left, right, settings) {
+    const exports = ensureInitialized();
+    const leftBytes = await toBytes(left);
+    const rightBytes = await toBytes(right);
+    await yieldToMain();
+    const result = exports.DocxDiffBridge.GetSemanticChangesJson(leftBytes, rightBytes, docxDiffSettingsJson(settings));
+    if (isErrorResponse(result)) {
+        const error = parseError(result);
+        throw new Error(`Failed to get semantic changes: ${error.error}`);
+    }
+    return JSON.parse(result);
+}
 /**
  * Accept every tracked revision in a redlined DOCX and return the resulting bytes
  * (materializes the "right"/revised side). The byte-in, byte-out counterpart of
@@ -1055,6 +1094,7 @@ export async function getDocumentStructure(document) {
     // Convert from PascalCase to camelCase
     const convertElement = (el) => ({
         id: el.Id || el.id,
+        anchorId: el.AnchorId || el.anchorId,
         type: el.Type || el.type,
         textPreview: el.TextPreview || el.textPreview,
         index: el.Index ?? el.index,
@@ -1066,8 +1106,12 @@ export async function getDocumentStructure(document) {
     });
     const convertTableColumn = (col) => ({
         tableId: col.TableId || col.tableId,
+        anchorId: col.AnchorId || col.anchorId,
+        tableAnchorId: col.TableAnchorId || col.tableAnchorId,
+        isVirtual: col.IsVirtual ?? col.isVirtual ?? false,
         columnIndex: col.ColumnIndex ?? col.columnIndex,
         cellIds: col.CellIds || col.cellIds || [],
+        cellAnchorIds: col.CellAnchorIds || col.cellAnchorIds || [],
         rowCount: col.RowCount ?? col.rowCount,
     });
     const root = convertElement(parsed.Root || parsed.root);
@@ -1168,6 +1212,7 @@ export async function getDocumentMetadata(document) {
         hasTrackedChanges: parsed.HasTrackedChanges ?? parsed.hasTrackedChanges,
         hasComments: parsed.HasComments ?? parsed.hasComments,
         estimatedPageCount: parsed.EstimatedPageCount ?? parsed.estimatedPageCount,
+        estimatedPageCountSource: parsed.EstimatedPageCountSource ?? parsed.estimatedPageCountSource ?? "heuristic",
     };
 }
 /**