@ansonlai/docx-redline-js 0.8.4 → 0.10.0

package/pipeline/diff-engine.js

@@ -41,9 +41,15 @@ export function createDiffEngine(options = {}) {
     return engine;
 }
 
+// Opening and closing punctuation that hugs a word. Splitting it into its own
+// token lets "agents and attorneys" -> "agents, attorneys," keep both words
+// unchanged instead of replacing the whole phrase.
+const LEADING_PUNCTUATION = /^[("'\[{“‘]+/u;
+const TRAILING_PUNCTUATION = /[)"'\]}”’,.;:!?]+$/u;
+
 function tokenize(text, atomicChars = null) {
     const tokens = [];
-    const pushWord = word => {
+    const pushPiece = word => {
         if (!atomicChars || atomicChars.size === 0) {
             tokens.push(word);
             return;
@@ -59,6 +65,20 @@ function tokenize(text, atomicChars = null) {
         }
         if (start < word.length) tokens.push(word.slice(start));
     };
+    const pushWord = word => {
+        const leading = word.match(LEADING_PUNCTUATION)?.[0] || '';
+        const rest = word.slice(leading.length);
+        const trailing = rest.match(TRAILING_PUNCTUATION)?.[0] || '';
+        const core = rest.slice(0, rest.length - trailing.length);
+        // A token made only of punctuation stays whole.
+        if (!core) {
+            pushPiece(word);
+            return;
+        }
+        for (const char of leading) pushPiece(char);
+        pushPiece(core);
+        for (const char of trailing) pushPiece(char);
+    };
     const leading = text.match(/^\s+/);
     if (leading) tokens.push(leading[0]);
 
@@ -243,11 +263,120 @@ export function computeWordDiffs(originalText, newText, options = {}) {
     const charDiffs = dmp.diff_main(encodeTokenIdsForDmp(tokenIds1), encodeTokenIdsForDmp(tokenIds2));
     if (cleanupSemantic) {
         dmp.diff_cleanupSemantic(charDiffs);
+        refineReplacementsAroundAnchors(dmp, charDiffs, wordArray);
     }
 
     return decodeBmpDiffs(charDiffs, wordArray);
 }
 
+// A token that is a substantive word: four or more letters or digits. Short
+// function words ("a", "the", "and") and punctuation never anchor on their own.
+const ANCHOR_TOKEN = /^[\p{L}\p{N}][\p{L}\p{N}'’-]{3,}$/u;
+
+function isAnchorEquality(chars, wordArray) {
+    for (let index = 0; index < chars.length; index++) {
+        if (ANCHOR_TOKEN.test(wordArray[bmpCharToTokenId(chars.charCodeAt(index))])) return true;
+    }
+    return false;
+}
+
+const MAX_ANCHOR_REFINEMENT_CELLS = 250000;
+
+/**
+ * Token LCS that weights substantive words far above whitespace, punctuation
+ * and function words. A plain LCS would rather keep " and " (three tokens)
+ * than "attorneys" (one token), which is the opposite of a useful redline.
+ * Returns null when the replacement is too large to refine cheaply.
+ *
+ * @param {string} deleted - BMP-encoded deleted tokens
+ * @param {string} inserted - BMP-encoded inserted tokens
+ * @param {string[]} wordArray
+ * @returns {Array<[number, string]>|null}
+ */
+function anchorWeightedDiff(deleted, inserted, wordArray) {
+    const rows = deleted.length;
+    const cols = inserted.length;
+    if (!rows || !cols || (rows + 1) * (cols + 1) > MAX_ANCHOR_REFINEMENT_CELLS) return null;
+
+    const weight = char => {
+        const token = wordArray[bmpCharToTokenId(char.charCodeAt(0))];
+        return ANCHOR_TOKEN.test(token) ? token.length * 100 : token.length;
+    };
+    const width = cols + 1;
+    const scores = new Float64Array((rows + 1) * width);
+    for (let row = rows - 1; row >= 0; row--) {
+        for (let col = cols - 1; col >= 0; col--) {
+            const skip = Math.max(scores[(row + 1) * width + col], scores[row * width + col + 1]);
+            scores[row * width + col] = deleted[row] === inserted[col]
+                ? Math.max(skip, weight(deleted[row]) + scores[(row + 1) * width + col + 1])
+                : skip;
+        }
+    }
+
+    const result = [];
+    const push = (op, char) => {
+        const last = result[result.length - 1];
+        if (last?.[0] === op) last[1] += char;
+        else result.push([op, char]);
+    };
+    let row = 0;
+    let col = 0;
+    while (row < rows && col < cols) {
+        const here = scores[row * width + col];
+        if (deleted[row] === inserted[col]
+            && here === weight(deleted[row]) + scores[(row + 1) * width + col + 1]) {
+            push(0, deleted[row]);
+            row++;
+            col++;
+        } else if (scores[(row + 1) * width + col] >= scores[row * width + col + 1]) {
+            push(-1, deleted[row++]);
+        } else {
+            push(1, inserted[col++]);
+        }
+    }
+    while (row < rows) push(-1, deleted[row++]);
+    while (col < cols) push(1, inserted[col++]);
+    return result;
+}
+
+/**
+ * Semantic cleanup measures equalities in tokens, so a single unchanged word
+ * between two edits ("agents[ and] attorneys[, accountants ...]") is folded
+ * into one whole-phrase replacement. Re-diff each replacement and keep any
+ * unchanged run that contains a substantive word, so the redline only marks
+ * the text that actually changed.
+ */
+function refineReplacementsAroundAnchors(dmp, diffs, wordArray) {
+    for (let index = 0; index < diffs.length; index++) {
+        let deleteIndex = -1;
+        let insertIndex = -1;
+        if (diffs[index][0] === -1 && diffs[index + 1]?.[0] === 1) {
+            deleteIndex = index;
+            insertIndex = index + 1;
+        } else if (diffs[index][0] === 1 && diffs[index + 1]?.[0] === -1) {
+            insertIndex = index;
+            deleteIndex = index + 1;
+        } else {
+            continue;
+        }
+
+        const inner = anchorWeightedDiff(diffs[deleteIndex][1], diffs[insertIndex][1], wordArray);
+        if (!inner?.some(([op, chars]) => op === 0 && isAnchorEquality(chars, wordArray))) continue;
+
+        const refined = [];
+        for (const [op, chars] of inner) {
+            if (op === 0 && !isAnchorEquality(chars, wordArray)) {
+                refined.push([-1, chars], [1, chars]);
+            } else {
+                refined.push([op, chars]);
+            }
+        }
+        dmp.diff_cleanupMerge(refined);
+        diffs.splice(index, 2, ...refined);
+        index += refined.length - 1;
+    }
+}
+
 /**
  * Computes a character-local diff without semantic cleanup. This is used to
  * refine whitespace-only substitutions that a word-level token groups with

package/pipeline/ingestion-export.js

@@ -1,243 +1,227 @@
-/**
- * Word OOXML ingestion helpers for plain-text/markdown export.
- *
- * These helpers are intentionally conservative and only map obvious signals:
- * - Paragraph structure
- * - Heading styles
- * - List paragraph properties
- * - Run-level bold/italic formatting
- */
-
-import { parseOoxmlSafe } from '../adapters/xml-adapter.js';
-import { NS_W } from '../core/types.js';
-import { getXmlParseError } from '../core/xml-query.js';
-import { isNodeVisibleInRevisionView, readCanonicalRunText } from '../core/paragraph-text.js';
-
-function hasParserError(doc) {
-    if (!doc || !doc.documentElement) return true;
-    if (doc.documentElement.localName === 'parsererror') return true;
-    return !!getXmlParseError(doc);
-}
-
-function parseWordOoxml(ooxml) {
-    const parsed = parseOoxmlSafe(ooxml, 'application/xml');
-    if (parsed.error || hasParserError(parsed.doc)) return { ...parsed, doc: null };
-    return parsed;
-}
-
-function getWordParagraphs(doc) {
-    if (!doc) return [];
-    const namespaced = Array.from(doc.getElementsByTagNameNS(NS_W, 'p'));
-    if (namespaced.length > 0) return namespaced;
-    return Array.from(doc.getElementsByTagNameNS('*', 'p')).filter(node => node?.localName === 'p');
-}
-
-function getDirectWordChild(node, localName) {
-    const children = Array.from(node?.childNodes || []);
-    for (const child of children) {
-        if (child?.nodeType !== 1) continue;
-        if (child.namespaceURI !== NS_W) continue;
-        if (child.localName === localName) return child;
-    }
-    return null;
-}
-
-function getWordDescendants(node, localName) {
-    return Array.from(node?.getElementsByTagNameNS?.(NS_W, localName) || []);
-}
-
-function getWordAttribute(element, names) {
-    if (!element) return '';
-    for (const name of names) {
-        const value = element.getAttribute(name);
-        if (value != null && value !== '') return value;
-    }
-    return '';
-}
-
-function getRunFormatting(run) {
-    const rPr = getDirectWordChild(run, 'rPr');
-    if (!rPr) return { bold: false, italic: false };
-    const rStyle = getWordDescendants(rPr, 'rStyle')[0] || null;
-    const rStyleValue = getWordAttribute(rStyle, ['w:val', 'val']).toLowerCase();
-    const styleImpliesBold = rStyleValue.includes('strong') || rStyleValue.includes('bold');
-    const styleImpliesItalic = rStyleValue.includes('italic') || rStyleValue.includes('emphasis');
-    return {
-        bold: getWordDescendants(rPr, 'b').length > 0 || styleImpliesBold,
-        italic: getWordDescendants(rPr, 'i').length > 0 || styleImpliesItalic
-    };
-}
-
-function collectParagraphSegments(paragraph) {
-    const segments = [];
-    const runs = Array.from(paragraph?.getElementsByTagNameNS?.(NS_W, 'r') || []);
-    for (const run of runs) {
-        if (!isNodeVisibleInRevisionView(run, paragraph, 'accepted')) continue;
-        const text = readCanonicalRunText(run, { boundary: paragraph, revisionView: 'accepted' });
-        if (!text) continue;
-        segments.push({
-            text,
-            ...getRunFormatting(run)
-        });
-    }
-    return segments;
-}
-
-function normalizeInlineWhitespace(text) {
-    const normalizedLines = String(text || '')
-        .replace(/\r/g, '')
-        .split('\n')
-        .map(line => line.replace(/[ \t]+/g, ' ').trim());
-    return normalizedLines.join('\n').trim();
-}
-
-function wrapRunMarkdown(text, format) {
-    const raw = String(text || '');
-    if (!raw) return '';
-    if (!format?.bold && !format?.italic) return raw;
-
-    const match = raw.match(/^(\s*)([\s\S]*?)(\s*)$/);
-    if (!match) return raw;
-    const leading = match[1] || '';
-    const core = match[2] || '';
-    const trailing = match[3] || '';
-    if (!core.trim()) return raw;
-
-    let wrapped = core;
-    if (format.bold && format.italic) wrapped = `***${core}***`;
-    else if (format.bold) wrapped = `**${core}**`;
-    else if (format.italic) wrapped = `*${core}*`;
-    return `${leading}${wrapped}${trailing}`;
-}
-
-function parseHeadingLevel(paragraph) {
-    const pPr = getDirectWordChild(paragraph, 'pPr');
-    if (!pPr) return null;
-
-    const pStyle = getWordDescendants(pPr, 'pStyle')[0] || null;
-    const styleVal = getWordAttribute(pStyle, ['w:val', 'val']);
-    if (styleVal) {
-        const match = styleVal.match(/^heading\s*([1-9])$/i);
-        if (match) {
-            const level = Number.parseInt(match[1], 10);
-            if (Number.isInteger(level)) return Math.min(Math.max(level, 1), 6);
-        }
-    }
-
-    const outlineLvl = getWordDescendants(pPr, 'outlineLvl')[0] || null;
-    const outlineRaw = getWordAttribute(outlineLvl, ['w:val', 'val']);
-    const outline = Number.parseInt(outlineRaw, 10);
-    if (Number.isInteger(outline) && outline >= 0) {
-        return Math.min(outline + 1, 6);
-    }
-
-    return null;
-}
-
-function parseListInfo(paragraph) {
-    const pPr = getDirectWordChild(paragraph, 'pPr');
-    if (!pPr) return null;
-
-    const numPr = getWordDescendants(pPr, 'numPr')[0] || null;
-    if (!numPr) return null;
-
-    const ilvlEl = getWordDescendants(numPr, 'ilvl')[0] || null;
-    const numIdEl = getWordDescendants(numPr, 'numId')[0] || null;
-    const ilvl = Number.parseInt(getWordAttribute(ilvlEl, ['w:val', 'val']), 10);
-    const numId = getWordAttribute(numIdEl, ['w:val', 'val']);
-
-    const safeLevel = Number.isInteger(ilvl) && ilvl >= 0 ? ilvl : 0;
-    const marker = numId === '1' ? '-' : '1.';
-    return { level: safeLevel, marker };
-}
-
-function paragraphToPlainText(paragraph) {
-    const text = collectParagraphSegments(paragraph).map(segment => segment.text).join('');
-    return normalizeInlineWhitespace(text);
-}
-
-function paragraphToMarkdown(paragraph) {
-    const segments = collectParagraphSegments(paragraph);
-    const inline = segments.map(segment => wrapRunMarkdown(segment.text, segment)).join('');
-    const normalizedInline = normalizeInlineWhitespace(inline);
-    if (!normalizedInline) return '';
-
-    const headingLevel = parseHeadingLevel(paragraph);
-    if (headingLevel != null) {
-        return `${'#'.repeat(headingLevel)} ${normalizedInline}`;
-    }
-
-    const list = parseListInfo(paragraph);
-    if (list) {
-        const indent = '  '.repeat(list.level);
-        return `${indent}${list.marker} ${normalizedInline}`;
-    }
-
-    return normalizedInline;
-}
-
-/**
- * Ingests Word OOXML and returns readable plain text.
- *
- * @param {string} ooxml
- * @returns {string}
- */
-export function ingestWordOoxmlToPlainText(ooxml) {
-    return ingestWordOoxmlToPlainTextResult(ooxml).text;
-}
-
-/**
- * Result-returning plain-text ingestion for callers that need parse failures
- * distinguished from legitimately empty documents.
- *
- * @param {unknown} ooxml
- * @returns {{ text: string, status: 'ok'|'error', error?: {code:string,message:string}, warnings?: string[] }}
- */
-export function ingestWordOoxmlToPlainTextResult(ooxml) {
-    const parsed = parseWordOoxml(ooxml);
-    if (!parsed.doc) {
-        return { text: '', status: 'error', error: parsed.error, warnings: parsed.warnings };
-    }
-    const doc = parsed.doc;
-
-    const paragraphs = getWordParagraphs(doc);
-    if (paragraphs.length === 0) {
-        const fallback = normalizeInlineWhitespace(doc.documentElement?.textContent || '');
-        return { text: fallback, status: 'ok', warnings: parsed.warnings };
-    }
-
-    const lines = paragraphs.map(paragraphToPlainText);
-    return { text: lines.join('\n\n').trim(), status: 'ok', warnings: parsed.warnings };
-}
-
-/**
- * Ingests Word OOXML and returns basic markdown.
- *
- * @param {string} ooxml
- * @returns {string}
- */
-export function ingestWordOoxmlToMarkdown(ooxml) {
-    return ingestWordOoxmlToMarkdownResult(ooxml).text;
-}
-
-/**
- * Result-returning markdown ingestion counterpart.
- *
- * @param {unknown} ooxml
- * @returns {{ text: string, status: 'ok'|'error', error?: {code:string,message:string}, warnings?: string[] }}
- */
-export function ingestWordOoxmlToMarkdownResult(ooxml) {
-    const parsed = parseWordOoxml(ooxml);
-    if (!parsed.doc) {
-        return { text: '', status: 'error', error: parsed.error, warnings: parsed.warnings };
-    }
-    const doc = parsed.doc;
-
-    const paragraphs = getWordParagraphs(doc);
-    if (paragraphs.length === 0) {
-        return { text: '', status: 'ok', warnings: parsed.warnings };
-    }
-
-    const lines = paragraphs.map(paragraphToMarkdown);
-    return { text: lines.join('\n\n').trim(), status: 'ok', warnings: parsed.warnings };
-}
+/**
+ * Word OOXML ingestion helpers for plain-text/markdown export.
+ *
+ * These helpers are intentionally conservative and only map obvious signals:
+ * - Paragraph structure
+ * - Heading styles
+ * - List paragraph properties
+ * - Run-level bold/italic formatting
+ */
+
+import { parseOoxmlSafe } from '../adapters/xml-adapter.js';
+import { NS_W } from '../core/types.js';
+import { getCurrentChild, getCurrentParagraphProperties, getCurrentRunProperties } from '../core/current-properties.js';
+import { getXmlParseError } from '../core/xml-query.js';
+import { isNodeVisibleInRevisionView, readCanonicalRunText } from '../core/paragraph-text.js';
+
+function hasParserError(doc) {
+    if (!doc || !doc.documentElement) return true;
+    if (doc.documentElement.localName === 'parsererror') return true;
+    return !!getXmlParseError(doc);
+}
+
+function parseWordOoxml(ooxml) {
+    const parsed = parseOoxmlSafe(ooxml, 'application/xml');
+    if (parsed.error || hasParserError(parsed.doc)) return { ...parsed, doc: null };
+    return parsed;
+}
+
+function getWordParagraphs(doc) {
+    if (!doc) return [];
+    const namespaced = Array.from(doc.getElementsByTagNameNS(NS_W, 'p'));
+    if (namespaced.length > 0) return namespaced;
+    return Array.from(doc.getElementsByTagNameNS('*', 'p')).filter(node => node?.localName === 'p');
+}
+
+
+function getWordAttribute(element, names) {
+    if (!element) return '';
+    for (const name of names) {
+        const value = element.getAttribute(name);
+        if (value != null && value !== '') return value;
+    }
+    return '';
+}
+
+function getRunFormatting(run) {
+    // Current run properties only: a w:rPrChange snapshot must not make historical b/i/rStyle look current.
+    const rPr = getCurrentRunProperties(run);
+    if (!rPr) return { bold: false, italic: false };
+    const rStyle = getCurrentChild(rPr, 'rStyle');
+    const rStyleValue = getWordAttribute(rStyle, ['w:val', 'val']).toLowerCase();
+    const styleImpliesBold = rStyleValue.includes('strong') || rStyleValue.includes('bold');
+    const styleImpliesItalic = rStyleValue.includes('italic') || rStyleValue.includes('emphasis');
+    return {
+        bold: !!getCurrentChild(rPr, 'b') || styleImpliesBold,
+        italic: !!getCurrentChild(rPr, 'i') || styleImpliesItalic
+    };
+}
+
+function collectParagraphSegments(paragraph) {
+    const segments = [];
+    const runs = Array.from(paragraph?.getElementsByTagNameNS?.(NS_W, 'r') || []);
+    for (const run of runs) {
+        if (!isNodeVisibleInRevisionView(run, paragraph, 'accepted')) continue;
+        const text = readCanonicalRunText(run, { boundary: paragraph, revisionView: 'accepted' });
+        if (!text) continue;
+        segments.push({
+            text,
+            ...getRunFormatting(run)
+        });
+    }
+    return segments;
+}
+
+function normalizeInlineWhitespace(text) {
+    const normalizedLines = String(text || '')
+        .replace(/\r/g, '')
+        .split('\n')
+        .map(line => line.replace(/[ \t]+/g, ' ').trim());
+    return normalizedLines.join('\n').trim();
+}
+
+function wrapRunMarkdown(text, format) {
+    const raw = String(text || '');
+    if (!raw) return '';
+    if (!format?.bold && !format?.italic) return raw;
+
+    const match = raw.match(/^(\s*)([\s\S]*?)(\s*)$/);
+    if (!match) return raw;
+    const leading = match[1] || '';
+    const core = match[2] || '';
+    const trailing = match[3] || '';
+    if (!core.trim()) return raw;
+
+    let wrapped = core;
+    if (format.bold && format.italic) wrapped = `***${core}***`;
+    else if (format.bold) wrapped = `**${core}**`;
+    else if (format.italic) wrapped = `*${core}*`;
+    return `${leading}${wrapped}${trailing}`;
+}
+
+function parseHeadingLevel(paragraph) {
+    const { pPr, pStyleElement, outlineLvlElement } = getCurrentParagraphProperties(paragraph);
+    if (!pPr) return null;
+
+    const styleVal = getWordAttribute(pStyleElement, ['w:val', 'val']);
+    if (styleVal) {
+        const match = styleVal.match(/^heading\s*([1-9])$/i);
+        if (match) {
+            const level = Number.parseInt(match[1], 10);
+            if (Number.isInteger(level)) return Math.min(Math.max(level, 1), 6);
+        }
+    }
+
+    const outlineRaw = getWordAttribute(outlineLvlElement, ['w:val', 'val']);
+    const outline = Number.parseInt(outlineRaw, 10);
+    if (Number.isInteger(outline) && outline >= 0) {
+        return Math.min(outline + 1, 6);
+    }
+
+    return null;
+}
+
+function parseListInfo(paragraph) {
+    const { numPr } = getCurrentParagraphProperties(paragraph);
+    if (!numPr) return null;
+
+    const ilvlEl = numPr.ilvlElement;
+    const numIdEl = numPr.numIdElement;
+    const ilvl = Number.parseInt(getWordAttribute(ilvlEl, ['w:val', 'val']), 10);
+    const numId = getWordAttribute(numIdEl, ['w:val', 'val']);
+
+    const safeLevel = Number.isInteger(ilvl) && ilvl >= 0 ? ilvl : 0;
+    const marker = numId === '1' ? '-' : '1.';
+    return { level: safeLevel, marker };
+}
+
+function paragraphToPlainText(paragraph) {
+    const text = collectParagraphSegments(paragraph).map(segment => segment.text).join('');
+    return normalizeInlineWhitespace(text);
+}
+
+function paragraphToMarkdown(paragraph) {
+    const segments = collectParagraphSegments(paragraph);
+    const inline = segments.map(segment => wrapRunMarkdown(segment.text, segment)).join('');
+    const normalizedInline = normalizeInlineWhitespace(inline);
+    if (!normalizedInline) return '';
+
+    const headingLevel = parseHeadingLevel(paragraph);
+    if (headingLevel != null) {
+        return `${'#'.repeat(headingLevel)} ${normalizedInline}`;
+    }
+
+    const list = parseListInfo(paragraph);
+    if (list) {
+        const indent = '  '.repeat(list.level);
+        return `${indent}${list.marker} ${normalizedInline}`;
+    }
+
+    return normalizedInline;
+}
+
+/**
+ * Ingests Word OOXML and returns readable plain text.
+ *
+ * @param {string} ooxml
+ * @returns {string}
+ */
+export function ingestWordOoxmlToPlainText(ooxml) {
+    return ingestWordOoxmlToPlainTextResult(ooxml).text;
+}
+
+/**
+ * Result-returning plain-text ingestion for callers that need parse failures
+ * distinguished from legitimately empty documents.
+ *
+ * @param {unknown} ooxml
+ * @returns {{ text: string, status: 'ok'|'error', error?: {code:string,message:string}, warnings?: string[] }}
+ */
+export function ingestWordOoxmlToPlainTextResult(ooxml) {
+    const parsed = parseWordOoxml(ooxml);
+    if (!parsed.doc) {
+        return { text: '', status: 'error', error: parsed.error, warnings: parsed.warnings };
+    }
+    const doc = parsed.doc;
+
+    const paragraphs = getWordParagraphs(doc);
+    if (paragraphs.length === 0) {
+        const fallback = normalizeInlineWhitespace(doc.documentElement?.textContent || '');
+        return { text: fallback, status: 'ok', warnings: parsed.warnings };
+    }
+
+    const lines = paragraphs.map(paragraphToPlainText);
+    return { text: lines.join('\n\n').trim(), status: 'ok', warnings: parsed.warnings };
+}
+
+/**
+ * Ingests Word OOXML and returns basic markdown.
+ *
+ * @param {string} ooxml
+ * @returns {string}
+ */
+export function ingestWordOoxmlToMarkdown(ooxml) {
+    return ingestWordOoxmlToMarkdownResult(ooxml).text;
+}
+
+/**
+ * Result-returning markdown ingestion counterpart.
+ *
+ * @param {unknown} ooxml
+ * @returns {{ text: string, status: 'ok'|'error', error?: {code:string,message:string}, warnings?: string[] }}
+ */
+export function ingestWordOoxmlToMarkdownResult(ooxml) {
+    const parsed = parseWordOoxml(ooxml);
+    if (!parsed.doc) {
+        return { text: '', status: 'error', error: parsed.error, warnings: parsed.warnings };
+    }
+    const doc = parsed.doc;
+
+    const paragraphs = getWordParagraphs(doc);
+    if (paragraphs.length === 0) {
+        return { text: '', status: 'ok', warnings: parsed.warnings };
+    }
+
+    const lines = paragraphs.map(paragraphToMarkdown);
+    return { text: lines.join('\n\n').trim(), status: 'ok', warnings: parsed.warnings };
+}