officeparser 6.1.0 → 7.0.0

package/dist/parsers/WordParser.js

@@ -40,6 +40,7 @@
  * - `<w:p>` - Paragraph
  * - `<w:r>` - Run (contiguous text with same formatting)
  * - `<w:t>` - Text content
+ * - `<w:br>` - Line or page break
  * - `<w:b>`, `<w:i>`, `<w:u>` - Bold, italic, underline
  * - `<w:pStyle>` - Paragraph style (for headings)
  * - `<w:numPr>` - List numbering properties
@@ -61,6 +62,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWord = void 0;
+const types_js_1 = require("../types.js");
+const astUtils_js_1 = require("../utils/astUtils.js");
 const errorUtils_js_1 = require("../utils/errorUtils.js");
 const imageUtils_js_1 = require("../utils/imageUtils.js");
 const ocrUtils_js_1 = require("../utils/ocrUtils.js");
@@ -95,83 +98,134 @@ const parseWord = async (buffer, config) => {
     // Helper to extract formatting from run properties XML string
     const extractFormattingFromXml = (rPr) => {
         const formatting = {};
-        const rPrString = (0, xmlUtils_js_1.serializeXml)(rPr);
-        // Helper to check boolean properties
-        const getBoolVal = (xmlSnippet, tagName) => {
-            const regex = new RegExp(`<${tagName}(?:\\s+w:val="([^"]+)")?\\s*\\/?>`);
-            const match = xmlSnippet.match(regex);
-            if (match) {
-                const val = match[1];
-                if (val === undefined)
+        // Helper to check boolean properties (e.g., <w:b />, <w:i w:val="0" />)
+        const getBoolVal = (parent, tagName) => {
+            const el = (0, xmlUtils_js_1.getFirstElementByTagName)(parent, tagName);
+            if (el) {
+                const val = el.getAttribute('w:val');
+                // In OOXML, if the element is present without w:val, it's true.
+                // If w:val is present, it can be '1', 'true', 'on' for true.
+                if (val === null)
                     return true;
                 return val === '1' || val === 'true' || val === 'on';
             }
             return null;
         };
-        const bold = getBoolVal(rPrString, 'w:b');
+        const bold = getBoolVal(rPr, 'w:b');
         if (bold !== null)
             formatting.bold = bold;
-        const italic = getBoolVal(rPrString, 'w:i');
+        const italic = getBoolVal(rPr, 'w:i');
         if (italic !== null)
             formatting.italic = italic;
-        const underlineMatch = rPrString.match(/<w:u(?: w:val="([^"]+)")?\/?>/);
-        if (underlineMatch) {
-            const val = underlineMatch[1];
+        const u = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, 'w:u');
+        if (u) {
+            const val = u.getAttribute('w:val');
             // If val is missing, it's a default underline (true). 
             // If val is present, it's true unless explicit 'none'.
             if (!val || val !== 'none') {
                 formatting.underline = true;
             }
         }
-        const strike = getBoolVal(rPrString, 'w:strike');
-        const dstrike = getBoolVal(rPrString, 'w:dstrike');
+        const strike = getBoolVal(rPr, 'w:strike');
+        const dstrike = getBoolVal(rPr, 'w:dstrike');
         if (strike !== null)
             formatting.strikethrough = strike;
         else if (dstrike !== null)
             formatting.strikethrough = dstrike;
-        // Font size
-        const szMatch = rPrString.match(/<w:sz w:val="(\d+)"/);
-        if (szMatch)
-            formatting.size = (parseInt(szMatch[1]) / 2).toString() + 'pt';
-        // Color
-        const colorMatch = rPrString.match(/<w:color w:val="([^"]+)"/);
-        if (colorMatch && colorMatch[1] !== 'auto')
-            formatting.color = '#' + colorMatch[1];
-        // Background color (shading)
-        const shdMatch = rPrString.match(/<w:shd[^>]*w:fill="([^"]+)"/);
-        if (shdMatch && shdMatch[1] !== 'auto')
-            formatting.backgroundColor = '#' + shdMatch[1];
-        // Highlight (map to backgroundColor)
-        const highlightMatch = rPrString.match(/<w:highlight w:val="([^"]+)"/);
-        if (highlightMatch && highlightMatch[1] !== 'none') {
-            const colorMap = {
-                'yellow': '#FFFF00', 'green': '#00FF00', 'cyan': '#00FFFF', 'magenta': '#FF00FF',
-                'blue': '#0000FF', 'red': '#FF0000', 'darkBlue': '#00008B', 'darkCyan': '#008B8B',
-                'darkGreen': '#006400', 'darkMagenta': '#8B008B', 'darkRed': '#8B0000',
-                'darkYellow': '#808000', 'darkGray': '#A9A9A9', 'lightGray': '#D3D3D3', 'black': '#000000'
-            };
-            formatting.backgroundColor = colorMap[highlightMatch[1]] || highlightMatch[1];
+        // Font size (w:sz) - stored in half-points
+        const sz = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, 'w:sz');
+        if (sz) {
+            const val = sz.getAttribute('w:val');
+            if (val) {
+                formatting.size = (parseInt(val, 10) / 2).toString() + 'pt';
+            }
         }
-        // Font family
-        const rFontsMatch = rPrString.match(/<w:rFonts[^>]*w:ascii="([^"]+)"/);
-        if (rFontsMatch) {
-            formatting.font = rFontsMatch[1];
+        // Color (w:color)
+        const color = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, 'w:color');
+        if (color) {
+            const val = color.getAttribute('w:val');
+            if (val && val !== 'auto') {
+                formatting.color = '#' + val;
+            }
         }
