officeparser 6.1.1 → 7.0.1

package/dist/parsers/WordParser.d.ts

@@ -59,7 +59,7 @@
  * @see https://www.ecma-international.org/publications-and-standards/standards/ecma-376/ OOXML Standard
  * @see https://learn.microsoft.com/en-us/openspecs/office_standards/ms-docx/ [MS-DOCX] Specification
  */
-import { OfficeParserAST, OfficeParserConfig } from '../types.js';
+import { FullOfficeParserConfig, OfficeParserAST } from '../types.js';
 /**
  * Parses a Word document (.docx) and extracts content, formatting, and metadata.
  *
@@ -76,4 +76,4 @@ import { OfficeParserAST, OfficeParserConfig } from '../types.js';
  * @param config - Parser configuration options
  * @returns A promise resolving to the parsed AST
  */
-export declare const parseWord: (buffer: Buffer, config: OfficeParserConfig) => Promise<OfficeParserAST>;
+export declare const parseWord: (buffer: Buffer, config: FullOfficeParserConfig) => Promise<OfficeParserAST>;

package/dist/parsers/WordParser.js

@@ -62,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");
@@ -96,79 +98,94 @@ 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], 10) / 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;
@@ -194,6 +211,21 @@ const parseWord = async (buffer, config) => {
         }
         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) ||
@@ -250,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);
+                        }
+                    }
+                }
             }
         }
     }
@@ -342,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;
@@ -605,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]) {
@@ -627,11 +672,43 @@ 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");
@@ -652,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]++;
@@ -674,7 +751,8 @@ const parseWord = async (buffer, config) => {
                     alignment: (alignment || 'left'),
                     listId: numId,
                     itemIndex: itemIndex,
-                    style: pStyleVal
+                    style: pStyleVal,
+                    ...commonMetadata
                 }
             };
             if (config.includeRawContent)
@@ -687,7 +765,7 @@ const parseWord = async (buffer, config) => {
                 type: 'heading',
                 text: text,
                 children: children,
-                metadata: { level, alignment, paragraphIndentation: paraIndentation, 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);
@@ -698,7 +776,7 @@ const parseWord = async (buffer, config) => {
                 type: 'paragraph',
                 text: text,
                 children: children,
-                metadata: { alignment, paragraphIndentation: paraIndentation, style: pStyleVal ?? undefined }
+                metadata: { alignment, paragraphIndentation: paraIndentation, style: pStyleVal ?? undefined, ...commonMetadata }
             };
             if (config.includeRawContent)
                 paraNode.rawContent = (0, xmlUtils_js_1.getRawContent)(pNode, documentContent, config);
@@ -706,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)
@@ -728,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);
         }
@@ -803,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);
+                        }
+                    }
                 }
             }
         }
@@ -821,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);
                     }
                 }
             }
@@ -852,27 +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 if (node.type === 'break') {
-                    t += 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;