docxmlater 11.0.10 → 12.1.0

package/dist/esm/core/Document.js

@@ -35,10 +35,11 @@ import { UNITS } from '../utils/units.js';
 function getLogger() {
     return createScopedLogger(getGlobalLogger(), 'Document');
 }
-import { acceptAllRevisions, cleanupRevisionMetadata } from '../processors/acceptRevisions.js';
+import { acceptAllRevisions, rejectAllRevisions, cleanupRevisionMetadata, } from '../processors/acceptRevisions.js';
 import { acceptRevisionsInMemory } from '../processors/InMemoryRevisionAcceptor.js';
 import { stripTrackedChanges } from '../processors/stripTrackedChanges.js';
 import { diffText, diffHasUnchangedParts } from '../utils/textDiff.js';
+import { reorderRunPropertyChildren } from '../utils/xmlSanitization.js';
 import { XMLBuilder } from '../xml/XMLBuilder.js';
 import { XMLParser } from '../xml/XMLParser.js';
 import { DocumentTrackingContext } from '../tracking/DocumentTrackingContext.js';
@@ -50,7 +51,7 @@ import { DocumentParser } from './DocumentParser.js';
 import { DocumentValidator } from './DocumentValidator.js';
 import { DocumentEventEmitter, } from './DocumentEvents.js';
 import { RelationshipManager } from './RelationshipManager.js';