-        else {
-            const hAnsiMatch = rPrString.match(/<w:rFonts[^>]*w:hAnsi="([^"]+)"/);
-            if (hAnsiMatch)
-                formatting.font = hAnsiMatch[1];
+        // Background color (w:shd) - shading
+        const shd = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, 'w:shd');
+        if (shd) {
+            const val = shd.getAttribute('w:fill');
+            if (val && val !== 'auto') {
+                formatting.backgroundColor = '#' + val;
+            }
         }
-        // Subscript/Superscript
-        const vertAlignMatch = rPrString.match(/<w:vertAlign w:val="([^"]+)"/);
-        if (vertAlignMatch) {
-            if (vertAlignMatch[1] === 'subscript')
+        // Highlight (w:highlight) - maps to background color in our AST
+        const highlight = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, 'w:highlight');
+        if (highlight) {
+            const val = highlight.getAttribute('w:val');
+            if (val && val !== 'none') {
+                const colorMap = {
+                    'yellow': '#FFFF00', 'green': '#00FF00', 'cyan': '#00FFFF', 'magenta': '#FF00FF',
+                    'blue': '#0000FF', 'red': '#FF0000', 'darkBlue': '#00008B', 'darkCyan': '#008B8B',
+                    'darkGreen': '#006400', 'darkMagenta': '#8B008B', 'darkRed': '#8B0000',
+                    'darkYellow': '#808000', 'darkGray': '#A9A9A9', 'lightGray': '#D3D3D3', 'black': '#000000'
+                };
+                formatting.backgroundColor = colorMap[val] || val;
+            }
+        }
+        // Font family (w:rFonts)
+        const rFonts = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, 'w:rFonts');
+        if (rFonts) {
+            // Priority: ascii (Western) > hAnsi (High ANSI)
+            const font = rFonts.getAttribute('w:ascii') || rFonts.getAttribute('w:hAnsi');
+            if (font) {
+                formatting.font = font;
+            }
+        }
+        // Subscript/Superscript (w:vertAlign)
+        const vertAlign = (0, xmlUtils_js_1.getFirstElementByTagName)(rPr, 'w:vertAlign');
+        if (vertAlign) {
+            const val = vertAlign.getAttribute('w:val');
+            if (val === 'subscript')
                 formatting.subscript = true;
-            if (vertAlignMatch[1] === 'superscript')
+            else if (val === 'superscript')
                 formatting.superscript = true;
         }
         return formatting;
     };
