docrev 0.2.0 → 0.3.0

package/lib/build.js

@@ -39,10 +39,12 @@ export const DEFAULT_CONFIG = {
     geometry: 'margin=1in',
     linestretch: 1.5,
     numbersections: false,
+    toc: false,
   },
   docx: {
     reference: null,
     keepComments: true,
+    toc: false,
   },
   tex: {
     standalone: true,
@@ -317,10 +319,16 @@ export function buildPandocArgs(format, config, outputPath) {
     if (config.pdf.numbersections) {
       args.push('--number-sections');
     }
+    if (config.pdf.toc) {
+      args.push('--toc');
+    }
   } else if (format === 'docx') {
     if (config.docx.reference) {
       args.push('--reference-doc', config.docx.reference);
     }
+    if (config.docx.toc) {
+      args.push('--toc');
+    }
   }
 
   return args;
@@ -434,8 +442,8 @@ export async function build(directory, formats = ['pdf', 'docx'], options = {})
     throw new Error('pandoc not found. Run `rev install` to install dependencies.');
   }
 
-  // Load config
-  const config = loadConfig(directory);
+  // Load config (use passed config if provided, otherwise load from file)
+  const config = options.config || loadConfig(directory);
 
   // Combine sections → paper.md
   const paperPath = combineSections(directory, config, options);

package/lib/crossref.js

