docxmlater 10.3.6 → 10.4.1

package/dist/core/Document.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Document = void 0;
 const Bookmark_1 = require("../elements/Bookmark");
 const BookmarkManager_1 = require("../elements/BookmarkManager");
+const PreservedElement_1 = require("../elements/PreservedElement");
 const CommentManager_1 = require("../elements/CommentManager");
 const EndnoteManager_1 = require("../elements/EndnoteManager");
 const Field_1 = require("../elements/Field");
@@ -155,7 +156,6 @@ class Document {
         showInkAnnotations: true,
     };
     autoPopulateTOCs = false;
-    autoSyncTOCStyles = false;
     skipDocumentXmlRegeneration = false;
     acceptRevisionsBeforeSave = false;
     _originalContentTypes;
@@ -243,6 +243,128 @@ class Document {
         doc.initializeRequiredFiles();
         return doc;
     }
+    static fromMarkdown(markdown, options) {
+        const doc = Document.create(options);
+        const lines = markdown.split('\n');
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            if (line.trim() === '') {
+                i++;
+                continue;
+            }
+            if (/^\s{0,3}([-]{3,}|[*]{3,}|[_]{3,})\s*$/.test(line)) {
+                doc.addHorizontalRule();
+                i++;
+                continue;
+            }
+            const headingMatch = /^(#{1,6})\s+(.+)$/.exec(line);
+            if (headingMatch) {
+                const level = headingMatch[1].length;
+                const text = headingMatch[2];
+                const para = doc.addHeading('', level);
+                Document.applyInlineMarkdown(para, text);
+                i++;
+                continue;
+            }
+            if (line.trimStart().startsWith('|')) {
+                const tableLines = [];
+                while (i < lines.length && lines[i].trimStart().startsWith('|')) {
+                    tableLines.push(lines[i]);
+                    i++;
+                }
+                const table = Document.parseMarkdownTable(tableLines);
+                if (table) {
+                    doc.addTable(table);
+                }
+                continue;
+            }
+            const bulletMatch = /^(\s*)[-*+]\s+(.+)$/.exec(line);
+            if (bulletMatch) {
+                const text = bulletMatch[2];
+                const para = doc.createParagraph();
+                Document.applyInlineMarkdown(para, text);
+                para.setStyle('ListBullet');
+                i++;
+                continue;
+            }
+            const numberMatch = /^(\s*)\d+[.)]\s+(.+)$/.exec(line);
+            if (numberMatch) {
+                const text = numberMatch[2];
+                const para = doc.createParagraph();
+                Document.applyInlineMarkdown(para, text);
+                para.setStyle('ListNumber');
+                i++;
+                continue;
+            }
+            const paraLines = [line];
+            i++;
+            while (i < lines.length &&
+                lines[i].trim() !== '' &&
+                !lines[i].trim().startsWith('#') &&
+                !lines[i].trim().startsWith('|') &&
+                !/^\s{0,3}([-]{3,}|[*]{3,}|[_]{3,})\s*$/.test(lines[i]) &&
+                !/^(\s*)[-*+]\s+/.test(lines[i]) &&
+                !/^(\s*)\d+[.)]\s+/.test(lines[i])) {
+                paraLines.push(lines[i]);
+                i++;
+            }
+            const para = doc.createParagraph();
+            Document.applyInlineMarkdown(para, paraLines.join(' '));
+        }
+        return doc;
+    }
+    static applyInlineMarkdown(para, text) {
+        const inlinePattern = /(\*\*\*(.+?)\*\*\*|\*\*(.+?)\*\*|\*(.+?)\*|~~(.+?)~~|`([^`]+)`|\[([^\]]+)\]\(([^)]+)\))/g;
+        let lastIndex = 0;
+        let match;
+        while ((match = inlinePattern.exec(text)) !== null) {
+            if (match.index > lastIndex) {
+                para.addText(text.slice(lastIndex, match.index));
+            }
+            if (match[2] !== undefined) {
+                para.addText(match[2], { bold: true, italic: true });
+            }
+            else if (match[3] !== undefined) {
+                para.addText(match[3], { bold: true });
+            }
+            else if (match[4] !== undefined) {
+                para.addText(match[4], { italic: true });
+            }
+            else if (match[5] !== undefined) {
+                para.addText(match[5], { strike: true });
+            }
+            else if (match[6] !== undefined) {
+                para.addText(match[6], { font: 'Courier New' });
+            }
+            else if (match[7] !== undefined && match[8] !== undefined) {
+                para.addHyperlink(new Hyperlink_1.Hyperlink({ url: match[8], text: match[7] }));
+            }
+            lastIndex = match.index + match[0].length;
+        }
+        if (lastIndex < text.length) {
+            para.addText(text.slice(lastIndex));
+        }
+    }
+    static parseMarkdownTable(lines) {
+        if (lines.length < 2)
+            return null;
+        const parseRow = (line) => line
+            .replace(/^\|/, '')
+            .replace(/\|$/, '')
+            .split('|')
+            .map((cell) => cell.trim());
+        const rows = [];
+        for (let i = 0; i < lines.length; i++) {
+            const cells = parseRow(lines[i]);
+            if (cells.every((c) => /^:?-+:?$/.test(c)))
+                continue;
+            rows.push(cells);
+        }
+        if (rows.length === 0)
+            return null;
+        return Table_1.Table.fromArray(rows);
+    }
     static async load(filePath, options) {
         const logger = getLogger();
         logger.info('Loading document from file', { path: filePath });
@@ -732,6 +854,21 @@ class Document {
         this.bodyElements.push(para);
         return para;
     }
+    addHeading(text, level = 1) {
+        return this.createParagraph(text).setStyle(`Heading${level}`);
+    }
+    addPageBreak() {
+        const para = this.createParagraph();
+        const run = new Run_1.Run('');
+        run.addBreak('page');
+        para.addRun(run);
+        return para;
+    }
+    addHorizontalRule(color = 'auto', size = 4) {
+        const para = this.createParagraph();
+        para.setBorder({ bottom: { style: 'single', size, color, space: 1 } });
+        return para;
+    }
     addTable(table) {
         table._setStylesManager(this.stylesManager);
         if (this.trackChangesEnabled && this.trackingContext.isEnabled()) {
@@ -750,6 +887,12 @@ class Document {
         this.bodyElements.push(table);
         return table;
     }
+    createTableFromCSV(csv, delimiter = ',') {
+        const table = Table_1.Table.fromCSV(csv, delimiter);
+        table._setStylesManager(this.stylesManager);
+        this.bodyElements.push(table);
+        return table;
+    }
     getTables() {
         return this.bodyElements.filter((el) => el instanceof Table_1.Table);
     }
@@ -1007,7 +1150,7 @@ class Document {
                 await fs.unlink(tempPath);
             }
             catch (cleanupErr) {
-                logger.debug('Failed to clean up temp file', { tempPath, error: String(cleanupErr) });
+                logger.warn('Failed to clean up temp file', { tempPath, error: String(cleanupErr) });
             }
             throw error;
         }
@@ -1049,6 +1192,22 @@ class Document {
             }
         }
     }
+    async toBase64() {
+        const buffer = await this.toBuffer();
+        return buffer.toString('base64');
+    }
+    async toDataUri() {
+        const base64 = await this.toBase64();
+        return `data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64,${base64}`;
+    }
+    static async loadFromBase64(base64, options) {
+        const buffer = Buffer.from(base64, 'base64');
+        return Document.loadFromBuffer(buffer, options);
+    }
+    async clone() {
+        const buffer = await this.toBuffer();
+        return Document.loadFromBuffer(buffer);
+    }
     updateDocumentXml() {
         let xml = this.generator.generateDocumentXml(this.bodyElements, this.section, this.namespaces, this._documentBackground);
         xml = this.syncTOCFieldInstructions(xml);
@@ -2181,7 +2340,6 @@ class Document {
             left: options?.cellMargins?.left ?? 115,
             right: options?.cellMargins?.right ?? 115,
         };
-        const skipSingleCellTables = options?.skipSingleCellTables !== false && !singleCellShading;
         let tablesProcessed = 0;
         let headerRowsFormatted = 0;
         let cellsRecolored = 0;
@@ -2584,6 +2742,19 @@ class Document {
         }
         const registeredSet = new Set(existingRevisions);
         let docPrId = 1;
+        const existingParaIds = new Set();
+        const paragraphsNeedingIds = [];
+        const generateUniqueParaId = () => {
+            let id;
+            do {
+                id = Math.floor(Math.random() * 0x7fffffff + 1)
+                    .toString(16)
+                    .toUpperCase()
+                    .padStart(8, '0');
+            } while (existingParaIds.has(id));
+            existingParaIds.add(id);
+            return id;
+        };
         const processParagraph = (para) => {
             for (const rev of para.getRevisions()) {
                 if (!registeredSet.has(rev)) {
@@ -2603,6 +2774,12 @@ class Document {
                     item.getImageElement().setDocPrId(docPrId++);
                 }
             }
+            if (para.formatting.paraId) {
+                existingParaIds.add(para.formatting.paraId);
+            }
+            else {
+                paragraphsNeedingIds.push(para);
+            }
         };
         for (const element of this.bodyElements) {
             if (element instanceof Paragraph_1.Paragraph) {
@@ -2618,6 +2795,12 @@ class Document {
                 }
             }
         }
+        for (const para of paragraphsNeedingIds) {
+            para.formatting.paraId = generateUniqueParaId();
+            if (!para.formatting.textId) {
+                para.formatting.textId = generateUniqueParaId();
+            }
+        }
     }
     getLastParagraph() {
         for (let i = this.bodyElements.length - 1; i >= 0; i--) {
@@ -2820,6 +3003,30 @@ class Document {
     createMultiLevelList() {
         return this.numberingManager.createMultiLevelList();
     }
+    addBulletListFromArray(items, formatting) {
+        if (items.length === 0)
+            return [];
+        const numId = this.createBulletList();
+        return this.addListItems(numId, items, formatting);
+    }
+    addNumberedListFromArray(items, formatting) {
+        if (items.length === 0)
+            return [];
+        const numId = this.createNumberedList();
+        return this.addListItems(numId, items, formatting);
+    }
+    addListItems(numId, items, formatting) {
+        const paragraphs = [];
+        for (const item of items) {
+            const text = typeof item === 'string' ? item : item.text;
+            const level = typeof item === 'string' ? 0 : (item.level ?? 0);
+            const para = this.createParagraph();
+            para.addText(text, formatting);
+            para.setNumbering(numId, level);
+            paragraphs.push(para);
+        }
+        return paragraphs;
+    }
     restartNumbering(numId, level, startValue) {
         return this.numberingManager.restartNumbering(numId, level, startValue);
     }
@@ -3041,6 +3248,14 @@ class Document {
         }
         return runs;
     }
+    static stripThemeFontsIfExplicitFont(runConfig) {
+        if (runConfig?.font) {
+            delete runConfig.fontAsciiTheme;
+            delete runConfig.fontHAnsiTheme;
+            delete runConfig.fontEastAsiaTheme;
+            delete runConfig.fontCsTheme;
+        }
+    }
     applyStyles(options) {
         const results = {
             heading1: false,
@@ -3109,6 +3324,11 @@ class Document {
                 ...options?.listParagraph?.paragraph,
             },
         };
+        Document.stripThemeFontsIfExplicitFont(h1Config.run);
+        Document.stripThemeFontsIfExplicitFont(h2Config.run);
+        Document.stripThemeFontsIfExplicitFont(h3Config.run);
+        Document.stripThemeFontsIfExplicitFont(normalConfig.run);
+        Document.stripThemeFontsIfExplicitFont(listParaConfig.run);
         const preserveBlankLines = options?.preserveBlankLinesAfterHeading2Tables ?? true;
         if (heading1 && h1Config.run && h1Config.paragraph) {
             if (h1Config.run)
@@ -3773,12 +3993,12 @@ class Document {
         }
         let updateCount = 0;
         const fillPattern = new RegExp(`(w:fill=["'])${normalizedOld}(["'])`, 'gi');
-        stylesXml = stylesXml.replace(fillPattern, (match, prefix, suffix) => {
+        stylesXml = stylesXml.replace(fillPattern, (_match, prefix, suffix) => {
             updateCount++;
             return `${prefix}${normalizedNew}${suffix}`;
         });
         const colorPattern = new RegExp(`(<w:shd[^>]*w:color=["'])${normalizedOld}(["'])`, 'gi');
-        stylesXml = stylesXml.replace(colorPattern, (match, prefix, suffix) => {
+        stylesXml = stylesXml.replace(colorPattern, (_match, prefix, suffix) => {
             updateCount++;
             return `${prefix}${normalizedNew}${suffix}`;
         });
@@ -3804,21 +4024,6 @@ class Document {
         }
         return totalUpdated;
     }
-    processConsecutiveBlanks(blanks, keepOne, toRemove) {
-        if (blanks.length === 0)
-            return;
-        if (keepOne && blanks.length > 1) {
-            for (let i = 1; i < blanks.length; i++) {
-                const blank = blanks[i];
-                if (blank) {
-                    toRemove.push(blank);
-                }
-            }
-        }
-        else if (!keepOne) {
-            toRemove.push(...blanks);
-        }
-    }
     standardizeBulletSymbols(options) {
         const { bold = false, fontSize = 24, color = '000000', font = 'Arial', } = options || {};
         let listsUpdated = 0;
@@ -4108,7 +4313,6 @@ class Document {
     parseTOCFieldInstruction(instrText) {
         const levels = new Set();
         let hasOutlineSwitch = false;
-        let hasTableSwitch = false;
         const normalizedText = instrText.trim().replace(/&quot;/g, '"');
         const outlineMatch = /\\o\s+(?:"(\d+)-(\d+)"|'(\d+)-(\d+)'|(\d+)-(\d+))/.exec(normalizedText);
         if (outlineMatch) {
@@ -4132,7 +4336,6 @@ class Document {
         const tSwitchRegex = /\\t\s+"([^"]*)"/g;
         const tMatches = [...normalizedText.matchAll(tSwitchRegex)];
         for (const match of tMatches) {
-            hasTableSwitch = true;
             const content = (match[1] || '').trim();
             if (!content)
                 continue;
@@ -4479,34 +4682,6 @@ class Document {
         }
         return headings;
     }
-    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 = /Heading\s*(\d+)/i.exec(formatting.style);
-                    if (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>';
@@ -5263,6 +5438,9 @@ class Document {
                     return true;
                 }
             }
+            if (item instanceof PreservedElement_1.PreservedElement && item.getRawXml().includes('w:anchor="_top"')) {
+                return true;
+            }
         }
         return false;
     }
@@ -5630,6 +5808,40 @@ class Document {
         this._settingsModified = true;
         this._modifiedBooleanSettings.add('defaultTabStop');
     }
+    setDefaultFont(fontName, sizeInPoints) {
+        let normalStyle = this.stylesManager.getStyle('Normal');
+        if (!normalStyle) {
+            normalStyle = new Style_1.Style({
+                styleId: 'Normal',
+                name: 'Normal',
+                type: 'paragraph',
+                isDefault: true,
+            });
+            this.stylesManager.addStyle(normalStyle);
+        }
+        const existing = normalStyle.getRunFormatting() ?? {};
+        const updated = { ...existing, font: fontName };
+        if (sizeInPoints !== undefined) {
+            updated.size = sizeInPoints;
+        }
+        normalStyle.setRunFormatting(updated);
+        return this;
+    }
+    setDefaultFontSize(sizeInPoints) {
+        let normalStyle = this.stylesManager.getStyle('Normal');
+        if (!normalStyle) {
+            normalStyle = new Style_1.Style({
+                styleId: 'Normal',
+                name: 'Normal',
+                type: 'paragraph',
+                isDefault: true,
+            });
+            this.stylesManager.addStyle(normalStyle);
+        }
+        const existing = normalStyle.getRunFormatting() ?? {};
+        normalStyle.setRunFormatting({ ...existing, size: sizeInPoints });
+        return this;
+    }
     getUpdateFields() {
         return this._updateFields ?? false;
     }
@@ -6069,6 +6281,10 @@ class Document {
         }
         return count;
     }
+    clear() {
+        this.bodyElements = [];
+        return this;
+    }
     dispose() {
         this.bodyElements = [];
         this.parser.clearParseErrors();
@@ -6751,6 +6967,33 @@ class Document {
         }
         return trackChanges ? { count, revisions } : { count };
     }
+    fillTemplate(data, options) {
+        const [open, close] = options?.delimiters ?? ['{{', '}}'];
+        let totalCount = 0;
+        const allParagraphs = this.getAllParagraphs();
+        for (const [key, value] of Object.entries(data)) {
+            const placeholder = `${open}${key}${close}`;
+            for (const para of allParagraphs) {
+                totalCount += para.replaceTextCrossRun(placeholder, value);
+            }
+        }
+        return totalCount;
+    }
+    findAndHighlight(text, color = 'yellow', options) {
+        return this.findAndFormat(text, { highlight: color }, options);
+    }
+    findAndFormat(text, formatting, options) {
+        let totalMatches = 0;
+        for (const para of this.getAllParagraphs()) {
+            const matches = para.findTextCrossRun(text, options);
+            for (let i = matches.length - 1; i >= 0; i--) {
+                const match = matches[i];
+                para.applyFormattingToRange(match.offset, match.offset + match.text.length, formatting);
+            }
+            totalMatches += matches.length;
+        }
+        return totalMatches;
+    }
     getWordCount() {
         let totalWords = 0;
         const countedParagraphs = new Set();
@@ -6825,6 +7068,425 @@ class Document {
         }
         return totalChars;
     }
+    getStatistics() {
+        const allParagraphs = this.getAllParagraphs();
+        const tables = this.getTables();
+        let words = 0;
+        let characters = 0;
+        let charactersNoSpaces = 0;
+        let headings = 0;
+        let lists = 0;
+        const counted = new Set();
+        for (const para of allParagraphs) {
+            if (counted.has(para))
+                continue;
+            counted.add(para);
+            const text = para.getText();
+            characters += text.length;
+            charactersNoSpaces += text.replace(/\s/g, '').length;
+            const trimmed = text.trim();
+            if (trimmed) {
+                words += trimmed.split(/\s+/).filter((w) => w.length > 0).length;
+            }
+            if (para.detectHeadingLevel() !== null)
+                headings++;
+            if (para.hasNumbering())
+                lists++;
+        }
+        for (const table of tables) {
+            for (const row of table.getRows()) {
+                for (const cell of row.getCells()) {
+                    for (const para of cell.getParagraphs()) {
+                        if (counted.has(para))
+                            continue;
+                        counted.add(para);
+                        const text = para.getText();
+                        characters += text.length;
+                        charactersNoSpaces += text.replace(/\s/g, '').length;
+                        const trimmed = text.trim();
+                        if (trimmed) {
+                            words += trimmed.split(/\s+/).filter((w) => w.length > 0).length;
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            words,
+            characters,
+            charactersNoSpaces,
+            paragraphs: allParagraphs.length,
+            tables: tables.length,
+            images: this.imageManager.getAllImages().length,
+            headings,
+            lists,
+            hyperlinks: this.getHyperlinks().length,
+            bookmarks: this.bookmarkManager.getAllBookmarks().length,
+            footnotes: this.footnoteManager.getAllFootnotes().length,
+            endnotes: this.endnoteManager.getAllEndnotes().length,
+            comments: this.commentManager.getAllComments().length,
+            sections: 1,
+        };
+    }
+    forEachParagraph(callback) {
+        let count = 0;
+        let paraIndex = 0;
+        for (const element of this.bodyElements) {
+            if (element instanceof Paragraph_1.Paragraph) {
+                const result = callback(element, paraIndex);
+                count++;
+                paraIndex++;
+                if (result === false)
+                    break;
+            }
+        }
+        return count;
+    }
+    forEachTable(callback) {
+        let count = 0;
+        let tableIndex = 0;
+        for (const element of this.bodyElements) {
+            if (element instanceof Table_1.Table) {
+                const result = callback(element, tableIndex);
+                count++;
+                tableIndex++;
+                if (result === false)
+                    break;
+            }
+        }
+        return count;
+    }
+    toPlainText(separator = '\n') {
+        const paragraphs = this.getAllParagraphs();
+        return paragraphs.map((p) => p.getText()).join(separator);
+    }
+    toMarkdown() {
+        const lines = [];
+        for (const element of this.bodyElements) {
+            if (element instanceof Paragraph_1.Paragraph) {
+                const mdLine = this.paragraphToMarkdown(element);
+                if (mdLine !== null) {
+                    lines.push(mdLine);
+                    lines.push('');
+                }
+            }
+            else if (element instanceof Table_1.Table) {
+                lines.push(...this.tableToMarkdown(element));
+                lines.push('');
+            }
+        }
+        while (lines.length > 0 && lines[lines.length - 1] === '') {
+            lines.pop();
+        }
+        return lines.join('\n');
+    }
+    paragraphToMarkdown(para) {
+        const text = this.paragraphContentToMarkdown(para);
+        if (!text && !para.hasNumbering())
+            return null;
+        const headingLevel = para.detectHeadingLevel();
+        if (headingLevel !== null && headingLevel >= 1 && headingLevel <= 6) {
+            return '#'.repeat(headingLevel) + ' ' + text;
+        }
+        if (para.hasNumbering()) {
+            const style = para.getStyle();
+            const isBullet = style?.toLowerCase().includes('bullet') || style?.toLowerCase().includes('list bullet');
+            return isBullet ? `- ${text}` : `1. ${text}`;
+        }
+        return text;
+    }
+    paragraphContentToMarkdown(para) {
+        const parts = [];
+        for (const item of para.getContent()) {
+            if (item instanceof Run_1.Run) {
+                const runText = item.getText();
+                if (!runText)
+                    continue;
+                const fmt = item.getFormatting();
+                let md = runText;
+                if (fmt.bold && fmt.italic) {
+                    md = `***${md}***`;
+                }
+                else if (fmt.bold) {
+                    md = `**${md}**`;
+                }
+                else if (fmt.italic) {
+                    md = `*${md}*`;
+                }
+                if (fmt.strike) {
+                    md = `~~${md}~~`;
+                }
+                if (fmt.font &&
+                    /^(courier|consolas|monaco|menlo|source code|fira code|jetbrains mono)/i.test(fmt.font)) {
+                    md = `\`${runText}\``;
+                }
+                parts.push(md);
+            }
+            else if (item instanceof Hyperlink_1.Hyperlink) {
+                const url = item.getUrl() || '';
+                const linkText = item.getText() || url;
+                parts.push(`[${linkText}](${url})`);
+            }
+        }
+        return parts.join('');
+    }
+    tableToMarkdown(table) {
+        const data = table.toArray();
+        if (data.length === 0)
+            return [];
+        const colCount = Math.max(...data.map((row) => row.length));
+        if (colCount === 0)
+            return [];
+        const normalized = data.map((row) => {
+            const padded = [...row];
+            while (padded.length < colCount)
+                padded.push('');
+            return padded.map((cell) => cell.replace(/\|/g, '\\|').replace(/\n/g, ' ').trim());
+        });
+        const lines = [];
+        lines.push('| ' + normalized[0].join(' | ') + ' |');
+        lines.push('| ' + normalized[0].map(() => '---').join(' | ') + ' |');
+        for (let i = 1; i < normalized.length; i++) {
+            lines.push('| ' + normalized[i].join(' | ') + ' |');
+        }
+        return lines;
+    }
+    toHTML(options) {
+        const parts = [];
+        let inList = null;
+        const closeList = () => {
+            if (inList) {
+                parts.push(`</${inList}>`);
+                inList = null;
+            }
+        };
+        for (const element of this.bodyElements) {
+            if (element instanceof Paragraph_1.Paragraph) {
+                const headingLevel = element.detectHeadingLevel();
+                const style = element.getStyle();
+                const isBullet = style?.toLowerCase().includes('bullet') || style === 'ListBullet';
+                const isNumber = style?.toLowerCase().includes('listnumber') ||
+                    style?.toLowerCase().includes('list number') ||
+                    style === 'ListNumber';
+                if (isBullet || isNumber) {
+                    const listType = isBullet ? 'ul' : 'ol';
+                    if (inList !== listType) {
+                        closeList();
+                        inList = listType;
+                        parts.push(`<${listType}>`);
+                    }
+                    parts.push(`<li>${this.paragraphContentToHTML(element)}</li>`);
+                    continue;
+                }
+                closeList();
+                if (headingLevel !== null && headingLevel >= 1 && headingLevel <= 6) {
+                    parts.push(`<h${headingLevel}>${this.paragraphContentToHTML(element)}</h${headingLevel}>`);
+                }
+                else {
+                    const content = this.paragraphContentToHTML(element);
+                    if (content) {
+                        parts.push(`<p>${content}</p>`);
+                    }
+                }
+            }
+            else if (element instanceof Table_1.Table) {
+                closeList();
+                parts.push(this.tableToHTML(element));
+            }
+        }
+        closeList();
+        const body = parts.join('\n');
+        if (options?.wrapInDocument) {
+            const title = options.title ? this.escapeHTML(options.title) : 'Document';
+            return [
+                '<!DOCTYPE html>',
+                '<html>',
+                '<head>',
+                `<meta charset="utf-8">`,
+                `<title>${title}</title>`,
+                '</head>',
+                '<body>',
+                body,
+                '</body>',
+                '</html>',
+            ].join('\n');
+        }
+        return body;
+    }
+    paragraphContentToHTML(para) {
+        const parts = [];
+        for (const item of para.getContent()) {
+            if (item instanceof Run_1.Run) {
+                const text = item.getText();
+                if (!text)
+                    continue;
+                const escaped = this.escapeHTML(text);
+                const fmt = item.getFormatting();
+                const isMono = fmt.font &&
+                    /^(courier|consolas|monaco|menlo|source code|fira code|jetbrains mono)/i.test(fmt.font);
+                if (isMono) {
+                    parts.push(`<code>${escaped}</code>`);
+                    continue;
+                }
+                let html = escaped;
+                if (fmt.bold)
+                    html = `<strong>${html}</strong>`;
+                if (fmt.italic)
+                    html = `<em>${html}</em>`;
+                if (fmt.strike)
+                    html = `<s>${html}</s>`;
+                if (fmt.underline && fmt.underline !== 'none') {
+                    html = `<u>${html}</u>`;
+                }
+                parts.push(html);
+            }
+            else if (item instanceof Hyperlink_1.Hyperlink) {
+                const url = this.escapeHTML(item.getUrl() || '');
+                const linkText = this.escapeHTML(item.getText() || url);
+                parts.push(`<a href="${url}">${linkText}</a>`);
+            }
+        }
+        return parts.join('');
+    }
+    tableToHTML(table) {
+        const rows = table.getRows();
+        if (rows.length === 0)
+            return '';
+        const lines = ['<table>'];
+        const headerCells = rows[0].getCells();
+        lines.push('<thead>');
+        lines.push('<tr>');
+        for (const cell of headerCells) {
+            lines.push(`<th>${this.escapeHTML(cell.getText())}</th>`);
+        }
+        lines.push('</tr>');
+        lines.push('</thead>');
+        if (rows.length > 1) {
+            lines.push('<tbody>');
+            for (let r = 1; r < rows.length; r++) {
+                lines.push('<tr>');
+                for (const cell of rows[r].getCells()) {
+                    lines.push(`<td>${this.escapeHTML(cell.getText())}</td>`);
+                }
+                lines.push('</tr>');
+            }
+            lines.push('</tbody>');
+        }
+        lines.push('</table>');
+        return lines.join('\n');
+    }
+    escapeHTML(text) {
+        return text
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;');
+    }
+    toJSON() {
+        const paragraphs = this.getAllParagraphs();
+        const tables = this.getTables();
+        const headings = this.getHeadingHierarchy();
+        return {
+            properties: this.getProperties(),
+            stats: {
+                paragraphs: paragraphs.length,
+                tables: tables.length,
+                images: this.imageManager.getImageCount(),
+                headings: headings.length,
+                sections: this.bodyElements.filter((el) => el instanceof Section_1.Section).length || 1,
+            },
+            headings: headings.map((h) => ({ level: h.level, text: h.text })),
+            body: this.bodyElements.map((el) => {
+                if (el instanceof Paragraph_1.Paragraph) {
+                    return {
+                        type: 'paragraph',
+                        text: el.getText(),
+                        style: el.getStyle(),
+                    };
+                }
+                if (el instanceof Table_1.Table) {
+                    return {
+                        type: 'table',
+                        text: `${el.getRows().length} rows x ${el.getRows()[0]?.getCells().length ?? 0} cols`,
+                    };
+                }
+                return { type: el.constructor.name };
+            }),
+        };
+    }
+    findImagesWithoutAltText() {
+        const results = [];
+        for (const para of this.getAllParagraphs()) {
+            for (const item of para.getContent()) {
+                if (item instanceof ImageRun_1.ImageRun) {
+                    const image = item.getImageElement();
+                    const altText = image.getAltText();
+                    if (!altText || altText === 'Image') {
+                        results.push(image);
+                    }
+                }
+                if (item instanceof Revision_1.Revision) {
+                    for (const revContent of item.getContent()) {
+                        if (revContent instanceof ImageRun_1.ImageRun) {
+                            const image = revContent.getImageElement();
+                            const altText = image.getAltText();
+                            if (!altText || altText === 'Image') {
+                                results.push(image);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return results;
+    }
+    getHeadingHierarchy() {
+        const results = [];
+        for (const para of this.getAllParagraphs()) {
+            const level = para.detectHeadingLevel();
+            if (level !== null) {
+                results.push({
+                    level,
+                    text: para.getText(),
+                    paragraph: para,
+                });
+            }
+        }
+        return results;
+    }
+    extractByHeading(maxLevel = 1) {
+        const sections = [];
+        let current = {
+            heading: undefined,
+            level: 0,
+            content: [],
+        };
+        for (const element of this.bodyElements) {
+            if (element instanceof Paragraph_1.Paragraph) {
+                const headingLevel = element.detectHeadingLevel();
+                if (headingLevel !== null && headingLevel <= maxLevel) {
+                    if (current.heading || current.content.length > 0) {
+                        sections.push(current);
+                    }
+                    current = { heading: element, level: headingLevel, content: [] };
+                    continue;
+                }
+            }
+            current.content.push(element);
+        }
+        if (current.heading || current.content.length > 0) {
+            sections.push(current);
+        }
+        return sections;
+    }
+    getElementsBetween(startElement, endElement) {
+        const startIndex = this.bodyElements.indexOf(startElement);
+        const endIndex = this.bodyElements.indexOf(endElement);
+        if (startIndex === -1 || endIndex === -1 || startIndex >= endIndex) {
+            return [];
+        }
+        return this.bodyElements.slice(startIndex + 1, endIndex);
+    }
     removeParagraph(paragraphOrIndex) {
         let index;
         if (typeof paragraphOrIndex === 'number') {
@@ -7032,6 +7694,34 @@ class Document {
         }
         return false;
     }
+    removeElement(element) {
+        const index = this.bodyElements.indexOf(element);
+        if (index === -1)
+            return false;
+        this.bodyElements.splice(index, 1);
+        return true;
+    }
+    insertAfter(reference, element) {
+        const index = this.bodyElements.indexOf(reference);
+        if (index === -1)
+            return false;
+        this.bodyElements.splice(index + 1, 0, element);
+        return true;
+    }
+    insertBefore(reference, element) {
+        const index = this.bodyElements.indexOf(reference);
+        if (index === -1)
+            return false;
+        this.bodyElements.splice(index, 0, element);
+        return true;
+    }
+    replaceElement(oldElement, newElement) {
+        const index = this.bodyElements.indexOf(oldElement);
+        if (index === -1)
+            return false;
+        this.bodyElements[index] = newElement;
+        return true;
+    }
     insertBodyElementAt(index, element) {
         const clampedIndex = Math.max(0, Math.min(index, this.bodyElements.length));
         this.bodyElements.splice(clampedIndex, 0, element);