-import { RelationshipType } from './Relationship.js';
+import { Relationship, RelationshipType } from './Relationship.js';
 import { optimizeImage } from '../images/ImageOptimizer.js';
 export class Document {
     constructor(zipHandler, options = {}, initDefaults = true) {
@@ -75,6 +76,9 @@ export class Document {
         this.bookmarkManager.setIdProvider(() => this.documentIdManager.getNextId(), (existingId) => this.documentIdManager.ensureNextIdAbove(existingId));
         this.revisionManager.setIdProvider(() => this.documentIdManager.getNextId(), (existingId) => this.documentIdManager.ensureNextIdAbove(existingId));
         this.commentManager.setIdProvider(() => this.documentIdManager.getNextId(), (existingId) => this.documentIdManager.ensureNextIdAbove(existingId));
+        this.commentManager.setModifiedNotifier(() => {
+            this._commentsModified = true;
+        });
         this.trackingContext = new DocumentTrackingContext(this.revisionManager);
         this.parser = new DocumentParser();
         this.generator = new DocumentGenerator();
@@ -129,6 +133,7 @@ export class Document {
     _originalNumberingXml;
     _originalSettingsXml;
     _originalAppPropsXml;
+    _originalCorePropsXml;
     _originalFootnotesXml;
     _originalEndnotesXml;
     _originalCommentsXml;
@@ -138,6 +143,7 @@ export class Document {
     _saveQueue = Promise.resolve();
     _removedParts = new Set();
     _appPropsModified = false;
+    _corePropsModified = false;
     _footnotesModified = false;
     _endnotesModified = false;
     _settingsModified = false;
@@ -337,7 +343,7 @@ export class Document {
         const logger = getLogger();
         logger.info('Loading document from file', { path: filePath });
         const zipHandler = new ZipHandler();
-        await zipHandler.load(filePath);
+        await zipHandler.load(filePath, { sizeLimits: options?.sizeLimits });
         const doc = await Document.initializeFromZip(zipHandler, options);
         doc._events.emit('afterLoad', { source: 'file', path: filePath });
         return doc;
@@ -346,7 +352,7 @@ export class Document {
         const logger = getLogger();
         logger.info('Loading document from buffer', { bufferSize: buffer.length });
         const zipHandler = new ZipHandler();
-        await zipHandler.loadFromBuffer(buffer);
+        await zipHandler.loadFromBuffer(buffer, { sizeLimits: options?.sizeLimits });
         const doc = await Document.initializeFromZip(zipHandler, options);
         doc._events.emit('afterLoad', { source: 'buffer' });
         return doc;
@@ -354,12 +360,20 @@ export class Document {
     static async initializeFromZip(zipHandler, options) {
         const logger = getLogger();
         const useInMemoryAccept = options?.acceptRevisions === true;
+        if (useInMemoryAccept && options?.revisionHandling === 'reject') {
+            throw new Error("Conflicting load options: 'acceptRevisions: true' (in-memory accept) cannot be combined " +
+                'with \'revisionHandling: "reject"\'. Use \'revisionHandling: "reject"\' on its own to ' +
+                'revert the document to its original pre-edit state.');
+        }
         const revisionHandling = useInMemoryAccept
             ? 'preserve'
             : (options?.revisionHandling ?? 'accept');
         if (revisionHandling === 'accept') {
             await acceptAllRevisions(zipHandler);
         }
+        else if (revisionHandling === 'reject') {
+            await rejectAllRevisions(zipHandler);
+        }
         else if (revisionHandling === 'strip') {
             await stripTrackedChanges(zipHandler);
         }
@@ -386,7 +400,7 @@ export class Document {
         }
         const numberingXml = zipHandler.getFileAsString(DOCX_PATHS.NUMBERING);
         if (numberingXml) {
-            doc._originalNumberingXml = numberingXml;
+            doc._originalNumberingXml = reorderRunPropertyChildren(numberingXml);
         }
         const settingsXml = zipHandler.getFileAsString(DOCX_PATHS.SETTINGS);
         if (settingsXml) {
@@ -397,6 +411,10 @@ export class Document {
         if (appPropsXml) {
             doc._originalAppPropsXml = appPropsXml;
         }
+        const corePropsXml = zipHandler.getFileAsString(DOCX_PATHS.CORE_PROPS);
+        if (corePropsXml) {
+            doc._originalCorePropsXml = corePropsXml;
+        }
         const webSettingsXml = zipHandler.getFileAsString(DOCX_PATHS.WEB_SETTINGS);
         if (webSettingsXml) {
             doc._originalWebSettingsXml = webSettingsXml;
@@ -659,17 +677,17 @@ export class Document {
         try {
             const headersFooters = await this.parser.parseHeadersAndFooters(this.zipHandler, result.section, this.relationshipManager, this.imageManager);
             const registeredHeaderRIds = new Set();
-            for (const { header, relationshipId } of headersFooters.headers) {
+            for (const { header, relationshipId, filename } of headersFooters.headers) {
                 if (registeredHeaderRIds.has(relationshipId))
                     continue;
-                this.headerFooterManager.registerHeader(header, relationshipId);
+                this.headerFooterManager.registerHeader(header, relationshipId, filename);
                 registeredHeaderRIds.add(relationshipId);
             }
             const registeredFooterRIds = new Set();
-            for (const { footer, relationshipId } of headersFooters.footers) {
+            for (const { footer, relationshipId, filename } of headersFooters.footers) {
                 if (registeredFooterRIds.has(relationshipId))
                     continue;
-                this.headerFooterManager.registerFooter(footer, relationshipId);
+                this.headerFooterManager.registerFooter(footer, relationshipId, filename);
                 registeredFooterRIds.add(relationshipId);
             }
         }
@@ -712,7 +730,7 @@ export class Document {
             }
         }
         const parser = new DocumentParser();
-        const comments = parser.parseCommentsXml(commentsXml);
+        const comments = parser.parseCommentsXml(commentsXml, this._originalCommentCompanionFiles.get(DOCX_PATHS.COMMENTS_EXTENDED));
         for (const comment of comments) {
             this.commentManager.registerExisting(comment);
         }
@@ -726,7 +744,9 @@ export class Document {
         this._originalFootnotesXml = footnotesXml;
         try {
             const parser = new DocumentParser();
-            const footnotes = parser.parseFootnotesXml(footnotesXml);
+            const relsXml = this.zipHandler.getFileAsString('word/_rels/footnotes.xml.rels');
+            const partRels = relsXml ? RelationshipManager.fromXml(relsXml) : undefined;
+            const footnotes = parser.parseFootnotesXml(footnotesXml, partRels);
             for (const footnote of footnotes) {
                 const id = footnote.getId();
                 if (!this.footnoteManager.hasFootnote(id)) {
@@ -748,7 +768,9 @@ export class Document {
         this._originalEndnotesXml = endnotesXml;
         try {
             const parser = new DocumentParser();
-            const endnotes = parser.parseEndnotesXml(endnotesXml);
+            const relsXml = this.zipHandler.getFileAsString('word/_rels/endnotes.xml.rels');
+            const partRels = relsXml ? RelationshipManager.fromXml(relsXml) : undefined;
+            const endnotes = parser.parseEndnotesXml(endnotesXml, partRels);
             for (const endnote of endnotes) {
                 const id = endnote.getId();
                 if (!this.endnoteManager.hasEndnote(id)) {
@@ -840,12 +862,13 @@ export class Document {
         paragraph._setStylesManager(this.stylesManager);
         if (this.trackChangesEnabled && this.trackingContext.isEnabled()) {
             this.bindTrackingToElement(paragraph);
-            const runs = paragraph.getRuns();
-            if (runs.length > 0) {
-                const author = this.trackingContext.getAuthor();
-                const insertion = Revision.createInsertion(author, runs);
-                this.trackingContext.getRevisionManager().register(insertion);
-                paragraph.addRevision(insertion);
+            const author = this.trackingContext.getAuthor();
+            for (const item of paragraph.getContent()) {
+                if (item instanceof Run || item instanceof Hyperlink) {
+                    const insertion = Revision.createInsertion(author, item);
+                    this.trackingContext.getRevisionManager().register(insertion);
+                    paragraph.replaceContent(item, [insertion]);
+                }
             }
         }
         this.bodyElements.push(paragraph);
@@ -1061,14 +1084,17 @@ export class Document {
     }
     setTitle(title) {
         this.properties.title = title;
+        this._corePropsModified = true;
         return this;
     }
     setSubject(subject) {
         this.properties.subject = subject;
+        this._corePropsModified = true;
         return this;
     }
     setCreator(creator) {
         this.properties.creator = creator;
+        this._corePropsModified = true;
         return this;
     }
     setAuthor(author) {
@@ -1076,18 +1102,22 @@ export class Document {
     }
     setKeywords(keywords) {
         this.properties.keywords = keywords;
+        this._corePropsModified = true;
         return this;
     }
     setDescription(description) {
         this.properties.description = description;
+        this._corePropsModified = true;
         return this;
     }
     setCategory(category) {
         this.properties.category = category;
+        this._corePropsModified = true;
         return this;
     }
     setContentStatus(status) {
         this.properties.contentStatus = status;
+        this._corePropsModified = true;
         return this;
     }
     setApplication(application) {
@@ -1534,8 +1564,48 @@ export class Document {
         if (this._removedParts.has(DOCX_PATHS.CORE_PROPS) ||
             this._removedParts.has('docProps/core.xml'))
             return;
-        const xml = this.generator.generateCoreProps(this.properties);
-        this.zipHandler.updateFile(DOCX_PATHS.CORE_PROPS, xml);
+        if (this._originalCorePropsXml && !this._corePropsModified) {
+            return;
+        }
+        if (this._originalCorePropsXml && this._corePropsModified) {
+            const mergedXml = this.mergeCorePropsWithOriginal();
+            this.zipHandler.updateFile(DOCX_PATHS.CORE_PROPS, mergedXml);
+        }
+        else {
+            const xml = this.generator.generateCoreProps(this.properties);
+            this.zipHandler.updateFile(DOCX_PATHS.CORE_PROPS, xml);
+        }
+    }
+    mergeCorePropsWithOriginal() {
+        if (!this._originalCorePropsXml) {
+            return this.generator.generateCoreProps(this.properties);
+        }
+        let xml = this._originalCorePropsXml;
+        const mergeField = (tag, value) => {
+            if (value === undefined)
+                return;
+            const escaped = XMLBuilder.sanitizeXmlContent(value);
+            const openClose = new RegExp(`<${tag}\\b[^>]*>[\\s\\S]*?</${tag}>`);
+            const selfClosing = new RegExp(`<${tag}\\b[^>]*/>`);
+            if (openClose.test(xml)) {
+                xml = xml.replace(openClose, `<${tag}>${escaped}</${tag}>`);
+            }
+            else if (selfClosing.test(xml)) {
+                xml = xml.replace(selfClosing, `<${tag}>${escaped}</${tag}>`);
+            }
+            else {
+                xml = xml.replace(/<\/cp:coreProperties>/, `  <${tag}>${escaped}</${tag}>\n</cp:coreProperties>`);
+            }
+        };
+        mergeField('dc:title', this.properties.title);
+        mergeField('dc:subject', this.properties.subject);
+        mergeField('dc:creator', this.properties.creator);
+        mergeField('cp:keywords', this.properties.keywords);
+        mergeField('dc:description', this.properties.description);
+        mergeField('cp:category', this.properties.category);
+        mergeField('cp:contentStatus', this.properties.contentStatus);
+        mergeField('dc:language', this.properties.language);
+        return xml;
     }
     updateAppProps() {
         if (this._removedParts.has(DOCX_PATHS.APP_PROPS) || this._removedParts.has('docProps/app.xml'))
@@ -1565,24 +1635,36 @@ export class Document {
             else if (xml.includes('<Company/>')) {
                 xml = xml.replace(/<Company\/>/, `<Company>${escaped}</Company>`);
             }
+            else {
+                xml = xml.replace(/<\/Properties>/, `  <Company>${escaped}</Company>\n</Properties>`);
+            }
         }
         if (this.properties.application !== undefined) {
             const escaped = XMLBuilder.sanitizeXmlContent(this.properties.application);
             if (xml.includes('<Application>')) {
                 xml = xml.replace(/<Application>[^<]*<\/Application>/, `<Application>${escaped}</Application>`);
             }
+            else {
+                xml = xml.replace(/<\/Properties>/, `  <Application>${escaped}</Application>\n</Properties>`);
+            }
         }
         if (this.properties.appVersion !== undefined) {
             const escaped = XMLBuilder.sanitizeXmlContent(this.properties.appVersion);
             if (xml.includes('<AppVersion>')) {
                 xml = xml.replace(/<AppVersion>[^<]*<\/AppVersion>/, `<AppVersion>${escaped}</AppVersion>`);
             }
+            else {
+                xml = xml.replace(/<\/Properties>/, `  <AppVersion>${escaped}</AppVersion>\n</Properties>`);
+            }
         }
         if (this.properties.manager !== undefined) {
             const escaped = XMLBuilder.sanitizeXmlContent(this.properties.manager);
             if (xml.includes('<Manager>')) {
                 xml = xml.replace(/<Manager>[^<]*<\/Manager>/, `<Manager>${escaped}</Manager>`);
             }
+            else {
+                xml = xml.replace(/<\/Properties>/, `  <Manager>${escaped}</Manager>\n</Properties>`);
+            }
         }
         return xml;
     }
@@ -1708,7 +1790,8 @@ export class Document {
             return this.stylesManager.generateStylesXml();
         }
         const modifiedStyleIds = this.stylesManager.getModifiedStyleIds();
-        if (modifiedStyleIds.size === 0) {
+        const removedStyleIds = this.stylesManager.getRemovedStyleIds();
+        if (modifiedStyleIds.size === 0 && removedStyleIds.size === 0) {
             return this._originalStylesXml;
         }
         const modifiedStyles = new Map();
@@ -1730,6 +1813,11 @@ export class Document {
                 resultXml = resultXml.replace('</w:styles>', `${newStyleXml}\n</w:styles>`);
             }
         }
+        for (const styleId of removedStyleIds) {
+            const escapedStyleId = styleId.replace(/[.*+?^${}()|[\]\\"]/g, '\\$&');
+            const removedPattern = new RegExp(`\\s*<w:style[^>]*\\sw:styleId="${escapedStyleId}"[^>]*>[\\s\\S]*?</w:style>`);
+            resultXml = resultXml.replace(removedPattern, '');
+        }
         return resultXml;
     }
     updateNumberingXml() {
@@ -1928,8 +2016,14 @@ export class Document {
         xml = xml.replace(/<w:revisionView\b[^>]*>[\s\S]*?<\/w:revisionView>/g, '');
         let trackBlock = '';
         const view = this.revisionViewSettings;
-        if (!view.showInsertionsAndDeletions || !view.showFormatting || !view.showInkAnnotations) {
-            trackBlock += `\n  <w:revisionView w:insDel="${view.showInsertionsAndDeletions ? '1' : '0'}" w:formatting="${view.showFormatting ? '1' : '0'}" w:inkAnnotations="${view.showInkAnnotations ? '1' : '0'}"/>`;
+        if (!view.showInsertionsAndDeletions ||
+            !view.showFormatting ||
+            !view.showInkAnnotations ||
+            view.showMarkup === false ||
+            view.showComments === false) {
+            const markupAttr = view.showMarkup === false ? ' w:markup="0"' : '';
+            const commentsAttr = view.showComments === false ? ' w:comments="0"' : '';
+            trackBlock += `\n  <w:revisionView w:insDel="${view.showInsertionsAndDeletions ? '1' : '0'}" w:formatting="${view.showFormatting ? '1' : '0'}" w:inkAnnotations="${view.showInkAnnotations ? '1' : '0'}"${markupAttr}${commentsAttr}/>`;
         }
         if (this.trackChangesEnabled) {
             trackBlock += '\n  <w:trackRevisions/>';
@@ -1965,6 +2059,8 @@ export class Document {
         const prot = this.documentProtection;
         const esc = XMLBuilder.escapeXmlAttribute;
         let protXml = `\n  <w:documentProtection w:edit="${esc(prot.edit)}" w:enforcement="${prot.enforcement ? '1' : '0'}"`;
+        if (prot.formatting !== undefined)
+            protXml += ` w:formatting="${prot.formatting ? '1' : '0'}"`;
         if (prot.cryptProviderType)
             protXml += ` w:cryptProviderType="${esc(prot.cryptProviderType)}"`;
         if (prot.cryptAlgorithmClass)
@@ -1979,6 +2075,12 @@ export class Document {
             protXml += ` w:hash="${esc(prot.hash)}"`;
         if (prot.salt)
             protXml += ` w:salt="${esc(prot.salt)}"`;
+        if (prot.algorithmName)
+            protXml += ` w:algorithmName="${esc(prot.algorithmName)}"`;
+        if (prot.hashValue)
+            protXml += ` w:hashValue="${esc(prot.hashValue)}"`;
+        if (prot.saltValue)
+            protXml += ` w:saltValue="${esc(prot.saltValue)}"`;
         protXml += '/>';
         if (/<w:autoFormatOverride\b/.test(xml)) {
             xml = xml.replace(/<w:autoFormatOverride\b/, protXml + '\n  <w:autoFormatOverride');
@@ -2732,6 +2834,18 @@ export class Document {
                 }
             }
         }
+        for (const style of this.stylesManager.getAllStyles()) {
+            const styleNumId = style.getProperties().numPr?.numId;
+            if (styleNumId !== undefined) {
+                usedNumIds.add(styleNumId);
+            }
+        }
+        for (const filePath of [DOCX_PATHS.STYLES, 'word/comments.xml']) {
+            const xml = this.zipHandler.getFileAsString(filePath);
+            if (xml) {
+                this.collectNumIdsFromXml(xml, usedNumIds);
+            }
+        }
         this.numberingManager.cleanupUnusedNumbering(usedNumIds);
     }
     validateNumberingReferences() {
@@ -2833,7 +2947,67 @@ export class Document {
                 maxRevId = rev.getId();
         }
         const registeredSet = new Set(existingRevisions);
-        let docPrId = 1;
+        let maxPreservedDocPrId = 0;
+        const collectPreservedDocPrIds = (rawXml) => {
+            if (!rawXml || !rawXml.includes('wp:docPr'))
+                return;
+            const docPrPattern = /<wp:docPr\b[^>]*\bid="(\d+)"/g;
+            let match;
+            while ((match = docPrPattern.exec(rawXml)) !== null) {
+                const id = parseInt(match[1], 10);
+                if (id > maxPreservedDocPrId)
+                    maxPreservedDocPrId = id;
+            }
+        };
+        const collectFromRun = (run) => {
+            if (run instanceof ImageRun) {
+                collectPreservedDocPrIds(run.getRawRunXml());
+                return;
+            }
+            for (const contentItem of run.getContent()) {
+                collectPreservedDocPrIds(contentItem.rawXml);
+            }
+        };
+        const collectFromParagraph = (para) => {
+            for (const item of para.getContent()) {
+                if (item instanceof Revision) {
+                    for (const revItem of item.getContent()) {
+                        if (revItem instanceof Run)
+                            collectFromRun(revItem);
+                    }
+                }
+                else if (item instanceof Run) {
+                    collectFromRun(item);
+                }
+                else if (item instanceof PreservedElement) {
+                    collectPreservedDocPrIds(item.getRawXml());
+                }
+            }
+        };
+        for (const element of this.bodyElements) {
+            if (element instanceof Paragraph) {
+                collectFromParagraph(element);
+            }
+            else if (element instanceof Table) {
+                for (const row of element.getRows()) {
+                    for (const cell of row.getCells()) {
+                        for (const para of cell.getParagraphs()) {
+                            collectFromParagraph(para);
+                        }
+                        for (const nested of cell.getRawNestedContent()) {
+                            collectPreservedDocPrIds(nested.xml);
+                        }
+                    }
+                }
+            }
+            else {
+                const passthrough = element;
+                if (typeof passthrough.getRawXml === 'function') {
+                    collectPreservedDocPrIds(passthrough.getRawXml());
+                }
+            }
+        }
+        let docPrId = maxPreservedDocPrId + 1;
         const existingParaIds = new Set();
         const paragraphsNeedingIds = [];
         const generateUniqueParaId = () => {
@@ -2865,6 +3039,13 @@ export class Document {
                 else if (item instanceof ImageRun) {
                     item.getImageElement().setDocPrId(docPrId++);
                 }
+                else if (item instanceof Revision) {
+                    for (const revItem of item.getContent()) {
+                        if (revItem instanceof ImageRun) {
+                            revItem.getImageElement().setDocPrId(docPrId++);
+                        }
+                    }
+                }
             }
             if (para.formatting.paraId) {
                 existingParaIds.add(para.formatting.paraId);
@@ -3154,6 +3335,7 @@ export class Document {
                 numLevel.setLeftIndent(720 * (levelIndex + 1));
                 numLevel.setHangingIndent(360);
             }
+            this.numberingManager.markAbstractNumberingModified(abstractNumId);
             this.applyFormattingToListParagraphs(instance.getNumId());
             count++;
         }
@@ -3180,6 +3362,7 @@ export class Document {
                 numLevel.setHangingIndent(360);
                 numLevel.setAlignment('left');
             }
+            this.numberingManager.markAbstractNumberingModified(abstractNumId);
             this.applyFormattingToListParagraphs(instance.getNumId());
             count++;
         }
@@ -5002,39 +5185,39 @@ export class Document {
         return this;
     }
     setHeader(header) {
-        const relationship = this.relationshipManager.addHeader(`${header.getFilename(1)}`);
+        const relationship = this.relationshipManager.addHeader(this.headerFooterManager.peekHeaderFilename(header));
         this.headerFooterManager.registerHeader(header, relationship.getId());
         this.section.setHeaderReference('default', relationship.getId());
         return this;
     }
     setFirstPageHeader(header) {
         this.section.setTitlePage(true);
-        const relationship = this.relationshipManager.addHeader(`${header.getFilename(this.headerFooterManager.getHeaderCount() + 1)}`);
+        const relationship = this.relationshipManager.addHeader(this.headerFooterManager.peekHeaderFilename(header));
         this.headerFooterManager.registerHeader(header, relationship.getId());
         this.section.setHeaderReference('first', relationship.getId());
         return this;
     }
     setEvenPageHeader(header) {
-        const relationship = this.relationshipManager.addHeader(`${header.getFilename(this.headerFooterManager.getHeaderCount() + 1)}`);
+        const relationship = this.relationshipManager.addHeader(this.headerFooterManager.peekHeaderFilename(header));
         this.headerFooterManager.registerHeader(header, relationship.getId());
         this.section.setHeaderReference('even', relationship.getId());
         return this;
     }
     setFooter(footer) {
-        const relationship = this.relationshipManager.addFooter(`${footer.getFilename(1)}`);
+        const relationship = this.relationshipManager.addFooter(this.headerFooterManager.peekFooterFilename(footer));
         this.headerFooterManager.registerFooter(footer, relationship.getId());
         this.section.setFooterReference('default', relationship.getId());
         return this;
     }
     setFirstPageFooter(footer) {
         this.section.setTitlePage(true);
-        const relationship = this.relationshipManager.addFooter(`${footer.getFilename(this.headerFooterManager.getFooterCount() + 1)}`);
+        const relationship = this.relationshipManager.addFooter(this.headerFooterManager.peekFooterFilename(footer));
         this.headerFooterManager.registerFooter(footer, relationship.getId());
         this.section.setFooterReference('first', relationship.getId());
         return this;
     }
     setEvenPageFooter(footer) {
-        const relationship = this.relationshipManager.addFooter(`${footer.getFilename(this.headerFooterManager.getFooterCount() + 1)}`);
+        const relationship = this.relationshipManager.addFooter(this.headerFooterManager.peekFooterFilename(footer));
         this.headerFooterManager.registerFooter(footer, relationship.getId());
         this.section.setFooterReference('even', relationship.getId());
         return this;
@@ -5180,6 +5363,20 @@ export class Document {
                 }
             }
             this.removeCommentCompanionFiles();
+            const extendedXml = this.commentManager.generateCommentsExtendedXml();
+            if (extendedXml) {
+                this.zipHandler.addFile(DOCX_PATHS.COMMENTS_EXTENDED, extendedXml);
+                const hasExtendedRel = this.relationshipManager
+                    .getAllRelationships()
+                    .some((rel) => rel.getTarget() === 'commentsExtended.xml');
+                if (!hasExtendedRel) {
+                    this.relationshipManager.addRelationship(Relationship.create({
+                        id: this.relationshipManager.generateId(),
+                        type: 'http://schemas.microsoft.com/office/2011/relationships/commentsExtended',
+                        target: 'commentsExtended.xml',
+                    }));
+                }
+            }
         }
         else if (this._originalCommentsXml) {
             this.zipHandler.addFile('word/comments.xml', this._originalCommentsXml);
@@ -5217,7 +5414,8 @@ export class Document {
         }
     }
     saveFootnotes() {
-        if (this._footnotesModified || this.footnoteManager.getCount() > 0) {
+        if (this._footnotesModified ||
+            (!this._originalFootnotesXml && this.footnoteManager.getCount() > 0)) {
             const xml = this.footnoteManager.generateFootnotesXml();
             this.zipHandler.addFile(DOCX_PATHS.FOOTNOTES, xml);
             const existingRels = this.relationshipManager.getRelationshipsByType(RelationshipType.FOOTNOTES);
@@ -5235,7 +5433,8 @@ export class Document {
         }
     }
     saveEndnotes() {
-        if (this._endnotesModified || this.endnoteManager.getCount() > 0) {
+        if (this._endnotesModified ||
+            (!this._originalEndnotesXml && this.endnoteManager.getCount() > 0)) {
             const xml = this.endnoteManager.generateEndnotesXml();
             this.zipHandler.addFile(DOCX_PATHS.ENDNOTES, xml);
             const existingRels = this.relationshipManager.getRelationshipsByType(RelationshipType.ENDNOTES);
@@ -5304,7 +5503,12 @@ export class Document {
             xml += '</Relationships>';
             this.zipHandler.addFile(relsPath, xml);
             for (const rel of hyperlinkRels) {
-                this.relationshipManager.removeRelationship(rel.id);
+                const mainRel = this.relationshipManager.getRelationship(rel.id);
+                if (mainRel &&
+                    mainRel.getType() === RelationshipType.HYPERLINK &&
+                    mainRel.getTarget() === rel.url) {
+                    this.relationshipManager.removeRelationship(rel.id);
+                }
             }
         }
     }
@@ -5422,13 +5626,25 @@ export class Document {
     parseContentTypes(xml) {
         const defaults = new Set();
         const overrides = new Set();
-        const defaultMatches = xml.matchAll(/<Default\s+Extension="([^"]+)"\s+ContentType="([^"]+)"\s*\/>/g);
-        for (const match of defaultMatches) {
-            defaults.add(`${match[1]}|${match[2]}`);
+        const readAttr = (tag, name) => {
+            const match = tag.match(new RegExp(`(?:^|\\s)${name}\\s*=\\s*("([^"]*)"|'([^']*)')`));
+            if (!match)
+                return undefined;
+            return XMLBuilder.unescapeXml(match[2] ?? match[3] ?? '');
+        };
+        for (const tagMatch of xml.matchAll(/<Default\b[^>]*>/g)) {
+            const ext = readAttr(tagMatch[0], 'Extension');
+            const contentType = readAttr(tagMatch[0], 'ContentType');
+            if (ext && contentType) {
+                defaults.add(`${ext}|${contentType}`);
+            }
         }
-        const overrideMatches = xml.matchAll(/<Override\s+PartName="([^"]+)"\s+ContentType="([^"]+)"\s*\/>/g);
-        for (const match of overrideMatches) {
-            overrides.add(`${match[1]}|${match[2]}`);
+        for (const tagMatch of xml.matchAll(/<Override\b[^>]*>/g)) {
+            const partName = readAttr(tagMatch[0], 'PartName');
+            const contentType = readAttr(tagMatch[0], 'ContentType');
+            if (partName && contentType) {
+                overrides.add(`${partName}|${contentType}`);
+            }
         }
         return { defaults, overrides };
     }
@@ -5748,9 +5964,7 @@ export class Document {
         }
         if (element && typeof element.getContent === 'function') {
             for (const item of element.getContent()) {
-                if (item &&
-                    typeof item._setTrackingContext === 'function' &&
-                    typeof item.getInstruction === 'function') {
+                if (item && typeof item._setTrackingContext === 'function') {
                     item._setTrackingContext(this.trackingContext);
                 }
             }
@@ -5917,6 +6131,7 @@ export class Document {
             updated.size = sizeInPoints;
         }
         normalStyle.setRunFormatting(updated);
+        this.stylesManager.addStyle(normalStyle);
         return this;
     }
     setDefaultFontSize(sizeInPoints) {
@@ -5932,6 +6147,7 @@ export class Document {
         }
         const existing = normalStyle.getRunFormatting() ?? {};
         normalStyle.setRunFormatting({ ...existing, size: sizeInPoints });
+        this.stylesManager.addStyle(normalStyle);
         return this;
     }
     getUpdateFields() {
@@ -6123,6 +6339,40 @@ export class Document {
         this.endnoteManager.clear();
         this._endnotesModified = true;
     }
+    removeFootnote(id) {
+        const removed = this.footnoteManager.removeFootnote(id);
+        if (removed) {
+            this._footnotesModified = true;
+            this.removeNoteReferenceRuns('footnoteReference', id);
+        }
+        return removed;
+    }
+    removeEndnote(id) {
+        const removed = this.endnoteManager.removeEndnote(id);
+        if (removed) {
+            this._endnotesModified = true;
+            this.removeNoteReferenceRuns('endnoteReference', id);
+        }
+        return removed;
+    }
+    removeNoteReferenceRuns(refType, id) {
+        for (const para of this.getAllParagraphs()) {
+            const content = para.getContent();
+            for (let i = content.length - 1; i >= 0; i--) {
+                const item = content[i];
+                if (!(item instanceof Run)) {
+                    continue;
+                }
+                const matches = item
+                    .getContent()
+                    .some((c) => c.type === refType &&
+                    (refType === 'footnoteReference' ? c.footnoteId === id : c.endnoteId === id));
+                if (matches) {
+                    para.removeContentAt(i);
+                }
+            }
+        }
+    }
     addCommentToParagraph(paragraph, commentOrAuthor, content, initials) {
         const comment = typeof commentOrAuthor === 'string'
             ? this.createComment(commentOrAuthor, content, initials)
@@ -6173,12 +6423,52 @@ export class Document {
         return this.commentManager.hasReplies(commentId);
     }
     removeComment(id) {
+        const replyIds = this.commentManager.getReplies(id).map((reply) => reply.getId());
         const removed = this.commentManager.removeComment(id);
         if (removed) {
+            this.removeCommentAnchors([id, ...replyIds]);
             this._commentsModified = true;
         }
         return removed;
     }
+    removeCommentAnchors(commentIds) {
+        const strip = (paragraphs) => {
+            let removed = false;
+            for (const paragraph of paragraphs) {
+                for (const commentId of commentIds) {
+                    if (paragraph.removeCommentAnchor(commentId)) {
+                        removed = true;
+                    }
+                }
+            }
+            return removed;
+        };
+        strip(this.getAllParagraphs());
+        for (const entry of this.headerFooterManager.getAllHeaders()) {
+            strip(this.extractParagraphsFromElements(entry.header.getElements()));
+        }
+        for (const entry of this.headerFooterManager.getAllFooters()) {
+            strip(this.extractParagraphsFromElements(entry.footer.getElements()));
+        }
+        let footnotesChanged = false;
+        for (const footnote of this.footnoteManager.getAllFootnotes()) {
+            if (strip(footnote.getParagraphs())) {
+                footnotesChanged = true;
+            }
+        }
+        if (footnotesChanged) {
+            this._footnotesModified = true;
+        }
+        let endnotesChanged = false;
+        for (const endnote of this.endnoteManager.getAllEndnotes()) {
+            if (strip(endnote.getParagraphs())) {
+                endnotesChanged = true;
+            }
+        }
+        if (endnotesChanged) {
+            this._endnotesModified = true;
+        }
+    }
     hasNoRevisions() {
         return this.revisionManager.isEmpty();
     }
@@ -6434,8 +6724,8 @@ export class Document {
         this.parser.clearParseErrors();
         this.stylesManager.clear();
         this.numberingManager.clear();
-        this.imageManager.clear();
         this.imageManager.releaseAllImageData();
+        this.imageManager.clear();
         this.relationshipManager.clear();
         this.headerFooterManager.clear();
         this.bookmarkManager.clear();
@@ -6449,6 +6739,7 @@ export class Document {
         this._originalNumberingXml = undefined;
         this._originalSettingsXml = undefined;
         this._originalAppPropsXml = undefined;
+        this._originalCorePropsXml = undefined;
         this._originalFootnotesXml = undefined;
         this._originalEndnotesXml = undefined;
         this._originalCommentsXml = undefined;
@@ -6457,6 +6748,7 @@ export class Document {
         this._originalContentTypes = undefined;
         this._settingsModified = false;
         this._appPropsModified = false;
+        this._corePropsModified = false;
         this._footnotesModified = false;
         this._endnotesModified = false;
         this._originalWebSettingsXml = undefined;
@@ -7014,7 +7306,7 @@ export class Document {
                     const matches = originalText.match(wordPattern);
                     if (matches) {
                         replacementCount += matches.length;
-                        newText = originalText.replace(wordPattern, replace);
+                        newText = originalText.replace(wordPattern, () => replace);
                     }
                 }
                 else {
@@ -7022,7 +7314,7 @@ export class Document {
                     const matches = originalText.match(searchPattern);
                     if (matches) {
                         replacementCount += matches.length;
-                        newText = originalText.replace(searchPattern, replace);
+                        newText = originalText.replace(searchPattern, () => replace);
                     }
                 }
                 if (newText !== originalText) {
@@ -7302,90 +7594,303 @@ export class Document {
     }
     toPlainText(separator = '\n') {
         const paragraphs = this.getAllParagraphs();
-        return paragraphs.map((p) => p.getText()).join(separator);
-    }
-    toMarkdown() {
+        return paragraphs.map((p) => p.getTextIncludingRevisions()).join(separator);
+    }
+    toMarkdown(options) {
+        const ctx = {
+            opts: {
+                htmlFallback: options?.htmlFallback ?? true,
+                footnotes: options?.footnotes ?? true,
+                images: options?.images ?? true,
+            },
+            notes: [],
+            noteMarkers: new Set(),
+        };
         const lines = [];
         for (const element of this.bodyElements) {
-            if (element instanceof Paragraph) {
-                const mdLine = this.paragraphToMarkdown(element);
-                if (mdLine !== null) {
-                    lines.push(mdLine);
-                    lines.push('');
-                }
+            this.bodyElementToMarkdown(element, ctx, lines);
+        }
+        while (lines.length > 0 && lines[lines.length - 1] === '') {
+            lines.pop();
+        }
+        let out = lines.join('\n');
+        if (ctx.opts.footnotes && ctx.notes.length > 0) {
+            const defs = ctx.notes.map((n) => `[^${n.marker}]: ${n.text}`).join('\n');
+            out = out ? `${out}\n\n${defs}` : defs;
+        }
+        return out;
+    }
+    bodyElementToMarkdown(element, ctx, lines) {
+        if (element instanceof Paragraph) {
+            const md = this.paragraphToMarkdown(element, ctx);
+            if (md !== null) {
+                lines.push(md);
+                lines.push('');
             }
-            else if (element instanceof Table) {
-                lines.push(...this.tableToMarkdown(element));
+        }
+        else if (element instanceof Table) {
+            const tableLines = this.tableToMarkdown(element, ctx);
+            if (tableLines.length > 0) {
+                lines.push(...tableLines);
                 lines.push('');
             }
         }
-        while (lines.length > 0 && lines[lines.length - 1] === '') {
-            lines.pop();
+        else if (element instanceof StructuredDocumentTag) {
+            for (const child of element.getContent()) {
+                this.bodyElementToMarkdown(child, ctx, lines);
+            }
+        }
+        else if (element instanceof PreservedElement) {
+            const text = this.extractTextFromRawXml(element.getRawXml());
+            if (text) {
+                lines.push(this.escapeMarkdown(text));
+                lines.push('');
+            }
         }
-        return lines.join('\n');
     }
-    paragraphToMarkdown(para) {
-        const text = this.paragraphContentToMarkdown(para);
-        if (!text && !para.hasNumbering())
+    paragraphToMarkdown(para, ctx) {
+        const inline = this.paragraphContentToMarkdown(para, ctx);
+        const hasNumbering = para.hasNumbering();
+        if (!inline && !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 '#'.repeat(headingLevel) + ' ' + this.toSingleLine(inline);
+        }
+        const style = (para.getStyle() ?? '').toLowerCase();
+        const isListStyle = style.includes('listbullet') ||
+            style.includes('list bullet') ||
+            style.includes('listnumber') ||
+            style.includes('list number');
+        if (hasNumbering || isListStyle) {
+            const level = para.getNumbering()?.level ?? 0;
+            const indent = '  '.repeat(Math.max(0, level));
+            const marker = this.isOrderedList(para) ? '1.' : '-';
+            return `${indent}${marker} ${this.toSingleLine(inline)}`;
+        }
+        if (style.includes('quote')) {
+            return this.toSingleLine(inline)
+                .split('\n')
+                .map((l) => `> ${l}`)
+                .join('\n');
+        }
+        return inline;
+    }
+    isOrderedList(para) {
+        const numbering = para.getNumbering();
+        if (numbering) {
+            const instance = this.numberingManager.getInstance(numbering.numId);
+            if (instance) {
+                const abstract = this.numberingManager.getAbstractNumbering(instance.getAbstractNumId());
+                const levelDef = abstract?.getLevel(numbering.level);
+                const format = levelDef?.getFormat();
+                if (format)
+                    return format !== 'bullet';
+            }
         }
-        return text;
+        const style = (para.getStyle() ?? '').toLowerCase();
+        if (style.includes('bullet'))
+            return false;
+        if (style.includes('number'))
+            return true;
+        return true;
+    }
+    paragraphContentToMarkdown(para, ctx) {
+        return this.inlineContentToMarkdown(para.getContent(), ctx);
     }
-    paragraphContentToMarkdown(para) {
+    inlineContentToMarkdown(items, ctx) {
         const parts = [];
-        for (const item of para.getContent()) {
-            if (item instanceof 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}*`;
+        for (const item of items) {
+            if (item instanceof ImageRun) {
+                if (ctx.opts.images) {
+                    const image = item.getImageElement();
+                    const alt = this.escapeMarkdown(image.getAltText() || 'image');
+                    const src = image.getRelationshipId() ?? 'image';
+                    parts.push(`![${alt}](${src})`);
                 }
-                if (fmt.strike) {
-                    md = `~~${md}~~`;
+            }
+            else if (item instanceof Run) {
+                parts.push(this.runToMarkdown(item, ctx));
+            }
+            else if (item instanceof Hyperlink) {
+                const runs = item.getRuns();
+                let label = runs.length > 0
+                    ? runs.map((r) => this.runToMarkdown(r, ctx, true)).join('')
+                    : this.escapeMarkdown(item.getText());
+                if (!label)
+                    label = this.escapeMarkdown(item.getText());
+                let url = item.getUrl() ?? '';
+                const anchor = item.getAnchor();
+                if (anchor)
+                    url = url ? `${url}#${anchor}` : `#${anchor}`;
+                parts.push(`[${label}](${url})`);
+            }
+            else if (item instanceof Revision) {
+                const inner = this.inlineContentToMarkdown(item.getContent(), ctx);
+                if (!inner)
+                    continue;
+                const type = item.getType();
+                if (type === 'delete' || type === 'moveFrom') {
+                    parts.push(ctx.opts.htmlFallback ? `<del>${inner}</del>` : `~~${inner}~~`);
                 }
-                if (fmt.font &&
-                    /^(courier|consolas|monaco|menlo|source code|fira code|jetbrains mono)/i.test(fmt.font)) {
-                    md = `\`${runText}\``;
+                else {
+                    parts.push(inner);
                 }
-                parts.push(md);
             }
-            else if (item instanceof Hyperlink) {
-                const url = item.getUrl() || '';
-                const linkText = item.getText() || url;
-                parts.push(`[${linkText}](${url})`);
+            else if (item instanceof ComplexField) {
+                const result = item.getResult();
+                if (result)
+                    parts.push(this.escapeMarkdown(result));
+            }
+            else if (item instanceof Field) {
+                const result = item.getCachedResult();
+                if (result)
+                    parts.push(this.escapeMarkdown(result));
+            }
+            else if (item instanceof TextBox) {
+                const text = item
+                    .getParagraphs()
+                    .map((p) => this.paragraphContentToMarkdown(p, ctx))
+                    .filter((s) => s !== '')
+                    .join(' ');
+                if (text)
+                    parts.push(text);
+            }
+            else if (item instanceof Shape) {
+                const text = item.getText();
+                if (text)
+                    parts.push(this.escapeMarkdown(text));
+            }
+            else if (item instanceof PreservedElement) {
+                const type = item.getElementType();
+                if (!type.startsWith('w:comment')) {
+                    const text = this.extractTextFromRawXml(item.getRawXml());
+                    if (text)
+                        parts.push(this.escapeMarkdown(text));
+                }
             }
         }
         return parts.join('');
     }
-    tableToMarkdown(table) {
-        const data = table.toArray();
-        if (data.length === 0)
+    runToMarkdown(run, ctx, inLink = false) {
+        const fmt = run.getFormatting();
+        const isMono = !!(fmt.font &&
+            /^(courier|consolas|monaco|menlo|source code|fira code|jetbrains mono)/i.test(fmt.font));
+        const escape = (s) => (isMono ? s : this.escapeMarkdown(s));
+        const segments = [];
+        const markers = [];
+        for (const content of run.getContent()) {
+            switch (content.type) {
+                case 'text':
+                case 'instructionText':
+                    segments.push(escape(content.value ?? ''));
+                    break;
+                case 'tab':
+                    segments.push('\t');
+                    break;
+                case 'carriageReturn':
+                    segments.push('\n');
+                    break;
+                case 'break':
+                    if (content.breakType !== 'page' && content.breakType !== 'column') {
+                        segments.push(ctx.opts.htmlFallback ? '<br>' : '\n');
+                    }
+                    break;
+                case 'noBreakHyphen':
+                    segments.push('‑');
+                    break;
+                case 'symbol':
+                    if (content.symbolChar) {
+                        const code = parseInt(content.symbolChar, 16);
+                        if (!Number.isNaN(code))
+                            segments.push(escape(String.fromCharCode(code)));
+                    }
+                    break;
+                case 'footnoteReference':
+                    if (ctx.opts.footnotes && content.footnoteId !== undefined) {
+                        markers.push(this.noteMarker(content.footnoteId, 'fn', ctx));
+                    }
+                    break;
+                case 'endnoteReference':
+                    if (ctx.opts.footnotes && content.endnoteId !== undefined) {
+                        markers.push(this.noteMarker(content.endnoteId, 'en', ctx));
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        let text = segments.join('');
+        if (text) {
+            if (isMono) {
+                text = `\`${text}\``;
+            }
+            if (fmt.bold && fmt.italic)
+                text = `***${text}***`;
+            else if (fmt.bold)
+                text = `**${text}**`;
+            else if (fmt.italic)
+                text = `*${text}*`;
+            if (fmt.strike || fmt.dstrike)
+                text = `~~${text}~~`;
+            if (ctx.opts.htmlFallback) {
+                if (fmt.superscript)
+                    text = `<sup>${text}</sup>`;
+                else if (fmt.subscript)
+                    text = `<sub>${text}</sub>`;
+                if (fmt.highlight && fmt.highlight !== 'none')
+                    text = `<mark>${text}</mark>`;
+                if (!inLink) {
+                    if (fmt.underline && fmt.underline !== 'none')
+                        text = `<u>${text}</u>`;
+                    if (fmt.color && fmt.color !== 'auto' && /^[0-9a-fA-F]{6}$/.test(fmt.color)) {
+                        text = `<span style="color:#${fmt.color}">${text}</span>`;
+                    }
+                }
+            }
+        }
+        return text + markers.join('');
+    }
+    noteMarker(id, kind, ctx) {
+        const marker = `${kind}${id}`;
+        if (!ctx.noteMarkers.has(marker)) {
+            ctx.noteMarkers.add(marker);
+            const note = kind === 'fn' ? this.footnoteManager.getFootnote(id) : this.endnoteManager.getEndnote(id);
+            let text = '';
+            if (note) {
+                text = note
+                    .getParagraphs()
+                    .map((p) => this.paragraphContentToMarkdown(p, ctx))
+                    .filter((s) => s !== '')
+                    .join(' ')
+                    .replace(/\s*\n\s*/g, ' ')
+                    .trim();
+            }
+            ctx.notes.push({ marker, text });
+        }
+        return `[^${marker}]`;
+    }
+    tableToMarkdown(table, ctx) {
+        const rows = table.getRows();
+        if (rows.length === 0)
             return [];
-        const colCount = Math.max(...data.map((row) => row.length));
+        const isComplex = rows.some((row) => row
+            .getCells()
+            .some((cell) => (cell.getColumnSpan() ?? 1) > 1 ||
+            cell.getVerticalMerge() !== undefined ||
+            cell.hasNestedTables()));
+        if (isComplex && ctx.opts.htmlFallback) {
+            return this.tableToHtmlBlock(table);
+        }
+        const matrix = rows.map((row) => row.getCells().map((cell) => this.cellToMarkdown(cell, ctx)));
+        const colCount = Math.max(...matrix.map((row) => row.length));
         if (colCount === 0)
             return [];
-        const normalized = data.map((row) => {
+        const normalized = matrix.map((row) => {
             const padded = [...row];
             while (padded.length < colCount)
                 padded.push('');
-            return padded.map((cell) => cell.replace(/\|/g, '\\|').replace(/\n/g, ' ').trim());
+            return padded;
         });
         const lines = [];
         lines.push('| ' + normalized[0].join(' | ') + ' |');
@@ -7395,6 +7900,88 @@ export class Document {
         }
         return lines;
     }
+    cellToMarkdown(cell, ctx) {
+        const text = cell
+            .getParagraphs()
+            .map((p) => this.paragraphContentToMarkdown(p, ctx))
+            .filter((s) => s !== '')
+            .join(' ');
+        return text.replace(/\|/g, '\\|').replace(/<br>/g, ' ').replace(/\n/g, ' ').trim();
+    }
+    tableToHtmlBlock(table) {
+        const rows = table.getRows();
+        const rowCells = rows.map((row) => {
+            let gridStart = 0;
+            return row.getCells().map((cell) => {
+                const span = cell.getColumnSpan() ?? 1;
+                const entry = { cell, gridStart, span };
+                gridStart += span;
+                return entry;
+            });
+        });
+        const html = ['<table>'];
+        for (let ri = 0; ri < rowCells.length; ri++) {
+            html.push('<tr>');
+            for (const { cell, gridStart, span } of rowCells[ri]) {
+                if (cell.getVerticalMerge() === 'continue')
+                    continue;
+                let rowspan = 1;
+                if (cell.getVerticalMerge() === 'restart') {
+                    for (let rj = ri + 1; rj < rowCells.length; rj++) {
+                        const below = rowCells[rj].find((e) => e.gridStart === gridStart);
+                        if (below?.cell.getVerticalMerge() === 'continue')
+                            rowspan++;
+                        else
+                            break;
+                    }
+                }
+                const tag = ri === 0 ? 'th' : 'td';
+                const attrs = (span > 1 ? ` colspan="${span}"` : '') + (rowspan > 1 ? ` rowspan="${rowspan}"` : '');
+                let content = cell
+                    .getParagraphs()
+                    .map((p) => this.paragraphContentToHTML(p))
+                    .filter((s) => s !== '')
+                    .join('<br>') || this.escapeHTML(cell.getText());
+                if (cell.hasNestedTables()) {
+                    const nestedText = cell
+                        .getRawNestedContent()
+                        .map((n) => this.extractTextFromRawXml(n.xml))
+                        .filter((s) => s)
+                        .join(' ');
+                    if (nestedText)
+                        content += `<br>${this.escapeHTML(nestedText)}`;
+                }
+                html.push(`<${tag}${attrs}>${content}</${tag}>`);
+            }
+            html.push('</tr>');
+        }
+        html.push('</table>');
+        return html;
+    }
+    escapeMarkdown(text) {
+        return text.replace(/([\\`*_[\]<>])/g, '\\$1');
+    }
+    toSingleLine(text) {
+        return text.replace(/<br>/g, ' ').replace(/\s*\n\s*/g, ' ');
+    }
+    extractTextFromRawXml(xml) {
+        if (!xml.includes('<w:t'))
+            return '';
+        const parts = [];
+        const regex = /<w:t(?:\s[^>]*)?>([\s\S]*?)<\/w:t>/g;
+        let match;
+        while ((match = regex.exec(xml)) !== null) {
+            parts.push(match[1] ?? '');
+        }
+        return parts
+            .join('')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&apos;/g, "'")
+            .replace(/&amp;/g, '&')
+            .trim();
+    }
     toHTML(options) {
         const parts = [];
         let inList = null;
@@ -7485,8 +8072,12 @@ export class Document {
                 parts.push(html);
             }
             else if (item instanceof Hyperlink) {
-                const url = this.escapeHTML(item.getUrl() || '');
-                const linkText = this.escapeHTML(item.getText() || url);
+                let rawUrl = item.getUrl() ?? '';
+                const anchor = item.getAnchor();
+                if (anchor)
+                    rawUrl = rawUrl ? `${rawUrl}#${anchor}` : `#${anchor}`;
+                const url = this.escapeHTML(rawUrl);
+                const linkText = this.escapeHTML(item.getText() || rawUrl);
                 parts.push(`<a href="${url}">${linkText}</a>`);
             }
         }
@@ -7634,7 +8225,10 @@ export class Document {
     removeParagraph(paragraphOrIndex) {
         let index;
         if (typeof paragraphOrIndex === 'number') {
-            index = paragraphOrIndex;
+            const para = this.getParagraphAt(paragraphOrIndex);
+            if (!para)
+                return false;
+            index = this.bodyElements.indexOf(para);
         }
         else {
             index = this.bodyElements.indexOf(paragraphOrIndex);
@@ -7643,13 +8237,8 @@ export class Document {
             const element = this.bodyElements[index];
             if (element instanceof Paragraph) {
                 if (this.trackChangesEnabled && this.trackingContext.isEnabled()) {
-                    const runs = element.getRuns();
-                    if (runs.length > 0) {
-                        const author = this.trackingContext.getAuthor();
-                        const deletion = Revision.createDeletion(author, runs);
-                        this.trackingContext.getRevisionManager().register(deletion);
-                        element.addRevision(deletion);
-                    }
+                    this.bindTrackingToElement(element);
+                    element.clearContent();
                     return true;
                 }
                 this.bodyElements.splice(index, 1);
@@ -7903,16 +8492,6 @@ export class Document {
         for (const paragraph of this.getAllParagraphs()) {
             extractHyperlinksFromParagraph(paragraph);
         }
-        for (const table of this.getTables()) {
-            for (const row of table.getRows()) {
-                for (const cell of row.getCells()) {
-                    const cellParagraphs = cell instanceof TableCell ? cell.getParagraphs() : [];
-                    for (const para of cellParagraphs) {
-                        extractHyperlinksFromParagraph(para);
-                    }
-                }
-            }
-        }
         return hyperlinks;
     }
     collectAllReferencedHyperlinkIds() {
@@ -8037,17 +8616,6 @@ export class Document {
                 bookmarks.push({ bookmark, paragraph });
             }
         }
-        for (const table of this.getTables()) {
-            for (const row of table.getRows()) {
-                for (const cell of row.getCells()) {
-                    for (const para of cell.getParagraphs()) {
-                        for (const bookmark of para.getBookmarksStart()) {
-                            bookmarks.push({ bookmark, paragraph: para });
-                        }
-                    }
-                }
-            }
-        }
         return bookmarks;
     }
     getFields() {
@@ -8057,18 +8625,6 @@ export class Document {
                 results.push({ field, paragraph });
             }
         }
-        for (const table of this.getTables()) {
-            for (const row of table.getRows()) {
-                for (const cell of row.getCells()) {
-                    const cellParagraphs = cell instanceof TableCell ? cell.getParagraphs() : [];
-                    for (const para of cellParagraphs) {
-                        for (const field of para.getFields()) {
-                            results.push({ field, paragraph: para, table });
-                        }
-                    }
-                }
-            }
-        }
         return results;
     }
     getImages() {
@@ -8107,7 +8663,7 @@ export class Document {
                 await entry.image.updateImageData(result.data);
             }
             if (result.newExtension !== extension) {
-                const newFilename = filename.replace(/\.[^.]+$/, `.${result.newExtension}`);
+                const newFilename = this.resolveUniqueMediaFilename(filename.replace(/\.[^.]+$/, `.${result.newExtension}`), filename);
                 this.imageManager.updateEntryFilename(image, newFilename);
                 for (const entry of entries) {
                     this.updateImageRelationshipTarget(entry.relationshipId, filename, newFilename);
@@ -8118,6 +8674,20 @@ export class Document {
         }
         return { optimizedCount, totalSavedBytes: totalSaved };
     }
+    resolveUniqueMediaFilename(candidate, currentFilename) {
+        const dotIndex = candidate.lastIndexOf('.');
+        const base = dotIndex === -1 ? candidate : candidate.slice(0, dotIndex);
+        const ext = dotIndex === -1 ? '' : candidate.slice(dotIndex);
+        const isTaken = (name) => this.zipHandler.hasFile(`word/media/${name}`) ||
+            this.imageManager.isFilenameOwnedByOther(name, currentFilename);
+        let name = candidate;
+        let counter = 1;
+        while (isTaken(name)) {
+            name = `${base}-${counter}${ext}`;
+            counter++;
+        }
+        return name;
+    }
     updateImageRelationshipTarget(relId, oldFilename, newFilename) {
         const rel = this.relationshipManager.getRelationship(relId);
         if (rel) {
@@ -8241,7 +8811,7 @@ export class Document {
             const toRemove = [];
             this.bodyElements.forEach((element, index) => {
                 if (element instanceof Paragraph) {
-                    const isEmpty = element.getText().trim() === '';
+                    const isEmpty = this.isParagraphRemovableBlank(element);
                     if (isEmpty && lastWasEmpty) {
                         toRemove.push(index);
                     }
@@ -8325,11 +8895,30 @@ export class Document {
         }
         return { removed, normalized };
     }
+    isParagraphRemovableBlank(para) {
+        if (para.getText().trim() !== '')
+            return false;
+        if (para.formatting.sectPr !== undefined)
+            return false;
+        if (para.getBookmarksStart().length > 0 || para.getBookmarksEnd().length > 0) {
+            return false;
+        }
+        if (para.getCommentsStart().length > 0 || para.getCommentsEnd().length > 0) {
+            return false;
+        }
+        for (const item of para.getContent()) {
+            if (item instanceof ImageRun || item instanceof Shape || item instanceof RangeMarker) {
+                return false;
+            }
+        }
+        return true;
+    }
     setLanguage(language) {
         if (!this.properties) {
             this.properties = {};
         }
         this.properties.language = language;
+        this._corePropsModified = true;
         return this;
     }
     getLanguage() {
@@ -8445,32 +9034,6 @@ export class Document {
                 pattern.lastIndex = 0;
             }
         }
-        for (const table of this.getTables()) {
-            for (const row of table.getRows()) {
-                for (const cell of row.getCells()) {
-                    for (const para of cell.getParagraphs()) {
-                        for (const run of para.getRuns()) {
-                            const text = run.getText();
-                            if (!text)
-                                continue;
-                            const runFormatting = run.getFormatting();
-                            if (matchBold && !runFormatting.bold)
-                                continue;
-                            if (matchItalic && !runFormatting.italic)
-                                continue;
-                            if (pattern.test(text)) {
-                                const newText = text.replace(pattern, replace);
-                                if (newText !== text) {
-                                    run.setText(newText);
-                                    replacedCount++;
-                                }
-                            }
-                            pattern.lastIndex = 0;
-                        }
-                    }
-                }
-            }
-        }
         return replacedCount;
     }
     static createEmpty() {