docrev 0.9.7 → 0.9.13

package/lib/types.ts

@@ -69,6 +69,22 @@ export interface PdfConfig {
   geometry?: string;
   linestretch?: number;
   toc?: boolean;
+  /**
+   * LaTeX engine to use for PDF output. One of `pdflatex` (default),
+   * `xelatex`, `lualatex`, `tectonic`, etc. xelatex/lualatex are required
+   * for native UTF-8 rendering of diacritics in author names, place
+   * names, and species epithets.
+   */
+  engine?: string;
+  /** Roman/serif main font (xelatex/lualatex only — uses fontspec). */
+  mainfont?: string;
+  /** Sans-serif font (xelatex/lualatex only). */
+  sansfont?: string;
+  /** Monospace font (xelatex/lualatex only). */
+  monofont?: string;
+  numbersections?: boolean;
+  template?: string;
+  headerIncludes?: string;
 }
 
 export interface DocxConfig {
@@ -338,6 +354,10 @@ export interface JournalFormatting {
     linestretch?: number;
     template?: string;
     numbersections?: boolean;
+    engine?: string;
+    mainfont?: string;
+    sansfont?: string;
+    monofont?: string;
   };
   docx?: {
     reference?: string;

package/lib/word-extraction.ts

@@ -18,6 +18,12 @@ export interface WordComment {
   author: string;
   date: string;
   text: string;
+  /**
+   * Parent comment id when this is a reply in a Word comment thread.
+   * Resolved from `commentsExtended.xml`'s `w15:paraIdParent` field.
+   * `undefined` for top-level comments.
+   */
+  parentId?: string;
 }
 
 export interface TextNode {
@@ -126,7 +132,6 @@ export async function extractWordComments(docxPath: string): Promise<WordComment
 
     const parsed = await parseStringPromise(commentsXml, { explicitArray: false });
 
-    const ns = 'w:';
     const commentsRoot = parsed['w:comments'];
     if (!commentsRoot || !commentsRoot['w:comment']) {
       return comments;
@@ -137,12 +142,18 @@ export async function extractWordComments(docxPath: string): Promise<WordComment
       ? commentsRoot['w:comment']
       : [commentsRoot['w:comment']];
 
+    // Map every paraId that lives inside a comment back to that comment's id.
+    // Word's commentsExtended.xml expresses threading via w15:paraIdParent,
+    // which references the parent's first <w:p>. Replies use a secondary
+    // (often-empty) <w:p>, so each comment may contribute multiple paraIds.
+    const paraIdToCommentId = new Map<string, string>();
+
     for (const comment of commentNodes) {
       const id = comment.$?.['w:id'] || '';
       const author = comment.$?.['w:author'] || 'Unknown';
       const date = comment.$?.['w:date'] || '';
 
-      // Extract text from nested w:p/w:r/w:t elements
+      // Extract text from nested w:p/w:r/w:t elements and record paraIds.
       let text = '';
       const extractText = (node: any): void => {
         if (!node) return;
@@ -160,13 +171,49 @@ export async function extractWordComments(docxPath: string): Promise<WordComment
         }
         if (node['w:p']) {
           const paras = Array.isArray(node['w:p']) ? node['w:p'] : [node['w:p']];
-          paras.forEach(extractText);
+          for (const para of paras) {
+            const paraId = para?.$?.['w14:paraId'];
+            if (paraId && id) paraIdToCommentId.set(paraId, id);
+            extractText(para);
+          }
         }
       };
       extractText(comment);
 
       comments.push({ id, author, date: date.slice(0, 10), text: text.trim() });
     }
+
+    // Resolve parent links from commentsExtended.xml. Missing entry just
+    // means the docx has no threading metadata (e.g. legacy/non-Word source).
+    const extendedEntry = zip.getEntry('word/commentsExtended.xml');
+    if (extendedEntry && paraIdToCommentId.size > 0) {
+      let extendedXml = '';
+      try {
+        extendedXml = extendedEntry.getData().toString('utf8');
+      } catch {
+        // Unreadable threading metadata is non-fatal; skip parent linking.
+      }
+      if (extendedXml) {
+        const parentByCommentId = new Map<string, string>();
+        const exPattern = /<w15:commentEx\b([^>]*?)\/>/g;
+        let m: RegExpExecArray | null;
+        while ((m = exPattern.exec(extendedXml)) !== null) {
+          const attrs = m[1] ?? '';
+          const paraIdMatch = attrs.match(/w15:paraId="([^"]+)"/);
+          const parentMatch = attrs.match(/w15:paraIdParent="([^"]+)"/);
+          if (!paraIdMatch || !parentMatch) continue;
+          const childCommentId = paraIdToCommentId.get(paraIdMatch[1]);
+          const parentCommentId = paraIdToCommentId.get(parentMatch[1]);
+          if (childCommentId && parentCommentId && childCommentId !== parentCommentId) {
+            parentByCommentId.set(childCommentId, parentCommentId);
+          }
+        }
+        for (const c of comments) {
+          const parent = parentByCommentId.get(c.id);
+          if (parent) c.parentId = parent;
+        }
+      }
+    }
   } catch (err: any) {
     // Re-throw with more context if it's already an Error we created
     if (err.message.includes('Invalid Word document') || err.message.includes('File not found')) {

package/lib/wordcomments.ts

@@ -72,10 +72,38 @@ function generateParaId(commentIdx: number, paraNum: number): string {
  * - comments: array with author, text, isReply, parentIdx
  */
 export function prepareMarkdownWithMarkers(markdown: string): PrepareResult {
-  // Match all comments with optional anchor
-  const commentPattern = /\{>>(.+?)<<\}(?:\s*\[([^\]]+)\]\{\.mark\})?/g;
+  // Match the comment block first; extend manually to capture an optional
+  // trailing `[anchor]{.mark}` span. A regex `[^\]]+` for the anchor would
+  // bail on the inner `]` of nested syntax (e.g. `[[0..9]]{.mark}` or
+  // `[*phrase*]{.mark}` after pandoc-rewriting), so we walk the brackets
+  // ourselves and verify a `{.mark}` suffix.
+  const commentPattern = /\{>>([\s\S]+?)<<\}/g;
+
+  function tryParseTrailingAnchor(
+    text: string,
+    fromIdx: number,
+  ): { anchor: string; endIdx: number } | null {
+    let i = fromIdx;
+    while (i < text.length && /\s/.test(text[i] ?? '')) i++;
+    if (text[i] !== '[') return null;
+    let depth = 1;
+    let j = i + 1;
+    while (j < text.length) {
+      const ch = text[j];
+      if (ch === '[') depth++;
+      else if (ch === ']') {
+        depth--;
+        if (depth === 0) break;
+      }
+      j++;
+    }
+    if (depth !== 0) return null;
+    if (text.slice(j + 1, j + 8) !== '{.mark}') return null;
+    return { anchor: text.slice(i + 1, j), endIdx: j + 8 };
+  }
 
-  const rawMatches: ParsedComment[] = [];
+  const REPLY_PREFIX = '↪ ';
+  const rawMatches: (ParsedComment & { explicitReply: boolean })[] = [];
   let match: RegExpExecArray | null;
   while ((match = commentPattern.exec(markdown)) !== null) {
     const content = match[1] ?? '';
@@ -87,24 +115,52 @@ export function prepareMarkdownWithMarkers(markdown: string): PrepareResult {
       text = content.slice(colonIdx + 1).trim();
     }
 
+    // The `↪ ` prefix is the authoritative reply signal emitted by
+    // `insertCommentsIntoMarkdown`. Strip it from the author before injection
+    // so Word displays the real name.
+    let explicitReply = false;
+    if (author.startsWith(REPLY_PREFIX)) {
+      explicitReply = true;
+      author = author.slice(REPLY_PREFIX.length).trim();
+    }
+
+    const commentEnd = match.index + match[0].length;
+    const trailing = tryParseTrailingAnchor(markdown, commentEnd);
+
     rawMatches.push({
       author,
       text,
-      anchor: match[2] || null,
+      anchor: trailing ? trailing.anchor : null,
       start: match.index,
-      end: match.index + match[0].length,
-      fullMatch: match[0]
+      end: trailing ? trailing.endIdx : commentEnd,
+      fullMatch: markdown.slice(match.index, trailing ? trailing.endIdx : commentEnd),
+      explicitReply,
     });
+
+    // Advance regex lastIndex past the consumed anchor so the next iteration
+    // doesn't re-scan inside it (e.g. `[*emphasis*]{.mark}` would otherwise
+    // tempt the matcher to look for another `{>>...<<}` in the body of the
+    // anchor span).
+    if (trailing) {
+      commentPattern.lastIndex = trailing.endIdx;
+    }
   }
 
   if (rawMatches.length === 0) {
     return { markedMarkdown: markdown, comments: [] };
   }
 
-  // Detect reply relationships based on adjacency
-  // First comment in a cluster = parent, all subsequent = replies to that parent
-  // Comments are "adjacent" if there's minimal text between them (< 10 chars)
+  // Two-mode reply detection driven by the markdown itself:
+  //   - If any comment carries the `↪ ` author prefix, the markdown came
+  //     through `insertCommentsIntoMarkdown` and we use prefix-only mode.
+  //     Distinct clusters that happen to land at gap=0 (a real failure
+  //     mode on dense reviewer docs — 298-comment paper produced 9 such
+  //     collisions) are not misthreaded.
+  //   - If no comment carries the prefix, the markdown was hand-typed.
+  //     Fall back to gap < 10 adjacency for backward compat with users
+  //     who write CriticMarkup directly.
   const ADJACENT_THRESHOLD = 10;
+  const useExplicitMode = rawMatches.some(m => m.explicitReply);
   const comments: PreparedComment[] = [];
   let clusterParentIdx = -1;  // Index of first comment in current cluster
   let lastCommentEnd = -1;
@@ -113,9 +169,10 @@ export function prepareMarkdownWithMarkers(markdown: string): PrepareResult {
     const m = rawMatches[i];
     if (!m) continue;
 
-    // Check if this comment is adjacent to the previous one
     const gap = lastCommentEnd >= 0 ? m.start - lastCommentEnd : Infinity;
-    const isAdjacent = gap < ADJACENT_THRESHOLD;
+    const isAdjacent = useExplicitMode
+      ? m.explicitReply
+      : gap < ADJACENT_THRESHOLD;
 
     // Reset cluster if there's a gap (comments not in same cluster)
     if (!isAdjacent) {
@@ -179,10 +236,11 @@ export function prepareMarkdownWithMarkers(markdown: string): PrepareResult {
 
     if (c.isReply) {
       // Reply: remove from document entirely (will be in comments.xml only)
-      // Also consume leading whitespace to avoid double spaces
+      // Also consume one preceding whitespace char to avoid double spaces.
+      // We deliberately consume at most one — walking arbitrarily backwards
+      // would shift positions that lower-index comments still depend on.
       let removeStart = c.start;
-      const charBefore = markedMarkdown[removeStart - 1];
-      while (removeStart > 0 && charBefore && /\s/.test(charBefore)) {
+      if (removeStart > 0 && /\s/.test(markedMarkdown[removeStart - 1] ?? '')) {
         removeStart--;
       }
 
@@ -205,10 +263,10 @@ export function prepareMarkdownWithMarkers(markdown: string): PrepareResult {
     } else {
       // Parent comment
       if (c.anchorFromReply) {
-        // Anchor markers are placed by the reply, just remove this comment
+        // Anchor markers are placed by the reply, just remove this comment.
+        // Consume one preceding whitespace char only (see reply branch above).
         let removeStart = c.start;
-        const charBefore = markedMarkdown[removeStart - 1];
-        while (removeStart > 0 && charBefore && /\s/.test(charBefore)) {
+        if (removeStart > 0 && /\s/.test(markedMarkdown[removeStart - 1] ?? '')) {
           removeStart--;
         }
         markedMarkdown = markedMarkdown.slice(0, removeStart) + markedMarkdown.slice(c.end);
@@ -421,93 +479,152 @@ export async function injectCommentsAtMarkers(
       const endMarker = `${MARKER_END_PREFIX}${idx}${MARKER_SUFFIX}`;
 
       const startPos = documentXml.indexOf(startMarker);
-      const endPos = documentXml.indexOf(endMarker);
+      const endPos = documentXml.indexOf(endMarker, startPos + startMarker.length);
 
       if (startPos === -1 || endPos === -1) continue;
 
-      // Find the <w:r> containing the markers
-      const rStartBefore = documentXml.lastIndexOf('<w:r>', startPos);
-      const rStartOpen = documentXml.lastIndexOf('<w:r ', startPos);
-      const rStart = Math.max(rStartBefore, rStartOpen);
-      const rEndPos = documentXml.indexOf('</w:r>', endPos);
-
-      if (rStart === -1 || rEndPos === -1) continue;
-
-      const rEnd = rEndPos + '</w:r>'.length;
-      const runContent = documentXml.slice(rStart, rEnd);
-
-      // Extract styling
-      const rPrMatch = runContent.match(/<w:rPr>[\s\S]*?<\/w:rPr>/);
-      const rPr = rPrMatch ? rPrMatch[0] : '';
-
-      // Extract text
-      const textMatch = runContent.match(/<w:t[^>]*>([\s\S]*?)<\/w:t>/);
-      if (!textMatch) continue;
-
-      const fullText = textMatch[1] ?? '';
-      const tElementMatch = textMatch[0].match(/<w:t[^>]*>/);
-      if (!tElementMatch) continue;
-      const tElement = tElementMatch[0];
-
-      const startInText = fullText.indexOf(startMarker);
-      const endInText = fullText.indexOf(endMarker);
-      if (startInText === -1 || endInText === -1) continue;
+      // Find the runs containing each marker. Pandoc may split a single
+      // markdown anchor across multiple <w:r> blocks when it applies styling
+      // mid-anchor (smart-quote substitution, *italic*, `code`, **bold**).
+      // The same-run path (current happy path) collapses into the multi-run
+      // path when start and end runs coincide.
+      const startRunOpen = Math.max(
+        documentXml.lastIndexOf('<w:r>', startPos),
+        documentXml.lastIndexOf('<w:r ', startPos),
+      );
+      const startRunCloseIdx = documentXml.indexOf('</w:r>', startPos);
+      const endRunOpen = Math.max(
+        documentXml.lastIndexOf('<w:r>', endPos),
+        documentXml.lastIndexOf('<w:r ', endPos),
+      );
+      const endRunCloseIdx = documentXml.indexOf('</w:r>', endPos);
+
+      if (
+        startRunOpen === -1 || startRunCloseIdx === -1 ||
+        endRunOpen === -1 || endRunCloseIdx === -1
+      ) continue;
+
+      const startRunClose = startRunCloseIdx + '</w:r>'.length;
+      const endRunClose = endRunCloseIdx + '</w:r>'.length;
+
+      const startRunFull = documentXml.slice(startRunOpen, startRunClose);
+      const endRunFull = documentXml.slice(endRunOpen, endRunClose);
+
+      // Extract <w:rPr> and <w:t> element shape from each run. Both pieces
+      // are needed verbatim so a textBefore split keeps its original styling
+      // and so the post-anchor textAfter render keeps the end run's styling.
+      function dissectRun(runXml: string, marker: string): {
+        rPr: string;
+        tElement: string;
+        textBefore: string;
+        textAfter: string;
+      } | null {
+        const rPrMatch = runXml.match(/<w:rPr>[\s\S]*?<\/w:rPr>/);
+        const tMatch = runXml.match(/<w:t[^>]*>([\s\S]*?)<\/w:t>/);
+        if (!tMatch) return null;
+        const tOpenMatch = tMatch[0].match(/<w:t[^>]*>/);
+        if (!tOpenMatch) return null;
+        const tContent = tMatch[1] ?? '';
+        const markerInT = tContent.indexOf(marker);
+        if (markerInT === -1) return null;
+        return {
+          rPr: rPrMatch ? rPrMatch[0] : '',
+          tElement: tOpenMatch[0],
+          textBefore: tContent.slice(0, markerInT),
+          textAfter: tContent.slice(markerInT + marker.length),
+        };
+      }
 
-      let textBefore = fullText.slice(0, startInText);
-      let anchorText = fullText.slice(startInText + startMarker.length, endInText);
-      let textAfter = fullText.slice(endInText + endMarker.length);
+      let replacement = '';
+      const replies = commentsWithIds.filter(c => c.isReply && c.parentIdx === comment?.commentIdx);
 
-      // When anchor is empty, use the first word from textAfter as fallback
-      if (!anchorText && textAfter) {
-        const wordMatch = textAfter.match(/^\s*(\S+)/);
-        if (wordMatch) {
-          anchorText = wordMatch[1] ?? '';
-          textAfter = textAfter.slice(wordMatch[0].length);
+      const emitRangeStarts = () => {
+        replacement += `<w:commentRangeStart w:id="${comment.id}"/>`;
+        for (const reply of replies) {
+          replacement += `<w:commentRangeStart w:id="${reply.id}"/>`;
         }
-      }
+      };
+
+      const emitRangeEnds = () => {
+        replacement += `<w:commentRangeEnd w:id="${comment.id}"/>`;
+        replacement += `<w:r><w:commentReference w:id="${comment.id}"/></w:r>`;
+        for (const reply of replies) {
+          replacement += `<w:commentRangeEnd w:id="${reply.id}"/>`;
+          replacement += `<w:r><w:commentReference w:id="${reply.id}"/></w:r>`;
+          injectedIds.add(reply.id);
+        }
+      };
+
+      if (startRunOpen === endRunOpen) {
+        // Same-run path: both markers live inside one <w:t>. Original logic.
+        const startInfo = dissectRun(startRunFull, startMarker);
+        if (!startInfo) continue;
+        const fullText = startInfo.textBefore + startMarker + startInfo.textAfter;
+        const endInTextRel = startInfo.textAfter.indexOf(endMarker);
+        if (endInTextRel === -1) continue;
+        const anchorTextSame = startInfo.textAfter.slice(0, endInTextRel);
+        let textAfter = startInfo.textAfter.slice(endInTextRel + endMarker.length);
+        let anchorText = anchorTextSame;
+        let textBefore = startInfo.textBefore;
+
+        // Empty anchor: borrow the next word so the comment has something
+        // to anchor on. Then normalize the trailing double space.
+        if (!anchorText && textAfter) {
+          const wordMatch = textAfter.match(/^\s*(\S+)/);
+          if (wordMatch) {
+            anchorText = wordMatch[1] ?? '';
+            textAfter = textAfter.slice(wordMatch[0].length);
+          }
+        }
+        if (!anchorText && textBefore.endsWith(' ') && textAfter.startsWith(' ')) {
+          textAfter = textAfter.slice(1);
+        }
+        // Suppress unused warning for pre-empty-anchor fullText var
+        void fullText;
 
-      // When anchor is still empty, normalize double spaces to single space
-      if (!anchorText && textBefore.endsWith(' ') && textAfter.startsWith(' ')) {
-        textAfter = textAfter.slice(1); // Remove leading space from textAfter
+        if (textBefore) {
+          replacement += `<w:r>${startInfo.rPr}${startInfo.tElement}${textBefore}</w:t></w:r>`;
+        }
+        emitRangeStarts();
+        if (anchorText) {
+          replacement += `<w:r>${startInfo.rPr}${startInfo.tElement}${anchorText}</w:t></w:r>`;
+        }
+        emitRangeEnds();
+        if (textAfter) {
+          replacement += `<w:r>${startInfo.rPr}${startInfo.tElement}${textAfter}</w:t></w:r>`;
+        }
+        documentXml = documentXml.slice(0, startRunOpen) + replacement + documentXml.slice(startRunClose);
+        injectedIds.add(comment.id);
+        continue;
       }
 
-      // Build replacement
-      let replacement = '';
-
-      if (textBefore) {
-        replacement += `<w:r>${rPr}${tElement}${textBefore}</w:t></w:r>`;
-      }
+      // Multi-run path: markers sit in different <w:r> blocks because pandoc
+      // applied mid-anchor styling. Split the start run at the start marker,
+      // keep all middle runs verbatim (they carry the styled anchor portions),
+      // split the end run at the end marker.
+      const startInfo = dissectRun(startRunFull, startMarker);
+      const endInfo = dissectRun(endRunFull, endMarker);
+      if (!startInfo || !endInfo) continue;
 
-      // Find replies to this comment
-      const replies = commentsWithIds.filter(c => c.isReply && c.parentIdx === comment?.commentIdx);
+      const middle = documentXml.slice(startRunClose, endRunOpen);
 
-      // Start ranges for parent AND all replies (nested)
-      replacement += `<w:commentRangeStart w:id="${comment.id}"/>`;
-      for (const reply of replies) {
-        replacement += `<w:commentRangeStart w:id="${reply.id}"/>`;
+      if (startInfo.textBefore) {
+        replacement += `<w:r>${startInfo.rPr}${startInfo.tElement}${startInfo.textBefore}</w:t></w:r>`;
       }
-
-      // Anchor text
-      if (anchorText) {
-        replacement += `<w:r>${rPr}${tElement}${anchorText}</w:t></w:r>`;
+      emitRangeStarts();
+      if (startInfo.textAfter) {
+        replacement += `<w:r>${startInfo.rPr}${startInfo.tElement}${startInfo.textAfter}</w:t></w:r>`;
       }
-
-      // End parent range and reference (NO rStyle wrapper - required for threading)
-      replacement += `<w:commentRangeEnd w:id="${comment.id}"/>`;
-      replacement += `<w:r><w:commentReference w:id="${comment.id}"/></w:r>`;
-
-      // End reply ranges and references (same position as parent, NO rStyle wrapper)
-      for (const reply of replies) {
-        replacement += `<w:commentRangeEnd w:id="${reply.id}"/>`;
-        replacement += `<w:r><w:commentReference w:id="${reply.id}"/></w:r>`;
-        injectedIds.add(reply.id);
+      replacement += middle;
+      if (endInfo.textBefore) {
+        replacement += `<w:r>${endInfo.rPr}${endInfo.tElement}${endInfo.textBefore}</w:t></w:r>`;
       }
-
-      if (textAfter) {
-        replacement += `<w:r>${rPr}${tElement}${textAfter}</w:t></w:r>`;
+      emitRangeEnds();
+      if (endInfo.textAfter) {
+        replacement += `<w:r>${endInfo.rPr}${endInfo.tElement}${endInfo.textAfter}</w:t></w:r>`;
       }
 
-      documentXml = documentXml.slice(0, rStart) + replacement + documentXml.slice(rEnd);
+      documentXml = documentXml.slice(0, startRunOpen) + replacement + documentXml.slice(endRunClose);
       injectedIds.add(comment.id);
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docrev",
-  "version": "0.9.7",
+  "version": "0.9.13",
   "description": "Academic paper revision workflow: Word ↔ Markdown round-trips, DOI validation, reviewer comments",
   "type": "module",
   "types": "dist/lib/types.d.ts",

package/dist/package.json

@@ -1,137 +0,0 @@
-{
-  "name": "docrev",
-  "version": "0.9.4",
-  "description": "Academic paper revision workflow: Word ↔ Markdown round-trips, DOI validation, reviewer comments",
-  "type": "module",
-  "types": "dist/lib/types.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/lib/annotations.d.ts",
-      "import": "./dist/lib/annotations.js"
-    },
-    "./annotations": {
-      "types": "./dist/lib/annotations.d.ts",
-      "import": "./dist/lib/annotations.js"
-    },
-    "./build": {
-      "types": "./dist/lib/build.d.ts",
-      "import": "./dist/lib/build.js"
-    },
-    "./citations": {
-      "types": "./dist/lib/citations.d.ts",
-      "import": "./dist/lib/citations.js"
-    },
-    "./crossref": {
-      "types": "./dist/lib/crossref.d.ts",
-      "import": "./dist/lib/crossref.js"
-    },
-    "./doi": {
-      "types": "./dist/lib/doi.d.ts",
-      "import": "./dist/lib/doi.js"
-    },
-    "./equations": {
-      "types": "./dist/lib/equations.d.ts",
-      "import": "./dist/lib/equations.js"
-    },
-    "./git": {
-      "types": "./dist/lib/git.d.ts",
-      "import": "./dist/lib/git.js"
-    },
-    "./journals": {
-      "types": "./dist/lib/journals.d.ts",
-      "import": "./dist/lib/journals.js"
-    },
-    "./merge": {
-      "types": "./dist/lib/merge.d.ts",
-      "import": "./dist/lib/merge.js"
-    },
-    "./sections": {
-      "types": "./dist/lib/sections.d.ts",
-      "import": "./dist/lib/sections.js"
-    },
-    "./word": {
-      "types": "./dist/lib/word.d.ts",
-      "import": "./dist/lib/word.js"
-    },
-    "./variables": {
-      "types": "./dist/lib/variables.d.ts",
-      "import": "./dist/lib/variables.js"
-    },
-    "./grammar": {
-      "types": "./dist/lib/grammar.d.ts",
-      "import": "./dist/lib/grammar.js"
-    },
-    "./trackchanges": {
-      "types": "./dist/lib/trackchanges.d.ts",
-      "import": "./dist/lib/trackchanges.js"
-    },
-    "./spelling": {
-      "types": "./dist/lib/spelling.d.ts",
-      "import": "./dist/lib/spelling.js"
-    },
-    "./wordcomments": {
-      "types": "./dist/lib/wordcomments.d.ts",
-      "import": "./dist/lib/wordcomments.js"
-    }
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "bin": {
-    "rev": "bin/rev.js"
-  },
-  "scripts": {
-    "build": "tsc && node scripts/postbuild.js",
-    "build:watch": "tsc --watch",
-    "dev": "tsx bin/rev.ts",
-    "test": "tsx --test test/*.test.js",
-    "test:ts": "tsx --test test/*.test.ts",
-    "test:watch": "node --test --watch test/*.test.js",
-    "test:coverage": "c8 --reporter=text --reporter=lcov node --test test/*.test.js",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/gcol33/docrev.git"
-  },
-  "bugs": {
-    "url": "https://github.com/gcol33/docrev/issues"
-  },
-  "homepage": "https://github.com/gcol33/docrev#readme",
-  "keywords": [
-    "markdown",
-    "word",
-    "docx",
-    "track-changes",
-    "comments",
-    "academic",
-    "writing",
-    "pandoc",
-    "criticmarkup"
-  ],
-  "author": "Gilles Colling",
-  "license": "MIT",
-  "dependencies": {
-    "adm-zip": "^0.5.16",
-    "chalk": "^5.3.0",
-    "commander": "^12.0.0",
-    "dictionary-en": "^4.0.0",
-    "dictionary-en-gb": "^3.0.0",
-    "diff": "^8.0.2",
-    "mathml-to-latex": "^1.5.0",
-    "nspell": "^2.1.5",
-    "pdf-lib": "^1.17.1",
-    "pdfjs-dist": "^5.4.530",
-    "tsx": "^4.21.0",
-    "xml2js": "^0.6.2",
-    "yaml": "^2.8.2"
-  },
-  "devDependencies": {
-    "@types/adm-zip": "^0.5.7",
-    "@types/node": "^25.2.0",
-    "@types/xml2js": "^0.4.14",
-    "c8": "^10.1.2",
-    "typescript": "^5.9.3"
-  }
-}