docxmlater 2.2.4 → 2.3.0

package/dist/core/Document.js

@@ -773,7 +773,7 @@ class Document {
     }
     applyStandardTableFormatting(colorOrOptions, multiCellColor) {
         let options;
-        if (typeof colorOrOptions === 'string') {
+        if (typeof colorOrOptions === "string") {
             if (multiCellColor) {
                 options = {
                     singleCellShading: colorOrOptions,
@@ -788,13 +788,13 @@ class Document {
             options = colorOrOptions;
         }
         const singleCellShading = options?.singleCellShading?.toUpperCase();
-        const headerRowShading = (options?.headerRowShading || 'E9E9E9').toUpperCase();
+        const headerRowShading = (options?.headerRowShading || "E9E9E9").toUpperCase();
         const headerRowFormatting = {
             bold: options?.headerRowFormatting?.bold !== false,
-            alignment: options?.headerRowFormatting?.alignment || 'center',
-            font: options?.headerRowFormatting?.font || 'Verdana',
+            alignment: options?.headerRowFormatting?.alignment || "center",
+            font: options?.headerRowFormatting?.font || "Verdana",
             size: options?.headerRowFormatting?.size || 12,
-            color: options?.headerRowFormatting?.color || '000000',
+            color: options?.headerRowFormatting?.color || "000000",
             spacingBefore: options?.headerRowFormatting?.spacingBefore ?? 60,
             spacingAfter: options?.headerRowFormatting?.spacingAfter ?? 60,
         };
@@ -814,12 +814,12 @@ class Document {
             const rowCount = table.getRowCount();
             const columnCount = table.getColumnCount();
             table.setAllBorders({
-                style: 'single',
+                style: "single",
                 size: 4,
-                color: '000000',
+                color: "000000",
             });
-            table.setLayout('auto');
-            table.setWidthType('pct');
+            table.setLayout("auto");
+            table.setWidthType("pct");
             table.setWidth(5000);
             const is1x1Table = rowCount === 1 && columnCount === 1;
             if (is1x1Table) {
@@ -840,7 +840,8 @@ class Document {
                     cell.setMargins(cellMargins);
                     for (const para of cell.getParagraphs()) {
                         const numPr = para.getFormatting().numbering;
-                        if (numPr && (numPr.level !== undefined || numPr.numId !== undefined)) {
+                        if (numPr &&
+                            (numPr.level !== undefined || numPr.numId !== undefined)) {
                             continue;
                         }
                         para.setAlignment(headerRowFormatting.alignment);
@@ -864,22 +865,23 @@ class Document {
                     cell.setMargins(cellMargins);
                     const currentShading = cell.getFormatting().shading;
                     const currentColor = currentShading?.fill?.toUpperCase();
-                    const isValidHexColor = /^[0-9A-F]{6}$/i.test(currentColor || '');
-                    if (currentColor && currentColor !== 'FFFFFF' && isValidHexColor) {
+                    const isValidHexColor = /^[0-9A-F]{6}$/i.test(currentColor || "");
+                    if (currentColor && currentColor !== "FFFFFF" && isValidHexColor) {
                         cell.setShading({ fill: headerRowShading });
                         cellsRecolored++;
                         for (const para of cell.getParagraphs()) {
                             const numPr = para.getFormatting().numbering;
-                            if (numPr && (numPr.level !== undefined || numPr.numId !== undefined)) {
+                            if (numPr &&
+                                (numPr.level !== undefined || numPr.numId !== undefined)) {
                                 continue;
                             }
-                            para.setAlignment('center');
+                            para.setAlignment("center");
                             para.setSpaceBefore(60);
                             para.setSpaceAfter(60);
                             for (const run of para.getRuns()) {
                                 run.setBold(true);
-                                run.setFont('Verdana', 12);
-                                run.setColor('000000');
+                                run.setFont("Verdana", 12);
+                                run.setColor("000000");
                             }
                         }
                     }
@@ -1085,15 +1087,15 @@ class Document {
             if (!abstractNum)
                 continue;
             const level0 = abstractNum.getLevel(0);
-            if (!level0 || level0.getFormat() !== 'bullet')
+            if (!level0 || level0.getFormat() !== "bullet")
                 continue;
             for (let levelIndex = 0; levelIndex < 9; levelIndex++) {
                 const numLevel = abstractNum.getLevel(levelIndex);
                 if (!numLevel)
                     continue;
-                const bullet = levelIndex % 2 === 0 ? '•' : '○';
+                const bullet = levelIndex % 2 === 0 ? "•" : "○";
                 numLevel.setText(bullet);
-                numLevel.setFont('Arial');
+                numLevel.setFont("Arial");
                 numLevel.setFontSize(24);
                 numLevel.setLeftIndent(720 * (levelIndex + 1));
                 numLevel.setHangingIndent(360);
@@ -1112,17 +1114,17 @@ class Document {
             if (!abstractNum)
                 continue;
             const level0 = abstractNum.getLevel(0);
-            if (!level0 || level0.getFormat() === 'bullet')
+            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.setFont("Verdana");
                 numLevel.setFontSize(24);
                 numLevel.setLeftIndent(720 * (levelIndex + 1));
                 numLevel.setHangingIndent(360);
-                numLevel.setAlignment('left');
+                numLevel.setAlignment("left");
             }
             this.applyFormattingToListParagraphs(instance.getNumId());
             count++;
@@ -1136,7 +1138,7 @@ class Document {
             if (numbering?.numId === numId) {
                 const runs = para.getRuns();
                 for (const run of runs) {
-                    run.setFont('Verdana', 12);
+                    run.setFont("Verdana", 12);
                 }
                 para.setSpaceBefore(0);
                 para.setSpaceAfter(60);
@@ -1164,30 +1166,32 @@ class Document {
     wrapParagraphInTable(para, options) {
         const paraIndex = this.bodyElements.indexOf(para);
         if (paraIndex === -1) {
-            throw new Error('Paragraph not found in document body elements');
+            throw new Error("Paragraph not found in document body elements");
         }
         const table = new Table_1.Table(1, 1);
         const cell = table.getCell(0, 0);
         if (!cell) {
-            throw new Error('Failed to get cell from newly created table');
+            throw new Error("Failed to get cell from newly created table");
         }
         this.bodyElements.splice(paraIndex, 1);
         cell.addParagraph(para);
         if (options.shading) {
             cell.setShading({ fill: options.shading });
         }
-        if (options.marginTop !== undefined || options.marginBottom !== undefined ||
-            options.marginLeft !== undefined || options.marginRight !== undefined) {
+        if (options.marginTop !== undefined ||
+            options.marginBottom !== undefined ||
+            options.marginLeft !== undefined ||
+            options.marginRight !== undefined) {
             cell.setMargins({
                 top: options.marginTop ?? 100,
                 bottom: options.marginBottom ?? 100,
                 left: options.marginLeft ?? 100,
-                right: options.marginRight ?? 100
+                right: options.marginRight ?? 100,
             });
         }
         if (options.tableWidthPercent !== undefined) {
             table.setWidth(options.tableWidthPercent);
-            table.setWidthType('pct');
+            table.setWidthType("pct");
         }
         this.bodyElements.splice(paraIndex, 0, table);
         return table;
@@ -1195,60 +1199,60 @@ class Document {
     applyCustomStylesToDocument() {
         const counts = { heading1: 0, heading2: 0, normal: 0 };
         const header1Style = Style_1.Style.create({
-            styleId: 'CustomHeader1',
-            name: 'Custom Header 1',
-            type: 'paragraph',
-            basedOn: 'Normal',
+            styleId: "CustomHeader1",
+            name: "Custom Header 1",
+            type: "paragraph",
+            basedOn: "Normal",
             runFormatting: {
-                font: 'Verdana',
+                font: "Verdana",
                 size: 18,
                 bold: true,
-                color: '000000'
+                color: "000000",
             },
             paragraphFormatting: {
-                alignment: 'left',
+                alignment: "left",
                 spacing: {
                     before: 0,
-                    after: 240
-                }
-            }
+                    after: 240,
+                },
+            },
         });
         const header2Style = Style_1.Style.create({
-            styleId: 'CustomHeader2',
-            name: 'Custom Header 2',
-            type: 'paragraph',
-            basedOn: 'Normal',
+            styleId: "CustomHeader2",
+            name: "Custom Header 2",
+            type: "paragraph",
+            basedOn: "Normal",
             runFormatting: {
-                font: 'Verdana',
+                font: "Verdana",
                 size: 14,
                 bold: true,
-                color: '000000'
+                color: "000000",
             },
             paragraphFormatting: {
-                alignment: 'left',
+                alignment: "left",
                 spacing: {
                     before: 120,
-                    after: 120
-                }
-            }
+                    after: 120,
+                },
+            },
         });
         const normalStyle = Style_1.Style.create({
-            styleId: 'CustomNormal',
-            name: 'Custom Normal',
-            type: 'paragraph',
-            basedOn: 'Normal',
+            styleId: "CustomNormal",
+            name: "Custom Normal",
+            type: "paragraph",
+            basedOn: "Normal",
             runFormatting: {
-                font: 'Verdana',
+                font: "Verdana",
                 size: 12,
-                color: '000000'
+                color: "000000",
             },
             paragraphFormatting: {
-                alignment: 'left',
+                alignment: "left",
                 spacing: {
                     before: 60,
-                    after: 60
-                }
-            }
+                    after: 60,
+                },
+            },
         });
         this.addStyle(header1Style);
         this.addStyle(header2Style);
@@ -1256,17 +1260,17 @@ class Document {
         const allParagraphs = this.getAllParagraphs();
         for (const para of allParagraphs) {
             const currentStyle = para.getStyle();
-            if (currentStyle === 'Heading1' || currentStyle === 'Heading 1') {
-                para.setStyle('CustomHeader1');
+            if (currentStyle === "Heading1" || currentStyle === "Heading 1") {
+                para.setStyle("CustomHeader1");
                 counts.heading1++;
             }
-            else if (currentStyle === 'Heading2' || currentStyle === 'Heading 2') {
-                para.setStyle('CustomHeader2');
+            else if (currentStyle === "Heading2" || currentStyle === "Heading 2") {
+                para.setStyle("CustomHeader2");
                 const { inTable, cell } = this.isParagraphInTable(para);
                 if (inTable && cell) {
-                    cell.setShading({ fill: 'BFBFBF' });
+                    cell.setShading({ fill: "BFBFBF" });
                     cell.setMargins({ top: 0, bottom: 0, left: 101, right: 101 });
-                    const table = this.getAllTables().find(t => {
+                    const table = this.getAllTables().find((t) => {
                         for (const row of t.getRows()) {
                             for (const c of row.getCells()) {
                                 if (c === cell)
@@ -1277,23 +1281,23 @@ class Document {
                     });
                     if (table) {
                         table.setWidth(5000);
-                        table.setWidthType('pct');
+                        table.setWidthType("pct");
                     }
                 }
                 else {
                     this.wrapParagraphInTable(para, {
-                        shading: 'BFBFBF',
+                        shading: "BFBFBF",
                         marginTop: 0,
                         marginBottom: 0,
                         marginLeft: 101,
                         marginRight: 101,
-                        tableWidthPercent: 5000
+                        tableWidthPercent: 5000,
                     });
                 }
                 counts.heading2++;
             }
-            else if (currentStyle === 'Normal' || currentStyle === undefined) {
-                para.setStyle('CustomNormal');
+            else if (currentStyle === "Normal" || currentStyle === undefined) {
+                para.setStyle("CustomNormal");
                 counts.normal++;
             }
         }
@@ -1301,29 +1305,29 @@ class Document {
     }
     static DEFAULT_HEADING1_CONFIG = {
         run: {
-            font: 'Verdana',
+            font: "Verdana",
             size: 18,
             bold: true,
-            color: '000000',
+            color: "000000",
         },
         paragraph: {
-            alignment: 'left',
-            spacing: { before: 0, after: 240, line: 240, lineRule: 'auto' },
+            alignment: "left",
+            spacing: { before: 0, after: 240, line: 240, lineRule: "auto" },
         },
     };
     static DEFAULT_HEADING2_CONFIG = {
         run: {
-            font: 'Verdana',
+            font: "Verdana",
             size: 14,
             bold: true,
-            color: '000000',
+            color: "000000",
         },
         paragraph: {
-            alignment: 'left',
-            spacing: { before: 120, after: 120, line: 240, lineRule: 'auto' },
+            alignment: "left",
+            spacing: { before: 120, after: 120, line: 240, lineRule: "auto" },
         },
         tableOptions: {
-            shading: 'BFBFBF',
+            shading: "BFBFBF",
             marginTop: 0,
             marginBottom: 0,
             marginLeft: 115,
@@ -1333,99 +1337,114 @@ class Document {
     };
     static DEFAULT_HEADING3_CONFIG = {
         run: {
-            font: 'Verdana',
+            font: "Verdana",
             size: 12,
             bold: true,
-            color: '000000',
+            color: "000000",
         },
         paragraph: {
-            alignment: 'left',
-            spacing: { before: 60, after: 60, line: 240, lineRule: 'auto' },
+            alignment: "left",
+            spacing: { before: 60, after: 60, line: 240, lineRule: "auto" },
         },
     };
     static DEFAULT_NORMAL_CONFIG = {
         run: {
-            font: 'Verdana',
+            font: "Verdana",
             size: 12,
-            color: '000000',
+            color: "000000",
         },
         paragraph: {
-            alignment: 'left',
-            spacing: { before: 60, after: 60, line: 240, lineRule: 'auto' },
+            alignment: "left",
+            spacing: { before: 60, after: 60, line: 240, lineRule: "auto" },
         },
     };
     static DEFAULT_LIST_PARAGRAPH_CONFIG = {
         run: {
-            font: 'Verdana',
+            font: "Verdana",
             size: 12,
-            color: '000000',
+            color: "000000",
         },
         paragraph: {
-            alignment: 'left',
-            spacing: { before: 0, after: 60, line: 240, lineRule: 'auto' },
+            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');
+        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");
         const h1Config = {
             run: {
-                ...(heading1?.getRunFormatting() || Document.DEFAULT_HEADING1_CONFIG.run),
-                ...options?.heading1?.run
+                ...(heading1?.getRunFormatting() ||
+                    Document.DEFAULT_HEADING1_CONFIG.run),
+                ...options?.heading1?.run,
             },
             paragraph: {
-                ...(heading1?.getParagraphFormatting() || Document.DEFAULT_HEADING1_CONFIG.paragraph),
-                ...options?.heading1?.paragraph
+                ...(heading1?.getParagraphFormatting() ||
+                    Document.DEFAULT_HEADING1_CONFIG.paragraph),
+                ...options?.heading1?.paragraph,
             },
         };
         const h2Config = {
             run: {
-                ...(heading2?.getRunFormatting() || Document.DEFAULT_HEADING2_CONFIG.run),
-                ...options?.heading2?.run
+                ...(heading2?.getRunFormatting() ||
+                    Document.DEFAULT_HEADING2_CONFIG.run),
+                ...options?.heading2?.run,
             },
             paragraph: {
-                ...(heading2?.getParagraphFormatting() || Document.DEFAULT_HEADING2_CONFIG.paragraph),
-                ...options?.heading2?.paragraph
+                ...(heading2?.getParagraphFormatting() ||
+                    Document.DEFAULT_HEADING2_CONFIG.paragraph),
+                ...options?.heading2?.paragraph,
             },
             tableOptions: {
                 ...Document.DEFAULT_HEADING2_CONFIG.tableOptions,
-                ...options?.heading2?.tableOptions
+                ...options?.heading2?.tableOptions,
             },
         };
         const h3Config = {
             run: {
-                ...(heading3?.getRunFormatting() || Document.DEFAULT_HEADING3_CONFIG.run),
-                ...options?.heading3?.run
+                ...(heading3?.getRunFormatting() ||
+                    Document.DEFAULT_HEADING3_CONFIG.run),
+                ...options?.heading3?.run,
             },
             paragraph: {
-                ...(heading3?.getParagraphFormatting() || Document.DEFAULT_HEADING3_CONFIG.paragraph),
-                ...options?.heading3?.paragraph
+                ...(heading3?.getParagraphFormatting() ||
+                    Document.DEFAULT_HEADING3_CONFIG.paragraph),
+                ...options?.heading3?.paragraph,
             },
         };
         const normalConfig = {
             run: {
                 ...(normal?.getRunFormatting() || Document.DEFAULT_NORMAL_CONFIG.run),
-                ...options?.normal?.run
+                ...options?.normal?.run,
             },
             paragraph: {
-                ...(normal?.getParagraphFormatting() || Document.DEFAULT_NORMAL_CONFIG.paragraph),
-                ...options?.normal?.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
+                ...(listParagraph?.getRunFormatting() ||
+                    Document.DEFAULT_LIST_PARAGRAPH_CONFIG.run),
+                ...options?.listParagraph?.run,
             },
             paragraph: {
-                ...(listParagraph?.getParagraphFormatting() || Document.DEFAULT_LIST_PARAGRAPH_CONFIG.paragraph),
-                ...options?.listParagraph?.paragraph
+                ...(listParagraph?.getParagraphFormatting() ||
+                    Document.DEFAULT_LIST_PARAGRAPH_CONFIG.paragraph),
+                ...options?.listParagraph?.paragraph,
             },
         };
         const preserveBlankLines = options?.preserveBlankLinesAfterHeader2Tables ?? true;
@@ -1496,7 +1515,7 @@ class Document {
                 continue;
             }
             const styleId = para.getStyle();
-            if (styleId === 'Heading1' && heading1) {
+            if (styleId === "Heading1" && heading1) {
                 para.clearDirectFormattingConflicts(heading1);
                 for (const run of para.getRuns()) {
                     if (!h1Preserve.bold) {
@@ -1506,25 +1525,33 @@ class Document {
                         run.setItalic(h1Config.run?.italic ?? false);
                     }
                     if (!h1Preserve.underline) {
-                        run.setUnderline(h1Config.run?.underline ? 'single' : false);
+                        run.setUnderline(h1Config.run?.underline ? "single" : false);
                     }
                 }
                 if (para.formatting.paragraphMarkRunProperties) {
                     const markProps = para.formatting.paragraphMarkRunProperties;
-                    if (!h1Preserve.bold && h1Config.run?.bold === false && markProps.bold) {
+                    if (!h1Preserve.bold &&
+                        h1Config.run?.bold === false &&
+                        markProps.bold) {
                         delete markProps.bold;
                     }
-                    if (!h1Preserve.italic && h1Config.run?.italic === false && markProps.italic) {
+                    if (!h1Preserve.italic &&
+                        h1Config.run?.italic === false &&
+                        markProps.italic) {
                         delete markProps.italic;
                     }
-                    if (!h1Preserve.underline && h1Config.run?.underline === false && markProps.underline) {
+                    if (!h1Preserve.underline &&
+                        h1Config.run?.underline === false &&
+                        markProps.underline) {
                         delete markProps.underline;
                     }
                 }
                 processedParagraphs.add(para);
             }
-            else if (styleId === 'Heading2' && heading2) {
-                const hasContent = para.getRuns().some(run => run.getText().trim().length > 0);
+            else if (styleId === "Heading2" && heading2) {
+                const hasContent = para
+                    .getRuns()
+                    .some((run) => run.getText().trim().length > 0);
                 if (!hasContent) {
                     processedParagraphs.add(para);
                     continue;
@@ -1538,18 +1565,24 @@ class Document {
                         run.setItalic(h2Config.run?.italic ?? false);
                     }
                     if (!h2Preserve.underline) {
-                        run.setUnderline(h2Config.run?.underline ? 'single' : false);
+                        run.setUnderline(h2Config.run?.underline ? "single" : false);
                     }
                 }
                 if (para.formatting.paragraphMarkRunProperties) {
                     const markProps = para.formatting.paragraphMarkRunProperties;
-                    if (!h2Preserve.bold && h2Config.run?.bold === false && markProps.bold) {
+                    if (!h2Preserve.bold &&
+                        h2Config.run?.bold === false &&
+                        markProps.bold) {
                         delete markProps.bold;
                     }
-                    if (!h2Preserve.italic && h2Config.run?.italic === false && markProps.italic) {
+                    if (!h2Preserve.italic &&
+                        h2Config.run?.italic === false &&
+                        markProps.italic) {
                         delete markProps.italic;
                     }
-                    if (!h2Preserve.underline && h2Config.run?.underline === false && markProps.underline) {
+                    if (!h2Preserve.underline &&
+                        h2Config.run?.underline === false &&
+                        markProps.underline) {
                         delete markProps.underline;
                     }
                 }
@@ -1558,8 +1591,10 @@ class Document {
                     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) {
+                    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,
@@ -1568,7 +1603,7 @@ class Document {
                         });
                     }
                     if (h2Config.tableOptions?.tableWidthPercent) {
-                        const table = this.getAllTables().find(t => {
+                        const table = this.getAllTables().find((t) => {
                             for (const row of t.getRows()) {
                                 for (const c of row.getCells()) {
                                     if (c === cell)
@@ -1579,13 +1614,13 @@ class Document {
                         });
                         if (table) {
                             table.setWidth(h2Config.tableOptions.tableWidthPercent);
-                            table.setWidthType('pct');
+                            table.setWidthType("pct");
                         }
                     }
                 }
                 else {
                     const table = this.wrapParagraphInTable(para, {
-                        shading: h2Config.tableOptions?.shading ?? 'BFBFBF',
+                        shading: h2Config.tableOptions?.shading ?? "BFBFBF",
                         marginTop: h2Config.tableOptions?.marginTop ?? 0,
                         marginBottom: h2Config.tableOptions?.marginBottom ?? 0,
                         marginLeft: h2Config.tableOptions?.marginLeft ?? 115,
@@ -1602,12 +1637,12 @@ class Document {
                             if (!content || content.length === 0)
                                 return true;
                             for (const item of content) {
-                                if (item.constructor.name === 'Hyperlink') {
+                                if (item.constructor.name === "Hyperlink") {
                                     return false;
                                 }
                                 if (item.getText) {
                                     const text = item.getText().trim();
-                                    if (text !== '')
+                                    if (text !== "")
                                         return false;
                                 }
                             }
@@ -1625,7 +1660,7 @@ class Document {
                 }
                 processedParagraphs.add(para);
             }
-            else if (styleId === 'Heading3' && heading3) {
+            else if (styleId === "Heading3" && heading3) {
                 para.clearDirectFormattingConflicts(heading3);
                 for (const run of para.getRuns()) {
                     if (!h3Preserve.bold) {
@@ -1635,31 +1670,37 @@ class Document {
                         run.setItalic(h3Config.run?.italic ?? false);
                     }
                     if (!h3Preserve.underline) {
-                        run.setUnderline(h3Config.run?.underline ? 'single' : false);
+                        run.setUnderline(h3Config.run?.underline ? "single" : false);
                     }
                 }
                 if (para.formatting.paragraphMarkRunProperties) {
                     const markProps = para.formatting.paragraphMarkRunProperties;
-                    if (!h3Preserve.bold && h3Config.run?.bold === false && markProps.bold) {
+                    if (!h3Preserve.bold &&
+                        h3Config.run?.bold === false &&
+                        markProps.bold) {
                         delete markProps.bold;
                     }
-                    if (!h3Preserve.italic && h3Config.run?.italic === false && markProps.italic) {
+                    if (!h3Preserve.italic &&
+                        h3Config.run?.italic === false &&
+                        markProps.italic) {
                         delete markProps.italic;
                     }
-                    if (!h3Preserve.underline && h3Config.run?.underline === false && markProps.underline) {
+                    if (!h3Preserve.underline &&
+                        h3Config.run?.underline === false &&
+                        markProps.underline) {
                         delete markProps.underline;
                     }
                 }
                 processedParagraphs.add(para);
             }
-            else if (styleId === 'ListParagraph' && listParagraph) {
-                const preservedFormatting = para.getRuns().map(run => {
+            else if (styleId === "ListParagraph" && listParagraph) {
+                const preservedFormatting = para.getRuns().map((run) => {
                     const fmt = run.getFormatting();
                     return {
                         run: run,
                         bold: listParaPreserve.bold ? fmt.bold : undefined,
                         italic: listParaPreserve.italic ? fmt.italic : undefined,
-                        underline: listParaPreserve.underline ? fmt.underline : undefined
+                        underline: listParaPreserve.underline ? fmt.underline : undefined,
                     };
                 });
                 para.clearDirectFormattingConflicts(listParagraph);
@@ -1682,31 +1723,37 @@ class Document {
                         run.setItalic(listParaConfig.run?.italic ?? false);
                     }
                     if (!listParaPreserve.underline) {
-                        run.setUnderline(listParaConfig.run?.underline ? 'single' : false);
+                        run.setUnderline(listParaConfig.run?.underline ? "single" : false);
                     }
                 }
                 if (para.formatting.paragraphMarkRunProperties) {
                     const markProps = para.formatting.paragraphMarkRunProperties;
-                    if (!listParaPreserve.bold && listParaConfig.run?.bold === false && markProps.bold) {
+                    if (!listParaPreserve.bold &&
+                        listParaConfig.run?.bold === false &&
+                        markProps.bold) {
                         delete markProps.bold;
                     }
-                    if (!listParaPreserve.italic && listParaConfig.run?.italic === false && markProps.italic) {
+                    if (!listParaPreserve.italic &&
+                        listParaConfig.run?.italic === false &&
+                        markProps.italic) {
                         delete markProps.italic;
                     }
-                    if (!listParaPreserve.underline && listParaConfig.run?.underline === false && markProps.underline) {
+                    if (!listParaPreserve.underline &&
+                        listParaConfig.run?.underline === false &&
+                        markProps.underline) {
                         delete markProps.underline;
                     }
                 }
                 processedParagraphs.add(para);
             }
-            else if ((styleId === 'Normal' || styleId === undefined) && normal) {
-                const preservedFormatting = para.getRuns().map(run => {
+            else if ((styleId === "Normal" || styleId === undefined) && normal) {
+                const preservedFormatting = para.getRuns().map((run) => {
                     const fmt = run.getFormatting();
                     return {
                         run: run,
                         bold: normalPreserve.bold ? fmt.bold : undefined,
                         italic: normalPreserve.italic ? fmt.italic : undefined,
-                        underline: normalPreserve.underline ? fmt.underline : undefined
+                        underline: normalPreserve.underline ? fmt.underline : undefined,
                     };
                 });
                 para.clearDirectFormattingConflicts(normal);
@@ -1729,18 +1776,24 @@ class Document {
                         run.setItalic(normalConfig.run?.italic ?? false);
                     }
                     if (!normalPreserve.underline) {
-                        run.setUnderline(normalConfig.run?.underline ? 'single' : false);
+                        run.setUnderline(normalConfig.run?.underline ? "single" : false);
                     }
                 }
                 if (para.formatting.paragraphMarkRunProperties) {
                     const markProps = para.formatting.paragraphMarkRunProperties;
-                    if (!normalPreserve.bold && normalConfig.run?.bold === false && markProps.bold) {
+                    if (!normalPreserve.bold &&
+                        normalConfig.run?.bold === false &&
+                        markProps.bold) {
                         delete markProps.bold;
                     }
-                    if (!normalPreserve.italic && normalConfig.run?.italic === false && markProps.italic) {
+                    if (!normalPreserve.italic &&
+                        normalConfig.run?.italic === false &&
+                        markProps.italic) {
                         delete markProps.italic;
                     }
-                    if (!normalPreserve.underline && normalConfig.run?.underline === false && markProps.underline) {
+                    if (!normalPreserve.underline &&
+                        normalConfig.run?.underline === false &&
+                        markProps.underline) {
                         delete markProps.underline;
                     }
                 }
@@ -1754,32 +1807,32 @@ class Document {
         for (const style of styles) {
             const styleId = style.getStyleId();
             switch (styleId) {
-                case 'Heading1':
+                case "Heading1":
                     options.heading1 = {
                         run: style.getRunFormatting(),
                         paragraph: style.getParagraphFormatting(),
                     };
                     break;
-                case 'Heading2':
+                case "Heading2":
                     options.heading2 = {
                         run: style.getRunFormatting(),
                         paragraph: style.getParagraphFormatting(),
                         tableOptions: style.getHeading2TableOptions(),
                     };
                     break;
-                case 'Heading3':
+                case "Heading3":
                     options.heading3 = {
                         run: style.getRunFormatting(),
                         paragraph: style.getParagraphFormatting(),
                     };
                     break;
-                case 'Normal':
+                case "Normal":
                     options.normal = {
                         run: style.getRunFormatting(),
                         paragraph: style.getParagraphFormatting(),
                     };
                     break;
-                case 'ListParagraph':
+                case "ListParagraph":
                     options.listParagraph = {
                         run: style.getRunFormatting(),
                         paragraph: style.getParagraphFormatting(),
@@ -1842,7 +1895,7 @@ class Document {
         return {
             removed,
             preserved,
-            total: toRemove.length
+            total: toRemove.length,
         };
     }
     processConsecutiveBlanks(blanks, keepOne, toRemove) {
@@ -1875,8 +1928,10 @@ class Document {
             let hasHeader2 = false;
             for (const para of cellParas) {
                 const style = para.getStyle();
-                if (style === 'Heading2' || style === 'Heading 2' ||
-                    style === 'CustomHeader2' || style === 'Header2') {
+                if (style === "Heading2" ||
+                    style === "Heading 2" ||
+                    style === "CustomHeader2" ||
+                    style === "Header2") {
                     hasHeader2 = true;
                     break;
                 }
@@ -1928,6 +1983,67 @@ class Document {
                 }
                 else {
                     const blankPara = Paragraph_1.Paragraph.create();
+                    blankPara.setStyle("Normal");
+                    blankPara.setSpaceAfter(spacingAfter);
+                    if (markAsPreserved) {
+                        blankPara.setPreserved(true);
+                    }
+                    this.bodyElements.splice(tableIndex + 1, 0, blankPara);
+                    blankLinesAdded++;
+                }
+            }
+            else {
+                const blankPara = Paragraph_1.Paragraph.create();
+                blankPara.setStyle("Normal");
+                blankPara.setSpaceAfter(spacingAfter);
+                if (markAsPreserved) {
+                    blankPara.setPreserved(true);
+                }
+                this.bodyElements.splice(tableIndex + 1, 0, blankPara);
+                blankLinesAdded++;
+            }
+        }
+        return {
+            tablesProcessed,
+            blankLinesAdded,
+            existingLinesMarked,
+        };
+    }
+    ensureBlankLinesAfterOtherTables(options) {
+        const spacingAfter = options?.spacingAfter ?? 120;
+        const markAsPreserved = options?.markAsPreserved ?? true;
+        const filter = options?.filter;
+        let tablesProcessed = 0;
+        let blankLinesAdded = 0;
+        let existingLinesMarked = 0;
+        const tables = this.getAllTables();
+        for (let i = 0; i < tables.length; i++) {
+            const table = tables[i];
+            if (!table)
+                continue;
+            const rowCount = table.getRowCount();
+            const colCount = table.getColumnCount();
+            if (rowCount === 1 && colCount === 1) {
+                continue;
+            }
+            if (filter && !filter(table, i)) {
+                continue;
+            }
+            tablesProcessed++;
+            const tableIndex = this.bodyElements.indexOf(table);
+            if (tableIndex === -1)
+                continue;
+            const nextElement = this.bodyElements[tableIndex + 1];
+            if (nextElement instanceof Paragraph_1.Paragraph) {
+                if (this.isParagraphBlank(nextElement)) {
+                    if (markAsPreserved && !nextElement.isPreserved()) {
+                        nextElement.setPreserved(true);
+                        existingLinesMarked++;
+                    }
+                }
+                else {
+                    const blankPara = Paragraph_1.Paragraph.create();
+                    blankPara.setStyle("Normal");
                     blankPara.setSpaceAfter(spacingAfter);
                     if (markAsPreserved) {
                         blankPara.setPreserved(true);
@@ -1938,6 +2054,7 @@ class Document {
             }
             else {
                 const blankPara = Paragraph_1.Paragraph.create();
+                blankPara.setStyle("Normal");
                 blankPara.setSpaceAfter(spacingAfter);
                 if (markAsPreserved) {
                     blankPara.setPreserved(true);
@@ -1952,6 +2069,73 @@ class Document {
             existingLinesMarked,
         };
     }
+    standardizeBulletSymbols(options) {
+        const { bold = true, fontSize = 24, color = "000000", font = "Arial", } = options || {};
+        let listsUpdated = 0;
+        let levelsModified = 0;
+        const instances = this.numberingManager.getAllInstances();
+        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(font);
+                numLevel.setFontSize(fontSize);
+                numLevel.setBold(bold);
+                numLevel.setColor(color);
+                levelsModified++;
+            }
+            listsUpdated++;
+        }
+        return { listsUpdated, levelsModified };
+    }
+    standardizeNumberedListPrefixes(options) {
+        const { bold = true, fontSize = 24, color = "000000", font = "Verdana", } = options || {};
+        let listsUpdated = 0;
+        let levelsModified = 0;
+        const instances = this.numberingManager.getAllInstances();
+        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(font);
+                numLevel.setFontSize(fontSize);
+                numLevel.setBold(bold);
+                numLevel.setColor(color);
+                levelsModified++;
+            }
+            listsUpdated++;
+        }
+        return { listsUpdated, levelsModified };
+    }
+    standardizeAllHyperlinks(options) {
+        const { font = "Verdana", size = 12, color = "0000FF", underline = true, } = options || {};
+        const hyperlinks = this.getHyperlinks();
+        for (const { hyperlink } of hyperlinks) {
+            hyperlink.setFormatting({
+                font: font,
+                size: size,
+                color: color,
+                underline: underline ? "single" : false,
+            });
+        }
+        return hyperlinks.length;
+    }
     cleanFormatting(styleNames) {
         let cleaned = 0;
         for (const para of this.bodyElements) {
@@ -1970,24 +2154,26 @@ class Document {
         return cleaned;
     }
     applyH1(options) {
-        return this.applyStyleToMatching('Heading1', options, (style) => /^(heading\s*1|header\s*1|h1)$/i.test(style));
+        return this.applyStyleToMatching("Heading1", options, (style) => /^(heading\s*1|header\s*1|h1)$/i.test(style));
     }
     applyH2(options) {
-        return this.applyStyleToMatching('Heading2', options, (style) => /^(heading\s*2|header\s*2|h2)$/i.test(style));
+        return this.applyStyleToMatching("Heading2", options, (style) => /^(heading\s*2|header\s*2|h2)$/i.test(style));
     }
     applyH3(options) {
-        return this.applyStyleToMatching('Heading3', options, (style) => /^(heading\s*3|header\s*3|h3)$/i.test(style));
+        return this.applyStyleToMatching("Heading3", options, (style) => /^(heading\s*3|header\s*3|h3)$/i.test(style));
     }
     applyNormal(options) {
-        const targets = options?.paragraphs || this.getAllParagraphs().filter(p => {
-            const style = p.getStyle();
-            return !style || !/^(heading|header|h\d|list|toc|tod|caution|table)/i.test(style);
-        });
+        const targets = options?.paragraphs ||
+            this.getAllParagraphs().filter((p) => {
+                const style = p.getStyle();
+                return (!style ||
+                    !/^(heading|header|h\d|list|toc|tod|caution|table)/i.test(style));
+            });
         let count = 0;
         for (const para of targets) {
             if (para.isPreserved())
                 continue;
-            para.setStyle('Normal');
+            para.setStyle("Normal");
             if (options?.keepProperties && options.keepProperties.length > 0) {
                 this.clearFormattingExcept(para, options.keepProperties);
             }
@@ -2002,19 +2188,19 @@ class Document {
         return count;
     }
     applyNumList(options) {
-        return this.applyStyleToMatching('ListParagraph', options, (style) => /^(list\s*number|numbered\s*list|list\s*paragraph)$/i.test(style));
+        return this.applyStyleToMatching("ListParagraph", options, (style) => /^(list\s*number|numbered\s*list|list\s*paragraph)$/i.test(style));
     }
     applyBulletList(options) {
-        return this.applyStyleToMatching('ListParagraph', options, (style) => /^(list\s*bullet|bullet\s*list|list\s*paragraph)$/i.test(style));
+        return this.applyStyleToMatching("ListParagraph", options, (style) => /^(list\s*bullet|bullet\s*list|list\s*paragraph)$/i.test(style));
     }
     applyTOC(options) {
-        return this.applyStyleToMatching('TOC', options, (style) => /^(toc|table\s*of\s*contents|toc\s*heading)$/i.test(style));
+        return this.applyStyleToMatching("TOC", options, (style) => /^(toc|table\s*of\s*contents|toc\s*heading)$/i.test(style));
     }
     applyTOD(options) {
-        return this.applyStyleToMatching('TopOfDocument', options, (style) => /^(tod|top\s*of\s*document|document\s*top)$/i.test(style));
+        return this.applyStyleToMatching("TopOfDocument", options, (style) => /^(tod|top\s*of\s*document|document\s*top)$/i.test(style));
     }
     applyCaution(options) {
-        return this.applyStyleToMatching('Caution', options, (style) => /^(caution|warning|important|alert)$/i.test(style));
+        return this.applyStyleToMatching("Caution", options, (style) => /^(caution|warning|important|alert)$/i.test(style));
     }
     applyCellHeader(options) {
         let count = 0;
@@ -2027,7 +2213,7 @@ class Document {
                 for (const para of cell.getParagraphs()) {
                     if (para.isPreserved())
                         continue;
-                    para.setStyle('TableHeader');
+                    para.setStyle("TableHeader");
                     if (options?.keepProperties && options.keepProperties.length > 0) {
                         this.clearFormattingExcept(para, options.keepProperties);
                     }
@@ -2062,13 +2248,13 @@ class Document {
                 if (options.color)
                     run.setColor(options.color);
                 if (options.emphasis) {
-                    options.emphasis.forEach(emp => {
-                        if (emp === 'bold')
+                    options.emphasis.forEach((emp) => {
+                        if (emp === "bold")
                             run.setBold(true);
-                        if (emp === 'italic')
+                        if (emp === "italic")
                             run.setItalic(true);
-                        if (emp === 'underline')
-                            run.setUnderline('single');
+                        if (emp === "underline")
+                            run.setUnderline("single");
                     });
                 }
             }
@@ -2153,10 +2339,11 @@ class Document {
         }
     }
     applyStyleToMatching(targetStyle, options, matcher) {
-        const targets = options?.paragraphs || this.getAllParagraphs().filter(p => {
-            const style = p.getStyle();
-            return style && matcher(style);
-        });
+        const targets = options?.paragraphs ||
+            this.getAllParagraphs().filter((p) => {
+                const style = p.getStyle();
+                return style && matcher(style);
+            });
         let count = 0;
         for (const para of targets) {
             if (para.isPreserved())
@@ -2181,26 +2368,27 @@ class Document {
             return true;
         }
         for (const item of content) {
-            if (item.constructor.name === 'Hyperlink') {
+            if (item.constructor.name === "Hyperlink") {
                 return false;
             }
-            if (item.constructor.name === 'Shape') {
+            if (item.constructor.name === "Shape") {
                 return false;
             }
-            if (item.constructor.name === 'TextBox') {
+            if (item.constructor.name === "TextBox") {
                 return false;
             }
-            if (item.constructor.name === 'Field') {
+            if (item.constructor.name === "Field") {
                 return false;
             }
             if (item.getText) {
                 const text = item.getText().trim();
-                if (text !== '') {
+                if (text !== "") {
                     return false;
                 }
             }
         }
-        if (para.getBookmarksStart().length > 0 || para.getBookmarksEnd().length > 0) {
+        if (para.getBookmarksStart().length > 0 ||
+            para.getBookmarksEnd().length > 0) {
             return false;
         }
         return true;
@@ -2222,7 +2410,10 @@ class Document {
             const content = match[1];
             if (!content)
                 continue;
-            const parts = content.split(',').map(p => p.trim()).filter(p => p);
+            const parts = content
+                .split(",")
+                .map((p) => p.trim())
+                .filter((p) => p);
             if (parts.length < 2)
                 continue;
             const styleName = parts[0];
@@ -2253,20 +2444,20 @@ class Document {
         const levelSet = new Set(levels);
         try {
             const parsed = XMLParser_1.XMLParser.parseToObject(docXml, { trimValues: false });
-            const document = parsed['w:document'];
+            const document = parsed["w:document"];
             if (!document) {
                 return headings;
             }
-            const body = document['w:body'];
+            const body = document["w:body"];
             if (!body) {
                 return headings;
             }
             const extractHeading = (para) => {
-                const pPr = para['w:pPr'];
-                if (!pPr || !pPr['w:pStyle']) {
+                const pPr = para["w:pPr"];
+                if (!pPr || !pPr["w:pStyle"]) {
                     return;
                 }
-                const styleVal = pPr['w:pStyle']['@_w:val'];
+                const styleVal = pPr["w:pStyle"]["@_w:val"];
                 if (!styleVal) {
                     return;
                 }
@@ -2278,30 +2469,32 @@ class Document {
                 if (!levelSet.has(headingLevel)) {
                     return;
                 }
-                let bookmark = '';
-                const bookmarkStart = para['w:bookmarkStart'];
+                let bookmark = "";
+                const bookmarkStart = para["w:bookmarkStart"];
                 if (bookmarkStart) {
-                    const bookmarkArray = Array.isArray(bookmarkStart) ? bookmarkStart : [bookmarkStart];
+                    const bookmarkArray = Array.isArray(bookmarkStart)
+                        ? bookmarkStart
+                        : [bookmarkStart];
                     for (const bm of bookmarkArray) {
-                        const bmName = bm['@_w:name'];
-                        if (bmName && bmName.toLowerCase().includes('_heading')) {
+                        const bmName = bm["@_w:name"];
+                        if (bmName && bmName.toLowerCase().includes("_heading")) {
                             bookmark = bmName;
                             break;
                         }
                     }
                 }
-                let text = '';
-                const runs = para['w:r'];
+                let text = "";
+                const runs = para["w:r"];
                 if (runs) {
                     const runArray = Array.isArray(runs) ? runs : [runs];
                     for (const run of runArray) {
-                        const textElement = run['w:t'];
+                        const textElement = run["w:t"];
                         if (textElement) {
-                            if (typeof textElement === 'string') {
+                            if (typeof textElement === "string") {
                                 text += textElement;
                             }
-                            else if (textElement['#text']) {
-                                text += textElement['#text'];
+                            else if (textElement["#text"]) {
+                                text += textElement["#text"];
                             }
                         }
                     }
@@ -2316,34 +2509,36 @@ class Document {
                 headings.push({
                     level: headingLevel,
                     text: text,
-                    bookmark: bookmark
+                    bookmark: bookmark,
                 });
             };
-            const paragraphs = body['w:p'];
+            const paragraphs = body["w:p"];
             if (paragraphs) {
                 const paraArray = Array.isArray(paragraphs) ? paragraphs : [paragraphs];
                 for (const para of paraArray) {
                     extractHeading(para);
                 }
             }
-            const tables = body['w:tbl'];
+            const tables = body["w:tbl"];
             if (tables) {
                 const tableArray = Array.isArray(tables) ? tables : [tables];
                 for (const table of tableArray) {
-                    const rows = table['w:tr'];
+                    const rows = table["w:tr"];
                     if (!rows)
                         continue;
                     const rowArray = Array.isArray(rows) ? rows : [rows];
                     for (const row of rowArray) {
-                        const cells = row['w:tc'];
+                        const cells = row["w:tc"];
                         if (!cells)
                             continue;
                         const cellArray = Array.isArray(cells) ? cells : [cells];
                         for (const cell of cellArray) {
-                            const cellParas = cell['w:p'];
+                            const cellParas = cell["w:p"];
                             if (!cellParas)
                                 continue;
-                            const cellParaArray = Array.isArray(cellParas) ? cellParas : [cellParas];
+                            const cellParaArray = Array.isArray(cellParas)
+                                ? cellParas
+                                : [cellParas];
                             for (const para of cellParaArray) {
                                 extractHeading(para);
                             }
@@ -2353,7 +2548,9 @@ class Document {
             }
         }
         catch (error) {
-            logger_1.defaultLogger.error('Error parsing document.xml for headings:', error instanceof Error ? { message: error.message, stack: error.stack } : { error: String(error) });
+            logger_1.defaultLogger.error("Error parsing document.xml for headings:", error instanceof Error
+                ? { message: error.message, stack: error.stack }
+                : { error: String(error) });
         }
         return headings;
     }
@@ -2375,7 +2572,7 @@ class Document {
                                 headings.push({
                                     level: headingLevel,
                                     text: text,
-                                    bookmark: bookmark.getName()
+                                    bookmark: bookmark.getName(),
                                 });
                             }
                         }
@@ -2387,93 +2584,95 @@ class Document {
     }
     generateTOCXML(headings, originalInstrText) {
         const sdtId = Math.floor(Math.random() * 2000000000) - 1000000000;
-        let tocXml = '<w:sdt>';
-        tocXml += '<w:sdtPr>';
+        let tocXml = "<w:sdt>";
+        tocXml += "<w:sdtPr>";
         tocXml += `<w:id w:val="${sdtId}"/>`;
-        tocXml += '<w:docPartObj>';
+        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>';
-        const minLevel = headings.length > 0
-            ? Math.min(...headings.map(h => h.level))
-            : 1;
-        tocXml += '<w:p>';
-        tocXml += '<w:pPr>';
-        tocXml += '<w:spacing w:after="0" w:before="0" w:line="240" w:lineRule="auto"/>';
+        tocXml += "</w:docPartObj>";
+        tocXml += "</w:sdtPr>";
+        tocXml += "<w:sdtContent>";
+        const minLevel = headings.length > 0 ? Math.min(...headings.map((h) => h.level)) : 1;
+        tocXml += "<w:p>";
+        tocXml += "<w:pPr>";
+        tocXml +=
+            '<w:spacing w:after="0" w:before="0" w:line="240" w:lineRule="auto"/>';
         if (headings.length > 0 && headings[0]) {
             const firstIndent = (headings[0].level - minLevel) * 360;
             if (firstIndent > 0) {
                 tocXml += `<w:ind w:left="${firstIndent}"/>`;
             }
         }
-        tocXml += '</w:pPr>';
+        tocXml += "</w:pPr>";
         tocXml += '<w:r><w:fldChar w:fldCharType="begin"/></w:r>';
-        tocXml += '<w:r>';
+        tocXml += "<w:r>";
         tocXml += `<w:instrText xml:space="preserve">${this.escapeXml(originalInstrText)}</w:instrText>`;
-        tocXml += '</w:r>';
+        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>';
+        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"/>';
+            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 - minLevel) * 360;
             if (indent > 0) {
                 tocXml += `<w:ind w:left="${indent}"/>`;
             }
-            tocXml += '</w:pPr>';
+            tocXml += "</w:pPr>";
             tocXml += this.buildTOCEntryXML(heading);
-            tocXml += '</w:p>';
+            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: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>';
+        tocXml += "</w:p>";
+        tocXml += "</w:sdtContent>";
+        tocXml += "</w:sdt>";
         return tocXml;
     }
     buildTOCEntryXML(heading) {
         const escapedText = this.escapeXml(heading.text);
-        let xml = '';
+        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: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:rPr>";
         xml += `<w:t xml:space="preserve">${escapedText}</w:t>`;
-        xml += '</w:r>';
-        xml += '</w:hyperlink>';
+        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;');
+            .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');
+        const docXml = handler.getFileAsString("word/document.xml");
         if (!docXml) {
-            throw new Error('word/document.xml not found in document');
+            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));
@@ -2491,9 +2690,9 @@ class Document {
                 }
                 let fieldInstruction = instrMatch[1];
                 fieldInstruction = fieldInstruction
-                    .replace(/&amp;/g, '&')
-                    .replace(/&lt;/g, '<')
-                    .replace(/&gt;/g, '>')
+                    .replace(/&amp;/g, "&")
+                    .replace(/&lt;/g, "<")
+                    .replace(/&gt;/g, ">")
                     .replace(/&quot;/g, '"')
                     .replace(/&apos;/g, "'");
                 const levels = this.parseTOCFieldInstruction(fieldInstruction);
@@ -2511,7 +2710,7 @@ class Document {
             }
         }
         if (replacedCount > 0) {
-            handler.updateFile('word/document.xml', modifiedXml);
+            handler.updateFile("word/document.xml", modifiedXml);
             await handler.save(filePath);
         }
         return replacedCount;
@@ -2743,7 +2942,7 @@ class Document {
             bookmark = new Bookmark_1.Bookmark({
                 id: 0,
                 name: BOOKMARK_NAME,
-                skipNormalization: true
+                skipNormalization: true,
             });
             this.bookmarkManager.register(bookmark);
             const paragraphs = this.getParagraphs();
@@ -2761,7 +2960,7 @@ class Document {
             anchor: BOOKMARK_NAME,
             hyperlink: (text, formatting) => {
                 return Hyperlink_1.Hyperlink.createInternal(BOOKMARK_NAME, text, formatting);
-            }
+            },
         };
     }
     getRevisionManager() {
@@ -2814,13 +3013,15 @@ class Document {
                 this.trackFormatting = options.trackFormatting;
             }
             if (options.showInsertionsAndDeletions !== undefined) {
-                this.revisionViewSettings.showInsertionsAndDeletions = options.showInsertionsAndDeletions;
+                this.revisionViewSettings.showInsertionsAndDeletions =
+                    options.showInsertionsAndDeletions;
             }
             if (options.showFormatting !== undefined) {
                 this.revisionViewSettings.showFormatting = options.showFormatting;
             }
             if (options.showInkAnnotations !== undefined) {
-                this.revisionViewSettings.showInkAnnotations = options.showInkAnnotations;
+                this.revisionViewSettings.showInkAnnotations =
+                    options.showInkAnnotations;
             }
         }
         return this;
@@ -2840,7 +3041,7 @@ class Document {
     }
     setRsidRoot(rsidRoot) {
         if (!/^[0-9A-Fa-f]{8}$/.test(rsidRoot)) {
-            throw new Error('RSID must be an 8-character hexadecimal value');
+            throw new Error("RSID must be an 8-character hexadecimal value");
         }
         this.rsidRoot = rsidRoot.toUpperCase();
         this.rsids.add(this.rsidRoot);
@@ -2848,13 +3049,16 @@ class Document {
     }
     addRsid(rsid) {
         if (!/^[0-9A-Fa-f]{8}$/.test(rsid)) {
-            throw new Error('RSID must be an 8-character hexadecimal value');
+            throw new Error("RSID must be an 8-character hexadecimal value");
         }
         this.rsids.add(rsid.toUpperCase());
         return this;
     }
     generateRsid() {
-        const rsid = Math.floor(Math.random() * 0xFFFFFFFF).toString(16).toUpperCase().padStart(8, '0');
+        const rsid = Math.floor(Math.random() * 0xffffffff)
+            .toString(16)
+            .toUpperCase()
+            .padStart(8, "0");
         this.rsids.add(rsid);
         return rsid;
     }
@@ -2875,9 +3079,11 @@ class Document {
             cryptSpinCount: protection.cryptSpinCount,
         };
         if (protection.password) {
-            const crypto = require('crypto');
-            const salt = crypto.randomBytes(16).toString('base64');
-            const hash = crypto.pbkdf2Sync(protection.password, salt, protection.cryptSpinCount || 100000, 32, 'sha512').toString('base64');
+            const crypto = require("crypto");
+            const salt = crypto.randomBytes(16).toString("base64");
+            const hash = crypto
+                .pbkdf2Sync(protection.password, salt, protection.cryptSpinCount || 100000, 32, "sha512")
+                .toString("base64");
             this.documentProtection.hash = hash;
             this.documentProtection.salt = salt;
         }
@@ -2914,7 +3120,9 @@ class Document {
         return this.revisionManager.register(revision);
     }
     trackMove(author, content, date) {
-        const moveId = `move${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const moveId = `move${Date.now()}_${Math.random()
+            .toString(36)
+            .substr(2, 9)}`;
         const moveName = `move${Date.now()}`;
         const rangeIdStart = this.revisionManager.getStats().nextId;
         const moveFromRangeStart = RangeMarker_1.RangeMarker.createMoveFromStart(rangeIdStart, moveName, author, date);
@@ -3065,7 +3273,7 @@ class Document {
             }
             let content = file.content;
             if (!file.isBinary && Buffer.isBuffer(file.content)) {
-                content = file.content.toString('utf-8');
+                content = file.content.toString("utf-8");
             }
             return {
                 name: partName,
@@ -3423,20 +3631,20 @@ class Document {
         return replacementCount;
     }
     findAndReplaceAll(pattern, replacement, options) {
-        const { caseSensitive = false, wholeWord = false, trackChanges = false, author = 'Unknown', } = options || {};
+        const { caseSensitive = false, wholeWord = false, trackChanges = false, author = "Unknown", } = options || {};
         let count = 0;
         const revisions = [];
         let regex;
-        if (typeof pattern === 'string') {
-            const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        if (typeof pattern === "string") {
+            const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
             const boundaryPattern = wholeWord ? `\\b${escaped}\\b` : escaped;
-            const flags = caseSensitive ? 'g' : 'gi';
+            const flags = caseSensitive ? "g" : "gi";
             regex = new RegExp(boundaryPattern, flags);
         }
         else {
-            const flags = pattern.flags.includes('g')
+            const flags = pattern.flags.includes("g")
                 ? pattern.flags
-                : pattern.flags + 'g';
+                : pattern.flags + "g";
             regex = new RegExp(pattern.source, flags);
         }
         const runs = this.getAllRuns();
@@ -3568,14 +3776,14 @@ class Document {
     }
     validateParagraph(paragraph) {
         if (!(paragraph instanceof Paragraph_1.Paragraph)) {
-            throw new Error('insertParagraphAt: parameter must be a Paragraph instance');
+            throw new Error("insertParagraphAt: parameter must be a Paragraph instance");
         }
         const paraId = paragraph.getFormatting().paraId;
         if (paraId) {
             const existingIds = this.bodyElements
                 .filter((el) => el instanceof Paragraph_1.Paragraph)
-                .map(p => p.getFormatting().paraId)
-                .filter(id => id === paraId);
+                .map((p) => p.getFormatting().paraId)
+                .filter((id) => id === paraId);
             if (existingIds.length > 0) {
                 throw new Error(`Duplicate paragraph ID detected: ${paraId}. Each paragraph must have a unique ID.`);
             }
@@ -3591,15 +3799,15 @@ class Document {
     }
     validateTable(table) {
         if (!(table instanceof Table_1.Table)) {
-            throw new Error('insertTableAt: parameter must be a Table instance');
+            throw new Error("insertTableAt: parameter must be a Table instance");
         }
         const rows = table.getRows();
         if (rows.length === 0) {
-            throw new Error('insertTableAt: table must have at least one row');
+            throw new Error("insertTableAt: table must have at least one row");
         }
         const firstRow = rows[0];
         if (firstRow && firstRow.getCells().length === 0) {
-            throw new Error('insertTableAt: table rows must have at least one cell');
+            throw new Error("insertTableAt: table rows must have at least one cell");
         }
         const tableStyle = table.getFormatting().style;
         if (tableStyle && !this.stylesManager.hasStyle(tableStyle)) {
@@ -3608,12 +3816,21 @@ class Document {
     }
     validateToc(toc) {
         if (!(toc instanceof TableOfContentsElement_1.TableOfContentsElement)) {
-            throw new Error('insertTocAt: parameter must be a TableOfContentsElement instance');
-        }
-        const hasHeadings = ['Heading1', 'Heading2', 'Heading3', 'Heading4', 'Heading5', 'Heading6', 'Heading7', 'Heading8', 'Heading9']
-            .some(style => this.stylesManager.hasStyle(style));
+            throw new Error("insertTocAt: parameter must be a TableOfContentsElement instance");
+        }
+        const hasHeadings = [
+            "Heading1",
+            "Heading2",
+            "Heading3",
+            "Heading4",
+            "Heading5",
+            "Heading6",
+            "Heading7",
+            "Heading8",
+            "Heading9",
+        ].some((style) => this.stylesManager.hasStyle(style));
         if (!hasHeadings) {
-            logger_1.defaultLogger.warn('No heading styles found in document. Table of Contents may not display entries correctly.');
+            logger_1.defaultLogger.warn("No heading styles found in document. Table of Contents may not display entries correctly.");
         }
     }
     normalizeIndex(index) {
@@ -3835,7 +4052,7 @@ class Document {
             const toRemove = [];
             this.bodyElements.forEach((element, index) => {
                 if (element instanceof Paragraph_1.Paragraph) {
-                    const isEmpty = element.getText().trim() === '';
+                    const isEmpty = element.getText().trim() === "";
                     if (isEmpty && lastWasEmpty) {
                         toRemove.push(index);
                     }
@@ -3862,7 +4079,7 @@ class Document {
                 }
             }
             if (standardLineSpacing !== undefined) {
-                para.setLineSpacing(standardLineSpacing, 'auto');
+                para.setLineSpacing(standardLineSpacing, "auto");
                 normalized++;
             }
             if (removeTrailingSpaces) {
@@ -3896,7 +4113,7 @@ class Document {
                             }
                         }
                         if (standardLineSpacing !== undefined) {
-                            para.setLineSpacing(standardLineSpacing, 'auto');
+                            para.setLineSpacing(standardLineSpacing, "auto");
                             normalized++;
                         }
                         if (removeTrailingSpaces) {