docxmlater 1.5.0 → 1.7.0

package/dist/core/Document.js

@@ -753,6 +753,97 @@ class Document {
         }
         return count;
     }
+    applyStandardTableFormatting(shadingColorOrOptions) {
+        const options = typeof shadingColorOrOptions === 'string'
+            ? { headerRowShading: shadingColorOrOptions }
+            : shadingColorOrOptions;
+        const autofitToWindow = options?.autofitToWindow !== false;
+        const headerRowShading = (options?.headerRowShading || 'E9E9E9').toUpperCase();
+        const headerRowFormatting = {
+            bold: options?.headerRowFormatting?.bold !== false,
+            alignment: options?.headerRowFormatting?.alignment || 'center',
+            font: options?.headerRowFormatting?.font || 'Verdana',
+            size: options?.headerRowFormatting?.size || 12,
+            color: options?.headerRowFormatting?.color || '000000',
+            spacingBefore: options?.headerRowFormatting?.spacingBefore ?? 60,
+            spacingAfter: options?.headerRowFormatting?.spacingAfter ?? 60,
+        };
+        const cellMargins = {
+            top: options?.cellMargins?.top ?? 0,
+            bottom: options?.cellMargins?.bottom ?? 0,
+            left: options?.cellMargins?.left ?? 115,
+            right: options?.cellMargins?.right ?? 115,
+        };
+        const skipSingleCellTables = options?.skipSingleCellTables !== false;
+        const conditionalReplacementColor = options?.conditionalShading?.replacementColor || headerRowShading;
+        let tablesProcessed = 0;
+        let headerRowsFormatted = 0;
+        let cellsRecolored = 0;
+        const tables = this.getAllTables();
+        for (const table of tables) {
+            const rowCount = table.getRowCount();
+            const columnCount = table.getColumnCount();
+            if (skipSingleCellTables && rowCount === 1 && columnCount === 1) {
+                continue;
+            }
+            if (autofitToWindow) {
+                table.setLayout('auto');
+            }
+            const firstRow = table.getRow(0);
+            if (firstRow) {
+                for (const cell of firstRow.getCells()) {
+                    cell.setShading({ fill: headerRowShading });
+                    cell.setMargins(cellMargins);
+                    for (const para of cell.getParagraphs()) {
+                        para.setAlignment(headerRowFormatting.alignment);
+                        para.setSpaceBefore(headerRowFormatting.spacingBefore);
+                        para.setSpaceAfter(headerRowFormatting.spacingAfter);
+                        for (const run of para.getRuns()) {
+                            if (headerRowFormatting.bold)
+                                run.setBold(true);
+                            run.setFont(headerRowFormatting.font, headerRowFormatting.size);
+                            run.setColor(headerRowFormatting.color);
+                        }
+                    }
+                }
+                headerRowsFormatted++;
+            }
+            for (let i = 1; i < rowCount; i++) {
+                const row = table.getRow(i);
+                if (!row)
+                    continue;
+                for (const cell of row.getCells()) {
+                    cell.setMargins(cellMargins);
+                    const currentShading = cell.getFormatting().shading;
+                    const currentColor = currentShading?.fill?.toUpperCase();
+                    if (currentColor &&
+                        currentColor !== 'FFFFFF' &&
+                        currentColor !== headerRowShading) {
+                        cell.setShading({ fill: conditionalReplacementColor });
+                        cellsRecolored++;
+                        const applyFormatting = options?.conditionalShading?.applyFormatting !== false;
+                        if (applyFormatting) {
+                            for (const para of cell.getParagraphs()) {
+                                para.setAlignment('center');
+                                para.setSpaceBefore(60);
+                                para.setSpaceAfter(60);
+                                for (const run of para.getRuns()) {
+                                    run.setBold(true);
+                                    run.setFont('Verdana', 12);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            tablesProcessed++;
+        }
+        return {
+            tablesProcessed,
+            headerRowsFormatted,
+            cellsRecolored,
+        };
+    }
     centerLargeImages(minPixels = 100) {
         let count = 0;
         const minEmus = Math.round(minPixels * 9525);
@@ -962,6 +1053,32 @@ class Document {
         }
         return count;
     }
+    applyStandardNumberedListFormatting() {
+        const instances = this.numberingManager.getAllInstances();
+        let count = 0;
+        for (const instance of instances) {
+            const abstractNumId = instance.getAbstractNumId();
+            const abstractNum = this.numberingManager.getAbstractNumbering(abstractNumId);
+            if (!abstractNum)
+                continue;
+            const level0 = abstractNum.getLevel(0);
+            if (!level0 || level0.getFormat() === 'bullet')
+                continue;
+            for (let levelIndex = 0; levelIndex < 9; levelIndex++) {
+                const numLevel = abstractNum.getLevel(levelIndex);
+                if (!numLevel)
+                    continue;
+                numLevel.setFont('Verdana');
+                numLevel.setFontSize(24);
+                numLevel.setLeftIndent(720 * (levelIndex + 1));
+                numLevel.setHangingIndent(360);
+                numLevel.setAlignment('left');
+            }
+            this.applyFormattingToListParagraphs(instance.getNumId());
+            count++;
+        }
+        return count;
+    }
     applyFormattingToListParagraphs(numId) {
         const paragraphs = this.getAllParagraphs();
         for (const para of paragraphs) {
@@ -1132,76 +1249,168 @@ class Document {
         }
         return counts;
     }
-    applyCustomFormattingToExistingStyles() {
+    static DEFAULT_HEADING1_CONFIG = {
+        run: {
+            font: 'Verdana',
+            size: 18,
+            bold: true,
+            color: '000000',
+        },
+        paragraph: {
+            alignment: 'left',
+            spacing: { before: 0, after: 240, line: 240, lineRule: 'auto' },
+        },
+    };
+    static DEFAULT_HEADING2_CONFIG = {
+        run: {
+            font: 'Verdana',
+            size: 14,
+            bold: true,
+            color: '000000',
+        },
+        paragraph: {
+            alignment: 'left',
+            spacing: { before: 120, after: 120, line: 240, lineRule: 'auto' },
+        },
+        tableOptions: {
+            shading: 'BFBFBF',
+            marginTop: 0,
+            marginBottom: 0,
+            marginLeft: 115,
+            marginRight: 115,
+            tableWidthPercent: 5000,
+        },
+    };
+    static DEFAULT_HEADING3_CONFIG = {
+        run: {
+            font: 'Verdana',
+            size: 12,
+            bold: true,
+            color: '000000',
+        },
+        paragraph: {
+            alignment: 'left',
+            spacing: { before: 60, after: 60, line: 240, lineRule: 'auto' },
+        },
+    };
+    static DEFAULT_NORMAL_CONFIG = {
+        run: {
+            font: 'Verdana',
+            size: 12,
+            color: '000000',
+        },
+        paragraph: {
+            alignment: 'left',
+            spacing: { before: 60, after: 60, line: 240, lineRule: 'auto' },
+        },
+    };
+    static DEFAULT_LIST_PARAGRAPH_CONFIG = {
+        run: {
+            font: 'Verdana',
+            size: 12,
+            color: '000000',
+        },
+        paragraph: {
+            alignment: 'left',
+            spacing: { before: 0, after: 60, line: 240, lineRule: 'auto' },
+            indentation: { left: 360, hanging: 360 },
+            contextualSpacing: true,
+        },
+    };
+    applyCustomFormattingToExistingStyles(options) {
         const results = { heading1: false, heading2: false, heading3: false, normal: false, listParagraph: false };
         const heading1 = this.stylesManager.getStyle('Heading1');
         const heading2 = this.stylesManager.getStyle('Heading2');
         const heading3 = this.stylesManager.getStyle('Heading3');
         const normal = this.stylesManager.getStyle('Normal');
         const listParagraph = this.stylesManager.getStyle('ListParagraph');
-        if (heading1) {
-            heading1.setRunFormatting({
-                font: 'Verdana',
-                size: 18,
-                bold: true,
-                color: '000000'
-            });
-            heading1.setParagraphFormatting({
-                alignment: 'left',
-                spacing: { before: 0, after: 240, line: 240, lineRule: 'auto' }
-            });
+        const h1Config = {
+            run: {
+                ...(heading1?.getRunFormatting() || Document.DEFAULT_HEADING1_CONFIG.run),
+                ...options?.heading1?.run
+            },
+            paragraph: {
+                ...(heading1?.getParagraphFormatting() || Document.DEFAULT_HEADING1_CONFIG.paragraph),
+                ...options?.heading1?.paragraph
+            },
+        };
+        const h2Config = {
+            run: {
+                ...(heading2?.getRunFormatting() || Document.DEFAULT_HEADING2_CONFIG.run),
+                ...options?.heading2?.run
+            },
+            paragraph: {
+                ...(heading2?.getParagraphFormatting() || Document.DEFAULT_HEADING2_CONFIG.paragraph),
+                ...options?.heading2?.paragraph
+            },
+            tableOptions: {
+                ...Document.DEFAULT_HEADING2_CONFIG.tableOptions,
+                ...options?.heading2?.tableOptions
+            },
+        };
+        const h3Config = {
+            run: {
+                ...(heading3?.getRunFormatting() || Document.DEFAULT_HEADING3_CONFIG.run),
+                ...options?.heading3?.run
+            },
+            paragraph: {
+                ...(heading3?.getParagraphFormatting() || Document.DEFAULT_HEADING3_CONFIG.paragraph),
+                ...options?.heading3?.paragraph
+            },
+        };
+        const normalConfig = {
+            run: {
+                ...(normal?.getRunFormatting() || Document.DEFAULT_NORMAL_CONFIG.run),
+                ...options?.normal?.run
+            },
+            paragraph: {
+                ...(normal?.getParagraphFormatting() || Document.DEFAULT_NORMAL_CONFIG.paragraph),
+                ...options?.normal?.paragraph
+            },
+        };
+        const listParaConfig = {
+            run: {
+                ...(listParagraph?.getRunFormatting() || Document.DEFAULT_LIST_PARAGRAPH_CONFIG.run),
+                ...options?.listParagraph?.run
+            },
+            paragraph: {
+                ...(listParagraph?.getParagraphFormatting() || Document.DEFAULT_LIST_PARAGRAPH_CONFIG.paragraph),
+                ...options?.listParagraph?.paragraph
+            },
+        };
+        if (heading1 && h1Config.run && h1Config.paragraph) {
+            if (h1Config.run)
+                heading1.setRunFormatting(h1Config.run);
+            if (h1Config.paragraph)
+                heading1.setParagraphFormatting(h1Config.paragraph);
             results.heading1 = true;
         }
-        if (heading2) {
-            heading2.setRunFormatting({
-                font: 'Verdana',
-                size: 14,
-                bold: true,
-                color: '000000'
-            });
-            heading2.setParagraphFormatting({
-                alignment: 'left',
-                spacing: { before: 120, after: 120, line: 240, lineRule: 'auto' }
-            });
+        if (heading2 && h2Config.run && h2Config.paragraph) {
+            if (h2Config.run)
+                heading2.setRunFormatting(h2Config.run);
+            if (h2Config.paragraph)
+                heading2.setParagraphFormatting(h2Config.paragraph);
             results.heading2 = true;
         }
-        if (heading3) {
-            heading3.setRunFormatting({
-                font: 'Verdana',
-                size: 12,
-                bold: true,
-                color: '000000'
-            });
-            heading3.setParagraphFormatting({
-                alignment: 'left',
-                spacing: { before: 60, after: 60, line: 240, lineRule: 'auto' }
-            });
+        if (heading3 && h3Config.run && h3Config.paragraph) {
+            if (h3Config.run)
+                heading3.setRunFormatting(h3Config.run);
+            if (h3Config.paragraph)
+                heading3.setParagraphFormatting(h3Config.paragraph);
             results.heading3 = true;
         }
-        if (normal) {
-            normal.setRunFormatting({
-                font: 'Verdana',
-                size: 12,
-                color: '000000'
-            });
-            normal.setParagraphFormatting({
-                alignment: 'left',
-                spacing: { before: 60, after: 60, line: 240, lineRule: 'auto' }
-            });
+        if (normal && normalConfig.run && normalConfig.paragraph) {
+            if (normalConfig.run)
+                normal.setRunFormatting(normalConfig.run);
+            if (normalConfig.paragraph)
+                normal.setParagraphFormatting(normalConfig.paragraph);
             results.normal = true;
         }
-        if (listParagraph) {
-            listParagraph.setRunFormatting({
-                font: 'Verdana',
-                size: 12,
-                color: '000000'
-            });
-            listParagraph.setParagraphFormatting({
-                alignment: 'left',
-                spacing: { before: 0, after: 60, line: 240, lineRule: 'auto' },
-                indentation: { left: 360, hanging: 360 },
-                contextualSpacing: true
-            });
+        if (listParagraph && listParaConfig.run && listParaConfig.paragraph) {
+            if (listParaConfig.run)
+                listParagraph.setRunFormatting(listParaConfig.run);
+            if (listParaConfig.paragraph)
+                listParagraph.setParagraphFormatting(listParaConfig.paragraph);
             results.listParagraph = true;
         }
         const processedParagraphs = new Set();
@@ -1240,30 +1449,42 @@ class Document {
                 }
                 const { inTable, cell } = this.isParagraphInTable(para);
                 if (inTable && cell) {
-                    cell.setShading({ fill: 'BFBFBF' });
-                    cell.setMargins({ top: 0, bottom: 0, left: 115, right: 115 });
-                    const table = this.getAllTables().find(t => {
-                        for (const row of t.getRows()) {
-                            for (const c of row.getCells()) {
-                                if (c === cell)
-                                    return true;
+                    if (h2Config.tableOptions?.shading) {
+                        cell.setShading({ fill: h2Config.tableOptions.shading });
+                    }
+                    if (h2Config.tableOptions?.marginTop !== undefined || h2Config.tableOptions?.marginBottom !== undefined ||
+                        h2Config.tableOptions?.marginLeft !== undefined || h2Config.tableOptions?.marginRight !== undefined) {
+                        cell.setMargins({
+                            top: h2Config.tableOptions.marginTop ?? 0,
+                            bottom: h2Config.tableOptions.marginBottom ?? 0,
+                            left: h2Config.tableOptions.marginLeft ?? 115,
+                            right: h2Config.tableOptions.marginRight ?? 115,
+                        });
+                    }
+                    if (h2Config.tableOptions?.tableWidthPercent) {
+                        const table = this.getAllTables().find(t => {
+                            for (const row of t.getRows()) {
+                                for (const c of row.getCells()) {
+                                    if (c === cell)
+                                        return true;
+                                }
                             }
+                            return false;
+                        });
+                        if (table) {
+                            table.setWidth(h2Config.tableOptions.tableWidthPercent);
+                            table.setWidthType('pct');
                         }
-                        return false;
-                    });
-                    if (table) {
-                        table.setWidth(5000);
-                        table.setWidthType('pct');
                     }
                 }
                 else {
                     this.wrapParagraphInTable(para, {
-                        shading: 'BFBFBF',
-                        marginTop: 0,
-                        marginBottom: 0,
-                        marginLeft: 115,
-                        marginRight: 115,
-                        tableWidthPercent: 5000
+                        shading: h2Config.tableOptions?.shading ?? 'BFBFBF',
+                        marginTop: h2Config.tableOptions?.marginTop ?? 0,
+                        marginBottom: h2Config.tableOptions?.marginBottom ?? 0,
+                        marginLeft: h2Config.tableOptions?.marginLeft ?? 115,
+                        marginRight: h2Config.tableOptions?.marginRight ?? 115,
+                        tableWidthPercent: h2Config.tableOptions?.tableWidthPercent ?? 5000,
                     });
                 }
                 processedParagraphs.add(para);
@@ -1305,23 +1526,234 @@ class Document {
                 processedParagraphs.add(para);
             }
         }
-        const hyperlinks = this.getHyperlinks();
-        for (const { hyperlink, paragraph } of hyperlinks) {
-            const text = hyperlink.getText().trim();
-            if (text === 'Top of the Document' || text === 'Top of Document') {
-                paragraph.setAlignment('right');
-                paragraph.setSpaceBefore(0);
-                paragraph.setSpaceAfter(0);
+        return results;
+    }
+    applyStylesFromObjects(...styles) {
+        const options = {};
+        for (const style of styles) {
+            const styleId = style.getStyleId();
+            switch (styleId) {
+                case 'Heading1':
+                    options.heading1 = {
+                        run: style.getRunFormatting(),
+                        paragraph: style.getParagraphFormatting(),
+                    };
+                    break;
+                case 'Heading2':
+                    options.heading2 = {
+                        run: style.getRunFormatting(),
+                        paragraph: style.getParagraphFormatting(),
+                        tableOptions: style.getHeading2TableOptions(),
+                    };
+                    break;
+                case 'Heading3':
+                    options.heading3 = {
+                        run: style.getRunFormatting(),
+                        paragraph: style.getParagraphFormatting(),
+                    };
+                    break;
+                case 'Normal':
+                    options.normal = {
+                        run: style.getRunFormatting(),
+                        paragraph: style.getParagraphFormatting(),
+                    };
+                    break;
+                case 'ListParagraph':
+                    options.listParagraph = {
+                        run: style.getRunFormatting(),
+                        paragraph: style.getParagraphFormatting(),
+                    };
+                    break;
+                default:
+                    break;
+            }
+        }
+        return this.applyCustomFormattingToExistingStyles(options);
+    }
+    parseTOCFieldInstruction(instrText) {
+        const levels = new Set();
+        const outlineMatch = instrText.match(/\\o\s+"(\d+)-(\d+)"/);
+        if (outlineMatch && outlineMatch[1] && outlineMatch[2]) {
+            const start = parseInt(outlineMatch[1], 10);
+            const end = parseInt(outlineMatch[2], 10);
+            for (let i = start; i <= end; i++) {
+                if (i >= 1 && i <= 9) {
+                    levels.add(i);
+                }
+            }
+        }
+        const styleMatches = instrText.matchAll(/\\t\s+"([^"]+)",(\d+),"/g);
+        for (const match of styleMatches) {
+            const styleName = match[1];
+            const levelStr = match[2];
+            if (!styleName || !levelStr)
+                continue;
+            const level = parseInt(levelStr, 10);
+            const headingMatch = styleName.match(/Heading\s*(\d+)/i);
+            if (headingMatch && headingMatch[1]) {
+                const headingLevel = parseInt(headingMatch[1], 10);
+                if (headingLevel >= 1 && headingLevel <= 9) {
+                    levels.add(headingLevel);
+                }
+            }
+            else if (level >= 1 && level <= 9) {
+                levels.add(level);
             }
         }
-        this.updateAllHyperlinkColors('0000FF');
-        const tocElements = this.getTableOfContentsElements();
-        for (const tocElement of tocElements) {
-            const toc = tocElement.getTableOfContents();
-            toc.setShowPageNumbers(false);
-            toc.setHideInWebLayout(true);
+        if (levels.size === 0) {
+            return [1, 2, 3];
         }
-        return results;
+        return Array.from(levels).sort((a, b) => a - b);
+    }
+    findHeadingsForTOC(levels) {
+        const headings = [];
+        const levelSet = new Set(levels);
+        for (const element of this.bodyElements) {
+            if (element instanceof Paragraph_1.Paragraph) {
+                const para = element;
+                const formatting = para.getFormatting();
+                if (formatting.style) {
+                    const styleMatch = formatting.style.match(/Heading(\d+)/i);
+                    if (styleMatch && styleMatch[1]) {
+                        const headingLevel = parseInt(styleMatch[1], 10);
+                        if (levelSet.has(headingLevel)) {
+                            const text = para.getText().trim();
+                            if (text) {
+                                const bookmark = this.bookmarkManager.createHeadingBookmark(text);
+                                headings.push({
+                                    level: headingLevel,
+                                    text: text,
+                                    bookmark: bookmark.getName()
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return headings;
+    }
+    generateTOCXML(headings, originalInstrText) {
+        const sdtId = Math.floor(Math.random() * 2000000000) - 1000000000;
+        let tocXml = '<w:sdt>';
+        tocXml += '<w:sdtPr>';
+        tocXml += `<w:id w:val="${sdtId}"/>`;
+        tocXml += '<w:docPartObj>';
+        tocXml += '<w:docPartGallery w:val="Table of Contents"/>';
+        tocXml += '<w:docPartUnique w:val="1"/>';
+        tocXml += '</w:docPartObj>';
+        tocXml += '</w:sdtPr>';
+        tocXml += '<w:sdtContent>';
+        tocXml += '<w:p>';
+        tocXml += '<w:pPr>';
+        tocXml += '<w:spacing w:after="0" w:before="0" w:line="240" w:lineRule="auto"/>';
+        tocXml += '</w:pPr>';
+        tocXml += '<w:r><w:fldChar w:fldCharType="begin"/></w:r>';
+        tocXml += '<w:r>';
+        tocXml += `<w:instrText xml:space="preserve">${this.escapeXml(originalInstrText)}</w:instrText>`;
+        tocXml += '</w:r>';
+        tocXml += '<w:r><w:fldChar w:fldCharType="separate"/></w:r>';
+        if (headings.length > 0 && headings[0]) {
+            tocXml += this.buildTOCEntryXML(headings[0]);
+        }
+        tocXml += '</w:p>';
+        for (let i = 1; i < headings.length; i++) {
+            const heading = headings[i];
+            if (!heading)
+                continue;
+            tocXml += '<w:p>';
+            tocXml += '<w:pPr>';
+            tocXml += '<w:spacing w:after="0" w:before="0" w:line="240" w:lineRule="auto"/>';
+            const indent = (heading.level - 1) * 720;
+            if (indent > 0) {
+                tocXml += `<w:ind w:left="${indent}"/>`;
+            }
+            tocXml += '</w:pPr>';
+            tocXml += this.buildTOCEntryXML(heading);
+            tocXml += '</w:p>';
+        }
+        tocXml += '<w:p>';
+        tocXml += '<w:pPr>';
+        tocXml += '<w:spacing w:after="0" w:before="0" w:line="240" w:lineRule="auto"/>';
+        tocXml += '</w:pPr>';
+        tocXml += '<w:r><w:fldChar w:fldCharType="end"/></w:r>';
+        tocXml += '</w:p>';
+        tocXml += '</w:sdtContent>';
+        tocXml += '</w:sdt>';
+        return tocXml;
+    }
+    buildTOCEntryXML(heading) {
+        const escapedText = this.escapeXml(heading.text);
+        let xml = '';
+        xml += `<w:hyperlink w:anchor="${this.escapeXml(heading.bookmark)}">`;
+        xml += '<w:r>';
+        xml += '<w:rPr>';
+        xml += '<w:rFonts w:ascii="Verdana" w:hAnsi="Verdana" w:cs="Verdana" w:eastAsia="Verdana"/>';
+        xml += '<w:color w:val="0000FF"/>';
+        xml += '<w:sz w:val="24"/>';
+        xml += '<w:szCs w:val="24"/>';
+        xml += '<w:u w:val="single"/>';
+        xml += '</w:rPr>';
+        xml += `<w:t xml:space="preserve">${escapedText}</w:t>`;
+        xml += '</w:r>';
+        xml += '</w:hyperlink>';
+        return xml;
+    }
+    escapeXml(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+    async replaceTableOfContents(filePath) {
+        const handler = new ZipHandler_1.ZipHandler();
+        await handler.load(filePath);
+        const docXml = handler.getFileAsString('word/document.xml');
+        if (!docXml) {
+            throw new Error('word/document.xml not found in document');
+        }
+        const tocRegex = /<w:sdt>[\s\S]*?<w:docPartGallery w:val="Table of Contents"[\s\S]*?<\/w:sdt>/g;
+        const tocMatches = Array.from(docXml.matchAll(tocRegex));
+        if (tocMatches.length === 0) {
+            return 0;
+        }
+        let replacedCount = 0;
+        let modifiedXml = docXml;
+        for (const match of tocMatches) {
+            try {
+                const tocXml = match[0];
+                const instrMatch = tocXml.match(/<w:instrText[^>]*>([\s\S]*?)<\/w:instrText>/);
+                if (!instrMatch || !instrMatch[1]) {
+                    continue;
+                }
+                let fieldInstruction = instrMatch[1];
+                fieldInstruction = fieldInstruction
+                    .replace(/&lt;/g, '<')
+                    .replace(/&gt;/g, '>')
+                    .replace(/&quot;/g, '"')
+                    .replace(/&apos;/g, "'")
+                    .replace(/&amp;/g, '&');
+                const levels = this.parseTOCFieldInstruction(fieldInstruction);
+                const headings = this.findHeadingsForTOC(levels);
+                if (headings.length === 0) {
+                    continue;
+                }
+                const newTocXml = this.generateTOCXML(headings, fieldInstruction);
+                modifiedXml = modifiedXml.replace(tocXml, newTocXml);
+                replacedCount++;
+            }
+            catch (error) {
+                console.error(`Error replacing TOC: ${error}`);
+                continue;
+            }
+        }
+        if (replacedCount > 0) {
+            handler.updateFile('word/document.xml', modifiedXml);
+            await handler.save(filePath);
+        }
+        return replacedCount;
     }
     getSection() {
         return this.section;