+    // Helper to extract indentation from paragraph properties XML string
+    const extractIndentationFromXml = (pPr) => {
+        const ind = (0, xmlUtils_js_1.getFirstElementByTagName)(pPr, "w:ind");
+        if (ind) {
+            const indentation = {};
+            const left = ind.getAttribute("w:left") || ind.getAttribute("w:start");
+            const right = ind.getAttribute("w:right") || ind.getAttribute("w:end");
+            const firstLine = ind.getAttribute("w:firstLine");
+            const hanging = ind.getAttribute("w:hanging");
+            if (left)
+                indentation.left = parseInt(left, 10);
+            if (right)
+                indentation.right = parseInt(right, 10);
+            if (firstLine)
+                indentation.firstLine = parseInt(firstLine, 10);
+            if (hanging)
+                indentation.hanging = parseInt(hanging, 10);
+            return Object.keys(indentation).length > 0 ? indentation : undefined;
+        }
+        return undefined;
+    };
+    /**
+     * Resolves mc:AlternateContent by preferring mc:Fallback if choice namespace is not recognized,
+     * or simply the first available valid child.
+     */
+    const resolveAlternateContent = (element) => {
+        const choice = (0, xmlUtils_js_1.getFirstElementByTagName)(element, "mc:Choice");
+        // In most cases, mc:Choice contains the modern version, but mc:Fallback is safer for legacy compatibility
+        // Mammoth often skips Choice if it's not handled. We'll try Choice first.
+        if (choice)
+            return Array.from(choice.childNodes);
+        const fallback = (0, xmlUtils_js_1.getFirstElementByTagName)(element, "mc:Fallback");
+        if (fallback)
+            return Array.from(fallback.childNodes);
+        return Array.from(element.childNodes);
+    };
     const files = await (0, zipUtils_js_1.extractFiles)(buffer, x => !!x.match(documentFileRegex) ||
         !!x.match(footnotesFileRegex) ||
         !!x.match(endnotesFileRegex) ||
@@ -228,18 +282,32 @@ const parseWord = async (buffer, config) => {
             const abstractNumId = abstractNumIdNode?.getAttribute("w:val");
             if (numId && abstractNumId && abstractNumMap[abstractNumId]) {
                 numberingMap[numId] = {};
+                // Inherit from abstractNum
                 const lvls = (0, xmlUtils_js_1.getElementsByTagName)(abstractNumMap[abstractNumId], "w:lvl");
                 for (const lvl of lvls) {
                     const ilvl = lvl.getAttribute("w:ilvl");
                     const numFmtNode = (0, xmlUtils_js_1.getFirstElementByTagName)(lvl, "w:numFmt");
                     const lvlTextNode = (0, xmlUtils_js_1.getFirstElementByTagName)(lvl, "w:lvlText");
+                    const startNode = (0, xmlUtils_js_1.getFirstElementByTagName)(lvl, "w:start");
                     if (ilvl) {
                         numberingMap[numId][ilvl] = {
                             numFmt: numFmtNode?.getAttribute("w:val") || 'decimal',
-                            lvlText: lvlTextNode?.getAttribute("w:val") || ''
+                            lvlText: lvlTextNode?.getAttribute("w:val") || '',
+                            start: parseInt(startNode?.getAttribute("w:val") || '1', 10)
                         };
                     }
                 }
+                // Apply instance overrides (w:lvlOverride)
+                const overrides = (0, xmlUtils_js_1.getElementsByTagName)(num, "w:lvlOverride");
+                for (const override of overrides) {
+                    const ilvl = override.getAttribute("w:ilvl");
+                    if (ilvl && numberingMap[numId][ilvl]) {
+                        const startOverride = (0, xmlUtils_js_1.getFirstElementByTagName)(override, "w:startOverride");
+                        if (startOverride) {
+                            numberingMap[numId][ilvl].start = parseInt(startOverride.getAttribute("w:val") || '1', 10);
+                        }
+                    }
+                }
             }
         }
     }