@@ -12,20 +12,26 @@ import * as path from 'path';
 
 /**
  * Patterns for detecting hardcoded references
- * Matches: Figure 1, Fig. 1a, fig 1b-c, Figs. 1-3, Table S1, etc.
- * Includes optional letter suffixes for sub-panels (a, b, c, etc.)
+ * Matches complex patterns including:
+ * - Simple: "Figure 1", "Fig. 2a", "Table S1"
+ * - Ranges: "Figures 1-3", "Fig. 1a-c", "Figs. 1a-3b"
+ * - Lists: "Figures 1, 2, and 3", "Fig. 1a, b, c", "Tables 1 & 2"
+ * - Mixed: "Figs. 1, 3-5, and 7"
+ *
+ * Uses a simpler base pattern and parses the full match for lists
  */
 const DETECTION_PATTERNS = {
-  // Figures: Fig, Fig., fig, figure, Figure, FIGURE, Figs, Figures (plural)
-  // With optional letter suffix: 1a, 1b, 2a-c, etc.
-  figure: /\b(Figures?|Figs?\.?)\s*(\d+|S\d+)([a-z])?(?:\s*[-–—&,]\s*(\d+|S\d+)?([a-z])?)?\b/gi,
+  // Captures the full reference including lists with "and"
+  // Group 1: type prefix (Figure, Fig., etc.)
+  // Group 2: reference list (parsed by parseReferenceList())
+  // Matches: "1", "1a", "1-3", "1a-c", "1, 2, 3", "1 and 2", "1, 2 and 3", "1, 2, and 3"
+  // Separator: comma/dash/ampersand, optionally followed by "and"
+  // Standalone letters must be followed by separator, punctuation, or word boundary
+  figure: /\b(Figures?|Figs?\.?)\s+((?:\d+|S\d+)[a-z]?(?:(?:\s*[-–—,&]\s*(?:and\s+)?|\s+and\s+)(?:(?:\d+|S\d+)[a-z]?|[a-z]\b))*)/gi,
 
-  // Tables: Tab, Tab., tab, table, Table, TABLE, Tabs, Tables (plural)
-  // With optional letter suffix for sub-tables
-  table: /\b(Tables?|Tabs?\.?)\s*(\d+|S\d+)([a-z])?(?:\s*[-–—&,]\s*(\d+|S\d+)?([a-z])?)?\b/gi,
+  table: /\b(Tables?|Tabs?\.?)\s+((?:\d+|S\d+)[a-z]?(?:(?:\s*[-–—,&]\s*(?:and\s+)?|\s+and\s+)(?:(?:\d+|S\d+)[a-z]?|[a-z]\b))*)/gi,
 
-  // Equations: Eq, Eq., eq, equation, Equation
-  equation: /\b(Equations?|Eqs?\.?)\s*(\d+)([a-z])?(?:\s*[-–—&,]\s*(\d+)?([a-z])?)?\b/gi,
+  equation: /\b(Equations?|Eqs?\.?)\s+((?:\d+)[a-z]?(?:(?:\s*[-–—,&]\s*(?:and\s+)?|\s+and\s+)(?:(?:\d+)[a-z]?|[a-z]\b))*)/gi,
 };
 
 /**
@@ -68,6 +74,120 @@ export function parseRefNumber(numStr, suffix = null) {
   return { isSupp, num, suffix: extractedSuffix ? extractedSuffix.toLowerCase() : null };
 }
 
+/**
+ * Parse a reference list string like "1, 2, and 3" or "1a-c" or "1a-3b"
+ * Returns an array of {num, isSupp, suffix} objects
+ *
+ * @param {string} listStr - e.g., "1, 2, and 3", "1a-c", "1a-3b", "1a, b, c"
+ * @returns {Array<{num: number, isSupp: boolean, suffix: string|null}>}
+ */
+export function parseReferenceList(listStr) {
+  const results = [];
+  if (!listStr) return results;
+
+  // Normalize: replace "and" with comma, normalize dashes
+  let normalized = listStr
+    .replace(/\s+and\s+/gi, ', ')
+    .replace(/[–—]/g, '-')   // en-dash, em-dash → hyphen
+    .replace(/&/g, ', ');    // & → comma
+
+  // Split by comma (but not by dash, which indicates ranges)
+  const parts = normalized.split(/\s*,\s*/).filter(p => p.trim());
+
+  let lastFullRef = null; // Track the last full reference for implicit prefixes
+
+  for (const part of parts) {
+    const trimmed = part.trim();
+    if (!trimmed) continue;
+
+    // Check if this is a range (contains -)
+    if (trimmed.includes('-')) {
+      const [start, end] = trimmed.split('-').map(s => s.trim());
+
+      // Check if end is just a letter (e.g., "1a-c" where end is "c")
+      const endIsLetterOnly = /^[a-z]$/i.test(end);
+
+      const startRef = parseRefNumber(start);
+      // For letter-only end, don't parse as number
+      const endRef = endIsLetterOnly
+        ? { num: startRef.num, isSupp: startRef.isSupp, suffix: end.toLowerCase() }
+        : parseRefNumber(end);
+
+      // Handle different range types:
+      // 1. Suffix-only range on same number: "1a-c" → 1a, 1b, 1c
+      // 2. Number range: "1-3" → 1, 2, 3
+      // 3. Cross-number suffix range: "1a-3b" → 1a...1z, 2a...2z, 3a, 3b (limited)
+
+      if (startRef.suffix && endRef.suffix && startRef.num !== endRef.num) {
+        // Cross-number suffix range: "1a-3b"
+        // For academic papers, limit intermediate figures to same suffix range
+        // e.g., "1a-3b" typically means 1a, 1b, 2a, 2b, 3a, 3b
+        const maxSuffix = Math.max(
+          startRef.suffix.charCodeAt(0),
+          endRef.suffix.charCodeAt(0)
+        );
+
+        for (let n = startRef.num; n <= endRef.num; n++) {
+          const suffixStart = (n === startRef.num) ? startRef.suffix.charCodeAt(0) : 'a'.charCodeAt(0);
+          const suffixEnd = (n === endRef.num) ? endRef.suffix.charCodeAt(0) : maxSuffix;
+
+          for (let s = suffixStart; s <= suffixEnd; s++) {
+            results.push({
+              num: n,
+              isSupp: startRef.isSupp,
+              suffix: String.fromCharCode(s)
+            });
+          }
+        }
+        lastFullRef = { num: endRef.num, isSupp: startRef.isSupp };
+      } else if (startRef.suffix || endRef.suffix) {
+        // Suffix range on same number: "1a-c"
+        const num = startRef.num || (lastFullRef ? lastFullRef.num : 1);
+        const isSupp = startRef.isSupp || (lastFullRef ? lastFullRef.isSupp : false);
+        const startCode = (startRef.suffix || 'a').charCodeAt(0);
+        const endCode = (endRef.suffix || 'a').charCodeAt(0);
+
+        for (let code = startCode; code <= endCode; code++) {
+          results.push({
+            num,
+            isSupp,
+            suffix: String.fromCharCode(code)
+          });
+        }
+        lastFullRef = { num, isSupp };
+      } else {
+        // Pure number range: "1-3"
+        for (let n = startRef.num; n <= endRef.num; n++) {
+          results.push({
+            num: n,
+            isSupp: startRef.isSupp,
+            suffix: null
+          });
+        }
+        lastFullRef = { num: endRef.num, isSupp: startRef.isSupp };
+      }
+    } else {
+      // Single reference or implicit suffix
+      // Check if it's just a letter (implicit prefix from previous number)
+      if (/^[a-z]$/i.test(trimmed) && lastFullRef) {
+        // Implicit prefix: "b" after "1a" means "1b"
+        results.push({
+          num: lastFullRef.num,
+          isSupp: lastFullRef.isSupp,
+          suffix: trimmed.toLowerCase()
+        });
+      } else {
+        // Full reference: "1", "1a", "S1", "S1a"
+        const ref = parseRefNumber(trimmed);
+        results.push(ref);
+        lastFullRef = { num: ref.num, isSupp: ref.isSupp };
+      }
+    }
+  }
+
+  return results;
+}
+
 /**
  * Build a registry of figure/table labels from .md files
  * Scans for {#fig:label} and {#tbl:label} anchors
@@ -232,46 +352,15 @@ export function detectHardcodedRefs(text) {
     let match;
 
     while ((match = pattern.exec(text)) !== null) {
-      const numbers = [];
-
       // Pattern groups:
-      // [1] = type (Figure, Fig., etc.)
-      // [2] = first number (1, S1)
-      // [3] = first suffix (a, b) - optional
-      // [4] = second number for range (2, S2) - optional
-      // [5] = second suffix (b, c) - optional
-
-      // Parse first number with optional suffix
-      const first = parseRefNumber(match[2], match[3]);
-      numbers.push(first);
-
-      // Parse second number/suffix if present (range like 1a-c or 1-3)
-      if (match[4] || match[5]) {
-        const second = parseRefNumber(match[4] || match[2], match[5]);
-
-        // Handle suffix-only ranges (e.g., "1a-c" means 1a, 1b, 1c)
-        if (!match[4] && match[5] && first.suffix) {
-          // Expand letter range: a-c → a, b, c
-          const startCode = first.suffix.charCodeAt(0);
-          const endCode = match[5].charCodeAt(0);
-          for (let code = startCode + 1; code <= endCode; code++) {
-            numbers.push({
-              num: first.num,
-              isSupp: first.isSupp,
-              suffix: String.fromCharCode(code)
-            });
-          }
-        } else if (match[4]) {
-          // Expand number range
-          if (first.isSupp === second.isSupp && !first.suffix && !second.suffix) {
-            for (let n = first.num + 1; n <= second.num; n++) {
-              numbers.push({ num: n, isSupp: first.isSupp, suffix: null });
-            }
-          } else {
-            numbers.push(second);
-          }
-        }
-      }
+      // [1] = type prefix (Figure, Fig., etc.)
+      // [2] = reference list string (e.g., "1, 2, and 3" or "1a-3b")
+
+      const listStr = match[2];
+      const numbers = parseReferenceList(listStr);
+
+      // Skip if no valid numbers were parsed
+      if (numbers.length === 0) continue;
 
       refs.push({
         type: normalizeType(type),

package/lib/equations.js

@@ -1,14 +1,36 @@
 /**
  * Equation extraction and conversion utilities
  * Handle LaTeX math in Markdown ↔ Word workflows
+ *
+ * Supports:
+ * - Extract LaTeX equations from Markdown
+ * - Extract equations from Word documents (OMML → LaTeX via Pandoc)
+ * - Convert Markdown with equations to Word (LaTeX → MathML)
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import AdmZip from 'adm-zip';
+import { parseString } from 'xml2js';
 
 const execAsync = promisify(exec);
+const parseXml = promisify(parseString);
+
+// Dynamic import for mathml-to-latex (ESM)
+let MathMLToLaTeX = null;
+async function getMathMLConverter() {
+  if (!MathMLToLaTeX) {
+    try {
+      const module = await import('mathml-to-latex');
+      MathMLToLaTeX = module.MathMLToLaTeX;
+    } catch {
+      return null;
+    }
+  }
+  return MathMLToLaTeX;
+}
 
 /**
  * Extract all equations from markdown text
@@ -256,3 +278,216 @@ export function getEquationStats(files) {
     byFile,
   };
 }
+
+/**
+ * Extract equations from a Word document using Pandoc
+ * Converts OMML (Office Math Markup) to LaTeX
+ *
+ * @param {string} docxPath - Path to Word document
+ * @returns {Promise<{success: boolean, equations: Array<{type: string, latex: string, position: number}>, error?: string}>}
+ */
+export async function extractEquationsFromWord(docxPath) {
+  if (!fs.existsSync(docxPath)) {
+    return { success: false, equations: [], error: `File not found: ${docxPath}` };
+  }
+
+  // Method 1: Use Pandoc to convert docx to markdown with LaTeX math
+  try {
+    const { stdout } = await execAsync(
+      `pandoc "${docxPath}" -t markdown --wrap=none`,
+      { maxBuffer: 50 * 1024 * 1024 }
+    );
+
+    // Extract equations from the markdown output
+    const equations = extractEquations(stdout, path.basename(docxPath));
+
+    return {
+      success: true,
+      equations: equations.map((eq, i) => ({
+        type: eq.type,
+        latex: eq.content,
+        position: i,
+        line: eq.line,
+      })),
+    };
+  } catch (err) {
+    // Pandoc failed, try fallback method
+    return extractEquationsFromWordDirect(docxPath);
+  }
+}
+
+/**
+ * Direct OMML extraction from Word document (fallback if Pandoc fails)
+ * Parses document.xml for <m:oMath> elements and attempts conversion
+ *
+ * @param {string} docxPath
+ * @returns {Promise<{success: boolean, equations: Array, error?: string}>}
+ */
+async function extractEquationsFromWordDirect(docxPath) {
+  try {
+    const zip = new AdmZip(docxPath);
+    const documentEntry = zip.getEntry('word/document.xml');
+
+    if (!documentEntry) {
+      return { success: false, equations: [], error: 'Invalid docx: no document.xml' };
+    }
+
+    const documentXml = zip.readAsText(documentEntry);
+
+    // Find all OMML equations (<m:oMath> or <m:oMathPara>)
+    const ommlPattern = /<m:oMath[^>]*>[\s\S]*?<\/m:oMath>/gi;
+    const matches = documentXml.match(ommlPattern) || [];
+
+    if (matches.length === 0) {
+      return { success: true, equations: [], message: 'No equations found' };
+    }
+
+    // Try to convert OMML to LaTeX via MathML intermediate
+    const Converter = await getMathMLConverter();
+    const equations = [];
+
+    for (let i = 0; i < matches.length; i++) {
+      const omml = matches[i];
+
+      // Attempt OMML → MathML → LaTeX conversion
+      // Note: This is a simplified approach; full OMML→MathML requires XSLT
+      try {
+        const latex = await ommlToLatex(omml, Converter);
+        if (latex) {
+          equations.push({
+            type: isDisplayMath(omml) ? 'display' : 'inline',
+            latex,
+            position: i,
+            raw: omml.substring(0, 100) + '...',
+          });
+        }
+      } catch {
+        // Keep raw OMML reference if conversion fails
+        equations.push({
+          type: 'unknown',
+          latex: null,
+          position: i,
+          raw: omml.substring(0, 100) + '...',
+          error: 'Conversion failed',
+        });
+      }
+    }
+
+    return { success: true, equations };
+  } catch (err) {
+    return { success: false, equations: [], error: err.message };
+  }
+}
+
+/**
+ * Check if OMML represents display math (equation on its own line)
+ */
+function isDisplayMath(omml) {
+  return omml.includes('<m:oMathPara') || omml.includes('m:jc');
+}
+
+/**
+ * Convert OMML to LaTeX (simplified approach)
+ * For complex equations, Pandoc method is more reliable
+ *
+ * @param {string} omml - OMML XML string
+ * @param {Function} Converter - MathMLToLaTeX converter
+ * @returns {Promise<string|null>}
+ */
+async function ommlToLatex(omml, Converter) {
+  if (!Converter) return null;
+
+  // Extract key elements from OMML and build approximate MathML
+  // This is a simplified conversion - not all OMML features are supported
+  try {
+    // Build basic MathML from OMML structure
+    const mathml = ommlToMathML(omml);
+    if (!mathml) return null;
+
+    // Convert MathML to LaTeX
+    const latex = Converter.convert(mathml);
+    return latex;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Convert OMML to MathML (simplified)
+ * Maps common OMML elements to MathML equivalents
+ */
+function ommlToMathML(omml) {
+  // Remove namespace prefixes for easier parsing
+  let xml = omml
+    .replace(/<m:/g, '<')
+    .replace(/<\/m:/g, '</')
+    .replace(/<w:/g, '<w_')
+    .replace(/<\/w:/g, '</w_');
+
+  // Map OMML elements to MathML
+  const mappings = [
+    [/<oMath[^>]*>/gi, '<math xmlns="http://www.w3.org/1998/Math/MathML">'],
+    [/<\/oMath>/gi, '</math>'],
+    [/<r>/gi, '<mi>'],
+    [/<\/r>/gi, '</mi>'],
+    [/<t>/gi, ''],
+    [/<\/t>/gi, ''],
+    [/<f>/gi, '<mfrac>'],
+    [/<\/f>/gi, '</mfrac>'],
+    [/<num>/gi, '<mrow>'],
+    [/<\/num>/gi, '</mrow>'],
+    [/<den>/gi, '<mrow>'],
+    [/<\/den>/gi, '</mrow>'],
+    [/<sup>/gi, '<msup><mrow>'],
+    [/<\/sup>/gi, '</mrow></msup>'],
+    [/<sub>/gi, '<msub><mrow>'],
+    [/<\/sub>/gi, '</mrow></msub>'],
+    [/<rad>/gi, '<msqrt>'],
+    [/<\/rad>/gi, '</msqrt>'],
+    [/<e>/gi, '<mrow>'],
+    [/<\/e>/gi, '</mrow>'],
+    // Remove elements we don't map
+    [/<rPr>[\s\S]*?<\/rPr>/gi, ''],
+    [/<ctrlPr>[\s\S]*?<\/ctrlPr>/gi, ''],
+    [/<w_[^>]*>[\s\S]*?<\/w_[^>]*>/gi, ''],
+    [/<[^>]*\/>/gi, ''], // Self-closing tags
+  ];
+
+  for (const [pattern, replacement] of mappings) {
+    xml = xml.replace(pattern, replacement);
+  }
+
+  // Clean up any remaining unrecognized tags
+  xml = xml.replace(/<[a-zA-Z][^>]*>/g, '').replace(/<\/[a-zA-Z]+>/g, '');
+
+  // Wrap in math if not already
+  if (!xml.includes('<math')) {
+    xml = `<math xmlns="http://www.w3.org/1998/Math/MathML">${xml}</math>`;
+  }
+
+  return xml;
+}
+
+/**
+ * Get equation summary from Word document
+ * @param {string} docxPath
+ * @returns {Promise<{count: number, display: number, inline: number, converted: number}>}
+ */
+export async function getWordEquationStats(docxPath) {
+  const result = await extractEquationsFromWord(docxPath);
+
+  if (!result.success) {
+    return { count: 0, display: 0, inline: 0, converted: 0, error: result.error };
+  }
+
+  const display = result.equations.filter(e => e.type === 'display').length;
+  const inline = result.equations.filter(e => e.type === 'inline').length;
+  const converted = result.equations.filter(e => e.latex).length;
+
+  return {
+    count: result.equations.length,
+    display,
+    inline,
+    converted,
+  };
+}