@@ -257,6 +325,7 @@ const parseWord = async (buffer, config) => {
                 const formatting = rPr ? extractFormattingFromXml(rPr) : {};
                 let alignment = undefined;
                 let backgroundColor = undefined;
+                let paragraphIndentation = undefined;
                 if (pPr) {
                     const jc = (0, xmlUtils_js_1.getFirstElementByTagName)(pPr, "w:jc");
                     if (jc) {
@@ -271,8 +340,11 @@ const parseWord = async (buffer, config) => {
                         if (fill && fill !== 'auto')
                             backgroundColor = '#' + fill;
                     }
+                    const ind = extractIndentationFromXml(pPr);
+                    if (ind)
+                        paragraphIndentation = ind;
                 }
-                styleMap[styleId] = { formatting, alignment, backgroundColor };
+                styleMap[styleId] = { formatting, alignment, backgroundColor, paragraphIndentation };
             }
         }
     }
@@ -316,8 +388,7 @@ const parseWord = async (buffer, config) => {
     const numberingState = {};
     const listCounters = {}; // Track item index per listId/level
     // Helper to parse a paragraph node
-    const parseParagraph = (pNode, documentContent) => {
-        const pXml = pNode.toString();
+    const parseParagraph = (pNode, documentContent, pendingAnchorIds = []) => {
         // Check if it's a list item
         const numPr = (0, xmlUtils_js_1.getFirstElementByTagName)(pNode, "w:numPr");
         const isList = !!numPr;
@@ -339,6 +410,14 @@ const parseWord = async (buffer, config) => {
                 }
             }
         }
+        // Extract Indentation
+        let paraIndentation = styleProps.paragraphIndentation;
+        if (pPr) {
+            const ind = extractIndentationFromXml(pPr);
+            if (ind) {
+                paraIndentation = { ...paraIndentation, ...ind };
+            }
+        }
         // Extract Paragraph Background
         let paraBackgroundColor = styleProps.backgroundColor;
         if (pPr) {
@@ -406,26 +485,71 @@ const parseWord = async (buffer, config) => {
                 if (!formatting.backgroundColor && paraBackgroundColor) {
                     formatting.backgroundColor = paraBackgroundColor;
                 }
-                // Text content
-                const tNodes = (0, xmlUtils_js_1.getElementsByTagName)(runNode, "w:t");
-                for (const tNode of tNodes) {
-                    const tContent = tNode.textContent || '';
-                    text += tContent;
-                    const textNode = {
-                        type: 'text',
-                        text: tContent,
-                        formatting: formatting
-                    };
-                    if (config.includeRawContent) {
-                        textNode.rawContent = (0, xmlUtils_js_1.getRawContent)(tNode, documentContent, config);
+                for (const child of runNode.childNodes) {
+                    if (!(0, xmlUtils_js_1.isElement)(child))
+                        continue;
+                    // also handle unprefixed version (mirroring the behaviour of getElementsByTagName)
+                    // Text content
+                    if (child.tagName === "w:t" || child.tagName === "t") {
+                        const tNode = child;
+                        const tContent = tNode.textContent || '';
+                        text += tContent;
+                        const textNode = {
+                            type: 'text',
+                            text: tContent,
+                            formatting: formatting
+                        };
+                        if (config.includeRawContent) {
+                            textNode.rawContent = (0, xmlUtils_js_1.getRawContent)(tNode, documentContent, config);
+                        }
+                        // Always set a style: run style > paragraph style > detected default
+                        // Use detected default style for international compatibility
+                        const nodeStyle = rStyleVal || pStyleVal || defaultParaStyleId;
+                        if (nodeStyle) {
+                            textNode.metadata = { style: nodeStyle };
+                        }
+                        children.push(textNode);
+                    }
+                    // Break nodes
+                    else if (config.includeBreakNodes &&
+                        (child.tagName === "w:br"
+                            || child.tagName === "br"
+                            || child.tagName === "w:cr"
+                            || child.tagName === "cr")) {
+                        const brNode = child;
+                        let breakType = 'textWrapping';
+                        if (child.tagName === "w:cr" || child.tagName === "cr") {
+                            breakType = 'carriageReturn';
+                        }
+                        else {
+                            const nodeBreakType = brNode.getAttribute("w:type") || brNode.getAttribute("type");
+                            if (nodeBreakType !== null) {
+                                breakType = nodeBreakType;
+                            }
+                        }
+                        let breakClear = undefined;
+                        if (breakType === 'textWrapping' && brNode.getAttribute("w:clear") !== null) {
+                            breakClear = brNode.getAttribute("w:clear");
+                        }
+                        const breakNode = {
+                            type: 'break',
+                            metadata: { breakType, clear: breakClear }
+                        };
+                        if (config.includeRawContent) {
+                            breakNode.rawContent = (0, xmlUtils_js_1.getRawContent)(brNode, documentContent, config);
+                        }
+                        children.push(breakNode);
                     }
-                    // Always set a style: run style > paragraph style > detected default
-                    // Use detected default style for international compatibility
-                    const nodeStyle = rStyleVal || pStyleVal || defaultParaStyleId;
-                    if (nodeStyle) {
-                        textNode.metadata = { style: nodeStyle };
+                    else if (config.includeBreakNodes && (child.tagName === "w:lastRenderedPageBreak" || child.tagName === "lastRenderedPageBreak")) {
+                        const breakNode = {
+                            type: 'break',
+                            metadata: { breakType: 'lastRenderedPage' }
+                        };
+                        if (config.includeRawContent) {
+                            breakNode.rawContent = (0, xmlUtils_js_1.getRawContent)(child, documentContent, config);
+                        }
+                        children.push(breakNode);
                     }
-                    children.push(textNode);
                 }
                 // Images/Drawings
                 if (config.extractAttachments) {
@@ -526,7 +650,7 @@ const parseWord = async (buffer, config) => {
                 const rId = hlNode.getAttribute("r:id");
                 const anchor = hlNode.getAttribute("w:anchor");
                 let linkMetadata;
-                if (anchor) {
+                if (anchor && !config.ignoreInternalLinks) {
                     linkMetadata = { link: '#' + anchor, linkType: 'internal' };
                 }
                 else if (rId && relsMap[rId]) {
@@ -548,16 +672,48 @@ const parseWord = async (buffer, config) => {
                     }
                 }
             }
+            else if ((0, xmlUtils_js_1.isElement)(node) && node.nodeName === 'w:bookmarkStart') {
+                const bookmarkName = node.getAttribute("w:name");
+                if (bookmarkName && !bookmarkName.startsWith('_GoBack') && !config.ignoreInternalLinks) {
+                    anchorIds.push(bookmarkName);
+                }
+            }
+            else if ((0, xmlUtils_js_1.isElement)(node) && (node.nodeName === 'mc:AlternateContent' || node.nodeName === 'AlternateContent')) {
+                const resolved = resolveAlternateContent(node);
+                for (const rNode of resolved)
+                    processChildNode(rNode);
+            }
+            else if ((0, xmlUtils_js_1.isElement)(node) && (node.nodeName === 'w:pict' || node.nodeName === 'pict' || node.nodeName === 'w:drawing' || node.nodeName === 'drawing')) {
+                // Extract text boxes from legacy shapes or modern drawings
+                const textBoxes = (0, xmlUtils_js_1.getElementsByTagName)(node, "w:txbxContent");
+                for (const txbx of textBoxes) {
+                    const txbxChildren = Array.from(txbx.childNodes);
+                    for (const txbxChild of txbxChildren) {
+                        if ((0, xmlUtils_js_1.isElement)(txbxChild) && txbxChild.nodeName === 'w:p') {
+                            const nestedP = parseParagraph(txbxChild, documentContent);
+                            children.push(...(nestedP.children || []));
+                            text += nestedP.text;
+                        }
+                    }
+                }
+            }
+            else if (node.childNodes.length > 0) {
+                // Generic fallback for unknown elements that might contain content
+                for (const child of Array.from(node.childNodes))
+                    processChildNode(child);
+            }
         };
+        const anchorIds = [...pendingAnchorIds];
         const childNodes = Array.from(pNode.childNodes);
         for (const child of childNodes) {
             processChildNode(child);
         }
+        const commonMetadata = anchorIds.length > 0 ? { anchorIds } : {};
         if (isList) {
             const numIdNode = (0, xmlUtils_js_1.getFirstElementByTagName)(numPr, "w:numId");
             const ilvlNode = (0, xmlUtils_js_1.getFirstElementByTagName)(numPr, "w:ilvl");
             const numId = numIdNode ? numIdNode.getAttribute("w:val") || '0' : '0';
-            const ilvl = ilvlNode ? parseInt(ilvlNode.getAttribute("w:val") || '0') : 0;
+            const ilvl = ilvlNode ? parseInt(ilvlNode.getAttribute("w:val") || '0', 10) : 0;
             let listType = 'ordered';
             let itemIndex = 0;
             if (numId && numberingMap[numId]) {
@@ -573,11 +729,11 @@ const parseWord = async (buffer, config) => {
                 }
                 const numFmt = numberingMap[numId][ilvlStr]?.numFmt || 'decimal';
                 listType = numFmt === 'bullet' ? 'unordered' : 'ordered';
-                // Track itemIndex (starts at 0, continues across interruptions for same listId)
+                // Track itemIndex (starts at override or default, continues across interruptions for same listId)
                 if (!listCounters[numId])
                     listCounters[numId] = {};
                 if (listCounters[numId][ilvlStr] === undefined) {
-                    listCounters[numId][ilvlStr] = 0;
+                    listCounters[numId][ilvlStr] = (numberingMap[numId][ilvlStr]?.start ?? 1) - 1;
                 }
                 else {
                     listCounters[numId][ilvlStr]++;
@@ -591,10 +747,12 @@ const parseWord = async (buffer, config) => {
                 metadata: {
                     listType,
                     indentation: ilvl,
+                    paragraphIndentation: paraIndentation,
                     alignment: (alignment || 'left'),
                     listId: numId,
                     itemIndex: itemIndex,
-                    style: pStyleVal
+                    style: pStyleVal,
+                    ...commonMetadata
                 }
             };
             if (config.includeRawContent)
@@ -602,12 +760,12 @@ const parseWord = async (buffer, config) => {
             return listNode;
         }
         else if (isHeading) {
-            const level = pStyleVal ? parseInt(pStyleVal.replace("Heading", "")) || 1 : 1;
+            const level = pStyleVal ? parseInt(pStyleVal.replace("Heading", ""), 10) || 1 : 1;
             const headingNode = {
                 type: 'heading',
                 text: text,
                 children: children,
-                metadata: { level, alignment, style: pStyleVal ?? undefined }
+                metadata: { level, alignment, paragraphIndentation: paraIndentation, style: pStyleVal ?? undefined, ...commonMetadata }
             };
             if (config.includeRawContent)
                 headingNode.rawContent = (0, xmlUtils_js_1.getRawContent)(pNode, documentContent, config);
@@ -618,7 +776,7 @@ const parseWord = async (buffer, config) => {
                 type: 'paragraph',
                 text: text,
                 children: children,
-                metadata: { alignment, style: pStyleVal ?? undefined }
+                metadata: { alignment, paragraphIndentation: paraIndentation, style: pStyleVal ?? undefined, ...commonMetadata }
             };
             if (config.includeRawContent)
                 paraNode.rawContent = (0, xmlUtils_js_1.getRawContent)(pNode, documentContent, config);
@@ -626,17 +784,41 @@ const parseWord = async (buffer, config) => {
         }
     };
     // Helper to parse a table node
-    const parseTable = (tblNode, documentContent) => {
+    const parseTable = (tblNode, documentContent, pendingAnchorIds = []) => {
         const rows = [];
-        // Only get direct child rows, not nested table rows
         const trNodes = (0, xmlUtils_js_1.getDirectChildren)(tblNode, "w:tr");
+        // Track vertical merges: colIndex -> { startCellNode, rowSpan }
+        const vMergeMap = new Map();
         for (let rIndex = 0; rIndex < trNodes.length; rIndex++) {
             const trNode = trNodes[rIndex];
             const cells = [];
             // Only get direct child cells, not nested table cells
             const tcNodes = (0, xmlUtils_js_1.getDirectChildren)(trNode, "w:tc");
-            for (let cIndex = 0; cIndex < tcNodes.length; cIndex++) {
-                const tcNode = tcNodes[cIndex];
+            let visualCol = 0;
+            for (let tcIndex = 0; tcIndex < tcNodes.length; tcIndex++) {
+                const tcNode = tcNodes[tcIndex];
+                const tcPr = (0, xmlUtils_js_1.getFirstElementByTagName)(tcNode, "w:tcPr");
+                // Horizontal merge (colspan)
+                let colSpan = 1;
+                if (tcPr) {
+                    const gridSpan = (0, xmlUtils_js_1.getFirstElementByTagName)(tcPr, "w:gridSpan");
+                    if (gridSpan) {
+                        colSpan = parseInt(gridSpan.getAttribute("w:val") || "1", 10);
+                    }
+                }
+                let vMergeRestart = false;
+                let isVMerge = false;
+                if (tcPr) {
+                    const vMerge = (0, xmlUtils_js_1.getFirstElementByTagName)(tcPr, "w:vMerge");
+                    if (vMerge) {
+                        isVMerge = true;
+                        const val = vMerge.getAttribute("w:val");
+                        // If it's explicit restart, or if we don't have an active merge for this column, treat as restart
+                        if (val === "restart" || !vMergeMap.has(visualCol)) {
+                            vMergeRestart = true;
+                        }
+                    }
+                }
                 const cellChildren = [];
                 let cellText = '';
                 // Cells contain paragraphs (and other block-level elements)
@@ -648,23 +830,50 @@ const parseWord = async (buffer, config) => {
                         cellText += pNode.text;
                     }
                     else if ((0, xmlUtils_js_1.isElement)(child) && child.nodeName === 'w:tbl') {
-                        // Nested table
                         const nestedTable = parseTable(child, documentContent);
                         cellChildren.push(nestedTable);
-                        // Don't add nested table text to cell text - it will be handled recursively
                     }
                 }
                 const cellNode = {
                     type: 'cell',
                     text: cellText,
                     children: cellChildren,
-                    metadata: { row: rIndex, col: cIndex }
+                    metadata: { row: rIndex, col: visualCol }
                 };
-                cells.push(cellNode);
+                if (colSpan > 1)
+                    cellNode.metadata.colSpan = colSpan;
+                if (isVMerge) {
+                    if (vMergeRestart) {
+                        vMergeMap.set(visualCol, { node: cellNode, span: 1 });
+                        cells.push(cellNode);
+                    }
+                    else {
+                        const mergeInfo = vMergeMap.get(visualCol);
+                        if (mergeInfo) {
+                            mergeInfo.span++;
+                            mergeInfo.node.metadata.rowSpan = mergeInfo.span;
+                            if (cellChildren.length > 0) {
+                                if (!mergeInfo.node.children)
+                                    mergeInfo.node.children = [];
+                                mergeInfo.node.children.push(...cellChildren);
+                                mergeInfo.node.text += " " + cellText;
+                            }
+                        }
+                        else {
+                            // Fallback: if we found a continue but no restart, treat as normal cell
+                            cells.push(cellNode);
+                        }
+                    }
+                }
+                else {
+                    vMergeMap.delete(visualCol);
+                    cells.push(cellNode);
+                }
+                visualCol += colSpan;
             }
             const rowNode = {
                 type: 'row',
-                children: cells
+                children: cells,
             };
             rows.push(rowNode);
         }
@@ -723,12 +932,23 @@ const parseWord = async (buffer, config) => {
         const body = (0, xmlUtils_js_1.getFirstElementByTagName)(doc, "w:body");
         if (body) {
             const bodyChildren = Array.from(body.childNodes);
+            let pendingAnchorIds = [];
             for (const child of bodyChildren) {
-                if ((0, xmlUtils_js_1.isElement)(child) && child.nodeName === 'w:p') {
-                    content.push(parseParagraph(child, documentContent));
-                }
-                else if ((0, xmlUtils_js_1.isElement)(child) && child.nodeName === 'w:tbl') {
-                    content.push(parseTable(child, documentContent));
+                if ((0, xmlUtils_js_1.isElement)(child)) {
+                    if (child.nodeName === 'w:p') {
+                        content.push(parseParagraph(child, documentContent, pendingAnchorIds));
+                        pendingAnchorIds = [];
+                    }
+                    else if (child.nodeName === 'w:tbl') {
+                        content.push(parseTable(child, documentContent, pendingAnchorIds));
+                        pendingAnchorIds = [];
+                    }
+                    else if (child.nodeName === 'w:bookmarkStart') {
+                        const bookmarkName = child.getAttribute("w:name");
+                        if (bookmarkName && !bookmarkName.startsWith('_GoBack') && !config.ignoreInternalLinks) {
+                            pendingAnchorIds.push(bookmarkName);
+                        }
+                    }
                 }
             }
         }
@@ -741,10 +961,10 @@ const parseWord = async (buffer, config) => {
             if (config.ocr) {
                 if (attachment.mimeType.startsWith('image/')) {
                     try {
-                        attachment.ocrText = (await (0, ocrUtils_js_1.performOcr)(media.content, { language: config.ocrLanguage, ...config.ocrConfig })).trim();
+                        attachment.ocrText = (await (0, ocrUtils_js_1.performOcr)(media.content, { ...config.ocrConfig })).trim();
                     }
                     catch (e) {
-                        (0, errorUtils_js_1.logWarning)(`OCR failed for ${attachment.name}:`, config, e);
+                        (0, errorUtils_js_1.logWarning)(types_js_1.OfficeWarningType.OCR_FAILED, config, attachment.name, e);
                     }
                 }
             }
@@ -772,24 +992,22 @@ const parseWord = async (buffer, config) => {
     if (config.putNotesAtLast && collectedNotes.length > 0) {
         content.push(...collectedNotes);
     }
-    return {
-        type: 'docx',
-        metadata: { ...metadata, formatting: docDefaults, styleMap: styleMap },
-        content: content,
-        attachments: attachments,
-        toText: () => content.map(c => {
-            // Recursive text extraction
-            const getText = (node) => {
-                let t = '';
-                if (node.children) {
-                    t += node.children.map(getText).filter(t => t != '').join(!node.children[0]?.children ? '' : config.newlineDelimiter ?? '\n');
-                }
-                else
-                    t += node.text || '';
-                return t;
-            };
-            return getText(c);
-        }).filter(t => t != '').join(config.newlineDelimiter ?? '\n')
-    };
+    const toTextSync = () => content.map(c => {
+        // Recursive text extraction
+        const getText = (node) => {
+            let t = '';
+            if (node.children) {
+                t += node.children.map(getText).filter(t => t != '').join(!node.children[0]?.children ? '' : config.newlineDelimiter);
+            }
+            else if (node.type === 'break') {
+                t += config.newlineDelimiter;
+            }
+            else
+                t += node.text || '';
+            return t;
+        };
+        return getText(c);
+    }).filter(t => t != '').join(config.newlineDelimiter);
+    return (0, astUtils_js_1.createAST)('docx', { ...metadata, formatting: docDefaults, styleMap: styleMap }, content, attachments, config, toTextSync);
 };
 exports.parseWord = parseWord;