docxmlater 10.4.1 → 11.0.4

package/src/{utils → processors}/InMemoryRevisionAcceptor.ts

@@ -14,14 +14,18 @@
  * @see https://learn.microsoft.com/en-us/previous-versions/office/developer/office-2007/ee836138(v=office.12)
  */
 
-import type { Document } from '../core/Document';
-import { Paragraph } from '../elements/Paragraph';
-import type { ParagraphContent } from '../elements/Paragraph';
-import { Revision, RevisionType } from '../elements/Revision';
-import { isRunContent, isHyperlinkContent, isImageRunContent } from '../elements/RevisionContent';
-import { ComplexField } from '../elements/Field';
-import { Table } from '../elements/Table';
-import { getGlobalLogger, createScopedLogger, ILogger } from './logger';
+import type { Document } from '../core/Document.js';
+import { Paragraph } from '../elements/Paragraph.js';
+import type { ParagraphContent } from '../elements/Paragraph.js';
+import { Revision, RevisionType } from '../elements/Revision.js';
+import {
+  isRunContent,
+  isHyperlinkContent,
+  isImageRunContent,
+} from '../elements/RevisionContent.js';
+import { ComplexField } from '../elements/Field.js';
+import { Table } from '../elements/Table.js';
+import { getGlobalLogger, createScopedLogger, ILogger } from '../utils/logger.js';
 
 /**
  * Get scoped logger for this module
@@ -240,6 +244,31 @@ export function acceptRevisionsInMemory(
       result.propertyChangesAccepted++;
     }
 
+    // Row-level tracked ins / del (CT_TrPr: w:ins / w:del per ECMA-376
+    // §17.13.5.19 / §17.13.5.14) — these mark the ENTIRE row as a tracked
+    // insertion or deletion. Previously the acceptor only cleared the
+    // tcPrChange / trPrChange / cellRevision metadata and silently ignored
+    // row-level markers, so deleted rows persisted and inserted rows kept
+    // their pending state. Collect deletion indices up front so we can
+    // splice them out after iteration (reverse order to keep indices stable).
+    const rowsToRemove: number[] = [];
+    const allRows = table.getRows();
+    for (let rowIdx = 0; rowIdx < allRows.length; rowIdx++) {
+      const row = allRows[rowIdx]!;
+      const fmt = row.getFormatting();
+      if (fmt.rowInsertion && opts.acceptInsertions) {
+        row.setRowInsertion(undefined);
+        result.insertionsAccepted++;
+      }
+      if (fmt.rowDeletion && opts.acceptDeletions) {
+        rowsToRemove.push(rowIdx);
+        result.deletionsAccepted++;
+      }
+    }
+    for (let i = rowsToRemove.length - 1; i >= 0; i--) {
+      table._removeRowAtIndex(rowsToRemove[i]!);
+    }
+
     for (const row of table.getRows()) {
       // Clear trPrChange on row
       if (opts.acceptPropertyChanges && row.getTrPrChange()) {
@@ -254,10 +283,28 @@ export function acceptRevisionsInMemory(
           result.propertyChangesAccepted++;
         }
 
-        // Clear cell structural revision markers (cellIns/cellDel/cellMerge)
-        if (opts.acceptPropertyChanges && cell.getCellRevision()) {
-          cell.clearCellRevision();
-          result.propertyChangesAccepted++;
+        // Route cellIns / cellDel / cellMerge by their semantic revision type
+        // (per ECMA-376 §17.13.5.4-6). Previously all three were lumped under
+        // `acceptPropertyChanges`, which meant `{ acceptInsertions: true }`
+        // alone never cleared a cellIns marker, and `{ acceptPropertyChanges:
+        // true }` alone cleared everything including insertions. Correct
+        // mapping:
+        //   - tableCellInsert (w:cellIns)   → acceptInsertions
+        //   - tableCellDelete (w:cellDel)   → acceptDeletions
+        //   - tableCellMerge  (w:cellMerge) → acceptPropertyChanges
+        const cellRev = cell.getCellRevision();
+        if (cellRev) {
+          const revType = cellRev.getType();
+          if (revType === 'tableCellInsert' && opts.acceptInsertions) {
+            cell.clearCellRevision();
+            result.insertionsAccepted++;
+          } else if (revType === 'tableCellDelete' && opts.acceptDeletions) {
+            cell.clearCellRevision();
+            result.deletionsAccepted++;
+          } else if (revType === 'tableCellMerge' && opts.acceptPropertyChanges) {
+            cell.clearCellRevision();
+            result.propertyChangesAccepted++;
+          }
         }
 
         // Process paragraphs in the cell
@@ -385,6 +432,40 @@ export function acceptRevisionsInMemory(
     }
   }
 
+  // Walk footnote and endnote paragraphs. Per ECMA-376 §17.11.4 /
+  // §17.11.15, notes can hold any block-level content including
+  // tracked changes; programmatically-added Revision objects on note
+  // paragraphs (e.g.
+  // `footnote.getParagraphs()[0].addContent(new Revision(...))`)
+  // were never visited by the in-memory acceptor and stayed in the
+  // model after `acceptAllRevisions()`. The raw-XML acceptor
+  // (iter 135) already handles existing-document note revisions on
+  // load, so this loop's job is the programmatic-API path.
+  const footnoteManager = doc.getFootnoteManager?.();
+  if (footnoteManager) {
+    for (const fn of footnoteManager.getAllFootnotes()) {
+      for (const paragraph of fn.getParagraphs()) {
+        const paragraphResult = acceptRevisionsInParagraph(paragraph, opts);
+        result.insertionsAccepted += paragraphResult.insertionsAccepted;
+        result.deletionsAccepted += paragraphResult.deletionsAccepted;
+        result.movesAccepted += paragraphResult.movesAccepted;
+        result.propertyChangesAccepted += paragraphResult.propertyChangesAccepted;
+      }
+    }
+  }
+  const endnoteManager = doc.getEndnoteManager?.();
+  if (endnoteManager) {
+    for (const en of endnoteManager.getAllEndnotes()) {
+      for (const paragraph of en.getParagraphs()) {
+        const paragraphResult = acceptRevisionsInParagraph(paragraph, opts);
+        result.insertionsAccepted += paragraphResult.insertionsAccepted;
+        result.deletionsAccepted += paragraphResult.deletionsAccepted;
+        result.movesAccepted += paragraphResult.movesAccepted;
+        result.propertyChangesAccepted += paragraphResult.propertyChangesAccepted;
+      }
+    }
+  }
+
   // Clear sectPrChange on document section
   if (opts.acceptPropertyChanges) {
     const section = doc.getSection();
@@ -581,6 +662,13 @@ function acceptRevisionsInParagraph(
       paragraph.clearParagraphPropertiesChange();
       result.propertyChangesAccepted++;
     }
+    // Paragraph-mark rPrChange (CT_ParaRPrChange, §17.3.1.30) — same
+    // rationale as pPrChange: acceptance clears the "previous" snapshot,
+    // current formatting (paragraphMarkRunProperties) stays intact.
+    if (formatting.paragraphMarkRunPropertiesChange) {
+      paragraph.formatting.paragraphMarkRunPropertiesChange = undefined;
+      result.propertyChangesAccepted++;
+    }
   }
 
   // Clear paragraph mark deletion tracking if accepting deletions

package/src/{utils → processors}/MoveOperationHelper.ts

@@ -33,9 +33,9 @@
  * ```
  */
 
-import { Revision } from '../elements/Revision';
-import { RangeMarker } from '../elements/RangeMarker';
-import { Run } from '../elements/Run';
+import { Revision } from '../elements/Revision.js';
+import { RangeMarker } from '../elements/RangeMarker.js';
+import { Run } from '../elements/Run.js';
 
 /**
  * Options for creating a move operation
@@ -203,8 +203,8 @@ export class MoveOperationHelper {
    * ```
    */
   static addMoveOperation(
-    sourceParagraph: import('../elements/Paragraph').Paragraph,
-    destParagraph: import('../elements/Paragraph').Paragraph,
+    sourceParagraph: import('../elements/Paragraph.js').Paragraph,
+    destParagraph: import('../elements/Paragraph.js').Paragraph,
     options: MoveOperationOptions
   ): MoveOperationResult {
     const moveOp = this.createMoveOperation(options);

package/src/{utils → processors}/RevisionAwareProcessor.ts

@@ -11,9 +11,9 @@
  * @module RevisionAwareProcessor
  */
 
-import type { Document } from '../core/Document';
-import { Revision, RevisionType } from '../elements/Revision';
-import { ChangeCategory, ChangeLocation } from './ChangelogGenerator';
+import type { Document } from '../core/Document.js';
+import { Revision, RevisionType } from '../elements/Revision.js';
+import { ChangeCategory, ChangeLocation } from './ChangelogGenerator.js';
 
 /**
  * Revision handling modes for document processing.

package/src/{utils → processors}/RevisionWalker.ts

@@ -8,7 +8,7 @@
  * @module RevisionWalker
  */
 
-import { ParsedXMLObject } from '../xml/XMLParser';
+import { ParsedXMLObject } from '../xml/XMLParser.js';
 
 /**
  * Options for controlling which revision types to accept
@@ -143,6 +143,16 @@ export class RevisionWalker {
       return;
     }
 
+    // Pre-recursion: row-level tracked deletions (CT_TrPr > w:del per
+    // §17.13.5.14). Must run BEFORE the depth-first recursion — otherwise
+    // processRevisions in trPr would strip the w:del marker before we can
+    // detect it at the table level. The default `w:del` removal in
+    // processRevisions only strips the marker itself, leaving a zombie
+    // empty row; per spec, accepting the deletion removes the entire row.
+    if (options.acceptDeletions && obj['w:tr']) {
+      RevisionWalker.filterDeletedRows(obj);
+    }
+
     // Get keys to process (excluding metadata keys)
     const keys = Object.keys(obj).filter(
       (k) => !k.startsWith('@_') && k !== '#text' && k !== '_orderedChildren'
@@ -165,6 +175,37 @@ export class RevisionWalker {
     RevisionWalker.processRevisions(obj, options);
   }
 
+  /**
+   * Remove `<w:tr>` entries whose `<w:trPr>` contains a self-closing
+   * `<w:del/>` row-level deletion marker. Operates on the parsed-object
+   * representation (arrays when multiple, single object otherwise).
+   */
+  private static filterDeletedRows(tbl: any): void {
+    const rows = tbl['w:tr'];
+    const isRowDeleted = (row: any): boolean => {
+      if (!row || typeof row !== 'object') return false;
+      const trPr = row['w:trPr'];
+      if (!trPr || typeof trPr !== 'object') return false;
+      // w:del at row level is a CT_TrackChange (no children). When absent
+      // the parser leaves no key; when present it's a self-closing tag
+      // parsed as an object with only @_w:id/@_w:author/@_w:date keys.
+      return !!trPr['w:del'];
+    };
+
+    if (Array.isArray(rows)) {
+      const kept = rows.filter((r) => !isRowDeleted(r));
+      if (kept.length !== rows.length) {
+        if (kept.length === 0) {
+          delete tbl['w:tr'];
+        } else {
+          tbl['w:tr'] = kept;
+        }
+      }
+    } else if (isRowDeleted(rows)) {
+      delete tbl['w:tr'];
+    }
+  }
+
   /**
    * Process revision elements at the current level
    */

package/src/{utils → processors}/SelectiveRevisionAcceptor.ts

@@ -12,13 +12,13 @@
  * @see https://github.com/OfficeDev/Open-Xml-PowerTools - RevisionAccepter.cs
  */
 
-import type { Document } from '../core/Document';
-import type { Paragraph, ParagraphContent } from '../elements/Paragraph';
-import { Revision, RevisionType } from '../elements/Revision';
-import type { Run } from '../elements/Run';
-import { isRunContent, isHyperlinkContent } from '../elements/RevisionContent';
-import { ChangeCategory } from './ChangelogGenerator';
-import { SelectionCriteria } from './RevisionAwareProcessor';
+import type { Document } from '../core/Document.js';
+import type { Paragraph, ParagraphContent } from '../elements/Paragraph.js';
+import { Revision, RevisionType } from '../elements/Revision.js';
+import type { Run } from '../elements/Run.js';
+import { isRunContent, isHyperlinkContent } from '../elements/RevisionContent.js';
+import { ChangeCategory } from './ChangelogGenerator.js';
+import { SelectionCriteria } from './RevisionAwareProcessor.js';
 
 /**
  * Result of selective revision acceptance.
@@ -62,23 +62,9 @@ export class SelectiveRevisionAcceptor {
     const hasFullApi = typeof (doc as any).getAllParagraphs === 'function';
 
     if (hasFullApi) {
-      // Full in-memory DOM transformation
-      const paragraphs = (doc as any).getAllParagraphs();
-      for (const paragraph of paragraphs) {
+      this.walkAllParagraphs(doc, (paragraph) => {
         this.processSelectiveParagraph(paragraph, criteria, 'accept', accepted, remaining);
-      }
-
-      // Process paragraphs in tables
-      const tables = (doc as any).getTables();
-      for (const table of tables) {
-        for (const row of table.getRows()) {
-          for (const cell of row.getCells()) {
-            for (const paragraph of cell.getParagraphs()) {
-              this.processSelectiveParagraph(paragraph, criteria, 'accept', accepted, remaining);
-            }
-          }
-        }
-      }
+      });
     } else {
       // Fallback: Filter revisions from RevisionManager only (for backward compatibility)
       const revisionManager = doc.getRevisionManager();
@@ -136,23 +122,9 @@ export class SelectiveRevisionAcceptor {
     const hasFullApi = typeof (doc as any).getAllParagraphs === 'function';
 
     if (hasFullApi) {
-      // Full in-memory DOM transformation
-      const paragraphs = (doc as any).getAllParagraphs();
-      for (const paragraph of paragraphs) {
+      this.walkAllParagraphs(doc, (paragraph) => {
         this.processSelectiveParagraph(paragraph, criteria, 'reject', rejected, remaining);
-      }
-
-      // Process paragraphs in tables
-      const tables = (doc as any).getTables();
-      for (const table of tables) {
-        for (const row of table.getRows()) {
-          for (const cell of row.getCells()) {
-            for (const paragraph of cell.getParagraphs()) {
-              this.processSelectiveParagraph(paragraph, criteria, 'reject', rejected, remaining);
-            }
-          }
-        }
-      }
+      });
     } else {
       // Fallback: Filter revisions from RevisionManager only (for backward compatibility)
       const revisionManager = doc.getRevisionManager();
@@ -189,6 +161,93 @@ export class SelectiveRevisionAcceptor {
     };
   }
 
+  /**
+   * Walk every paragraph that can carry tracked-change content per
+   * ECMA-376: body, tables (recursively), headers, footers, footnotes,
+   * and endnotes. Mirrors the in-memory acceptor traversal so
+   * selective accept / reject covers the same surface as
+   * `acceptRevisionsInMemory`. Comments are deliberately excluded —
+   * `Comment` stores `Run[]` rather than `Paragraph[]`, so revisions
+   * are never represented in the in-memory model and must be cleaned
+   * via the raw-XML path on load.
+   */
+  private static walkAllParagraphs(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    doc: any,
+    visit: (paragraph: Paragraph) => void
+  ): void {
+    // Body paragraphs
+    for (const paragraph of doc.getAllParagraphs()) {
+      visit(paragraph);
+    }
+
+    // Tables (body-level)
+    for (const table of doc.getTables()) {
+      for (const row of table.getRows()) {
+        for (const cell of row.getCells()) {
+          for (const paragraph of cell.getParagraphs()) {
+            visit(paragraph);
+          }
+        }
+      }
+    }
+
+    // Headers and footers
+    const hfManager = doc.getHeaderFooterManager?.();
+    if (hfManager) {
+      for (const headerEntry of hfManager.getAllHeaders()) {
+        for (const element of headerEntry.header.getElements()) {
+          if (typeof element.getContent === 'function' && typeof element.getRuns === 'function') {
+            // Paragraph
+            visit(element);
+          } else if (typeof element.getRows === 'function') {
+            // Table
+            for (const row of element.getRows()) {
+              for (const cell of row.getCells()) {
+                for (const paragraph of cell.getParagraphs()) {
+                  visit(paragraph);
+                }
+              }
+            }
+          }
+        }
+      }
+      for (const footerEntry of hfManager.getAllFooters()) {
+        for (const element of footerEntry.footer.getElements()) {
+          if (typeof element.getContent === 'function' && typeof element.getRuns === 'function') {
+            visit(element);
+          } else if (typeof element.getRows === 'function') {
+            for (const row of element.getRows()) {
+              for (const cell of row.getCells()) {
+                for (const paragraph of cell.getParagraphs()) {
+                  visit(paragraph);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    // Footnotes and endnotes
+    const footnoteManager = doc.getFootnoteManager?.();
+    if (footnoteManager) {
+      for (const fn of footnoteManager.getAllFootnotes()) {
+        for (const paragraph of fn.getParagraphs()) {
+          visit(paragraph);
+        }
+      }
+    }
+    const endnoteManager = doc.getEndnoteManager?.();
+    if (endnoteManager) {
+      for (const en of endnoteManager.getAllEndnotes()) {
+        for (const paragraph of en.getParagraphs()) {
+          visit(paragraph);
+        }
+      }
+    }
+  }
+
   /**
    * Process a paragraph for selective revision acceptance/rejection.
    * Transforms matching revisions in-place using DOM transformation.

package/src/{utils → processors}/ShadingResolver.ts

@@ -13,11 +13,11 @@
  * - fill: "auto" = inherit (continue resolution)
  */
 
-import type { ShadingConfig } from '../elements/CommonTypes';
-import type { Table } from '../elements/Table';
-import type { TableCell } from '../elements/TableCell';
-import type { StylesManager } from '../formatting/StylesManager';
-import { getActiveConditionalsInPriorityOrder } from './cnfStyleDecoder';
+import type { ShadingConfig } from '../elements/CommonTypes.js';
+import type { Table } from '../elements/Table.js';
+import type { TableCell } from '../elements/TableCell.js';
+import type { StylesManager } from '../formatting/StylesManager.js';
+import { getActiveConditionalsInPriorityOrder } from './cnfStyleDecoder.js';
 
 /**
  * Resolves the effective shading for a table cell through the style hierarchy.

package/src/{utils → processors}/acceptRevisions.ts

@@ -1,6 +1,15 @@
-import { ZipHandler } from '../zip/ZipHandler';
-import { XMLParser } from '../xml/XMLParser';
-import { RevisionWalker } from './RevisionWalker';
+import { ZipHandler } from '../zip/ZipHandler.js';
+import { XMLParser } from '../xml/XMLParser.js';
+import { RevisionWalker } from './RevisionWalker.js';
+
+/**
+ * Markers covered: w:ins, w:del, w:moveFrom, w:moveTo,
+ * w:rPrChange, w:pPrChange, w:tblPrChange, w:tblPrExChange,
+ * w:trPrChange, w:tcPrChange, w:sectPrChange, w:numberingChange,
+ * w:cellIns, w:cellDel, w:cellMerge, and any *RangeStart/End markers.
+ */
+const REVISION_MARKER_PATTERN =
+  /<w:(?:ins|del|moveFrom|moveTo|rPrChange|pPrChange|tblPrChange|tblPrExChange|trPrChange|tcPrChange|sectPrChange|numberingChange|cellIns|cellDel|cellMerge|moveFromRangeStart|moveFromRangeEnd|moveToRangeStart|moveToRangeEnd|customXmlInsRangeStart|customXmlInsRangeEnd|customXmlDelRangeStart|customXmlDelRangeEnd|customXmlMoveFromRangeStart|customXmlMoveFromRangeEnd|customXmlMoveToRangeStart|customXmlMoveToRangeEnd)\b/;
 
 /**
  * Accepts all tracked changes in a Word document per Microsoft's OpenXML SDK pattern
@@ -40,7 +49,14 @@ class RevisionAcceptor {
     // Process document.xml
     await this.processDocumentPart('word/document.xml');
 
-    // Process headers
+    // Process headers / footers / footnotes / endnotes / comments.
+    // Footnotes (§17.11.15), endnotes (§17.11.4), and comments (§17.13.4)
+    // can all carry block-level content including tracked changes
+    // (w:ins / w:del / pPrChange / rPrChange / moveFrom / moveTo).
+    // Previously only document.xml + headers + footers were walked,
+    // leaving footnote / endnote / comment revisions unaccepted so
+    // Word still showed the document as having pending tracked
+    // changes after `acceptAllRevisions()` returned.
     const files = this.zipHandler.getFilePaths();
     for (const file of files) {
       if (/^word\/header\d+\.xml$/.exec(file)) {
@@ -50,6 +66,14 @@ class RevisionAcceptor {
         await this.processDocumentPart(file);
       }
     }
+    // Singleton notes / comments parts. Check presence explicitly
+    // (not all documents have them) — processDocumentPart is a no-op
+    // on missing files.
+    for (const notesPath of ['word/footnotes.xml', 'word/endnotes.xml', 'word/comments.xml']) {
+      if (this.zipHandler.getFileAsString(notesPath)) {
+        await this.processDocumentPart(notesPath);
+      }
+    }
 
     // Clean up metadata files
     this.cleanupPeopleXml();
@@ -61,12 +85,31 @@ class RevisionAcceptor {
    * Process a document part (document.xml, header, footer) to accept revisions
    */
   private async processDocumentPart(partPath: string): Promise<void> {
+    // Fast path: parts with no revision markup do not need to be re-serialised.
+    // Re-serialising a part destroys the original whitespace / formatting
+    // (XMLBuilder emits a different layout than the source), which can break
+    // byte-for-byte passthrough preservation in downstream consumers
+    // (e.g., comments.xml round-trip with no tracked changes inside).
+    const xml = this.zipHandler.getFileAsString(partPath);
+    if (!xml || !RevisionAcceptor.containsRevisionMarkup(xml)) {
+      return;
+    }
+
     if (this.useDomBasedProcessing) {
       return this.processDocumentPartDOM(partPath);
     }
     return this.processDocumentPartRegex(partPath);
   }
 
+  /**
+   * Quick scan for any tracked-change marker. Returns false when the part
+   * carries none, allowing the acceptor to skip an unnecessary parse +
+   * re-serialise round-trip.
+   */
+  private static containsRevisionMarkup(xml: string): boolean {
+    return REVISION_MARKER_PATTERN.test(xml);
+  }
+
   /**
    * DOM-based implementation of revision acceptance
    * Uses XMLParser and RevisionWalker for reliable processing
@@ -200,23 +243,48 @@ class RevisionAcceptor {
   }
 
   /**
-   * Accept deletions - remove the entire <w:del> element including its content
+   * Accept deletions - remove the entire <w:del> element including its content.
    *
-   * Per Microsoft SDK: "DeletedRun elements should be removed along with their content"
+   * Per Microsoft SDK: "DeletedRun elements should be removed along with
+   * their content". Additionally, per ECMA-376 Part 1 §17.13.5.14, a
+   * self-closing `<w:del/>` inside `<w:trPr>` marks the entire row as a
+   * tracked deletion — accepting it must remove the entire `<w:tr>` block,
+   * not just the marker. Without that, zombie rows (the row wrapper with
+   * empty cells) persist in the document after revision acceptance.
    */
   private acceptDeletions(xml: string): string {
     let result = xml;
     let previousLength = 0;
 
-    // Iterate until no more deletions (handles nested cases)
+    // Pass A — row-level deletion: remove entire <w:tr> whose <w:trPr>
+    // contains a self-closing row-deletion marker. Constraints:
+    //   - `<w:trPr\b(?:\s[^>]*)?>` only matches the OPEN form of trPr (i.e.
+    //     rejects self-closing `<w:trPr/>`, which by definition contains
+    //     no del markers), so the match anchors on the correct row.
+    //   - negative lookahead `(?!<w:tc\b|<w:tr\b|<\/w:tr>)` between the
+    //     `<w:tr>` opening and the `<w:trPr>` prevents the match from
+    //     slipping past a cell boundary or nested-table row and latching
+    //     onto a later row's trPr-with-del.
+    const rowDelPattern =
+      /<w:tr\b[^>]*>(?:(?!<w:tc\b|<w:tr\b|<\/w:tr>)[\s\S])*?<w:trPr\b(?:\s[^>]*)?>(?:(?!<\/w:trPr>)[\s\S])*?<w:del\b[^>]*\/>(?:(?!<\/w:trPr>)[\s\S])*?<\/w:trPr>(?:(?!<w:tr\b|<\/w:tr>)[\s\S])*?<\/w:tr>/g;
+    previousLength = 0;
     while (result.length !== previousLength) {
       previousLength = result.length;
+      result = result.replace(rowDelPattern, '');
+    }
 
-      // Match complete <w:del ...>...</w:del> elements and remove entirely
+    // Pass B — wrapper deletions: iterate until no more <w:del>..</w:del>
+    // elements (handles nested cases).
+    previousLength = 0;
+    while (result.length !== previousLength) {
+      previousLength = result.length;
       result = result.replace(/<w:del\b[^>]*>[\s\S]*?<\/w:del>/g, '');
     }
 
-    // Also remove self-closing deletion tags
+    // Pass C — remove any remaining self-closing deletion markers (paragraph
+    // mark deletions inside pPr/rPr, orphans, etc.). By this point, any
+    // row-level markers have already triggered full-row removal in Pass A,
+    // so this pass only cleans up non-structural markers.
     result = result.replace(/<w:del\b[^>]*\/>/g, '');
 
     return result;

package/src/{utils → processors}/cnfStyleDecoder.ts

@@ -6,7 +6,7 @@
  * representing whether a particular conditional format applies.
  */
 
-import { ConditionalFormattingType } from '../formatting/Style';
+import { ConditionalFormattingType } from '../formatting/Style.js';
 
 /**
  * Decoded cnfStyle flags

package/src/{utils → processors}/stripTrackedChanges.ts

@@ -1,4 +1,4 @@
-import { ZipHandler } from '../zip/ZipHandler';
+import { ZipHandler } from '../zip/ZipHandler.js';
 
 /**
  * Strips all tracked changes markup from a Word document
@@ -13,11 +13,33 @@ class TrackedChangesStripper {
   }
 
   /**
-   * Main method to strip all tracked changes from the document
+   * Main method to strip all tracked changes from the document.
+   *
+   * Per ECMA-376 Part 1, tracked-change markup can appear in any
+   * part that carries block-level content: the body (§17.2 w:body),
+   * headers / footers (§17.10.3-4 CT_HdrFtr), footnotes (§17.11.15),
+   * endnotes (§17.11.4), and comments (§17.13.4). All of these
+   * must be walked — stripping document.xml alone would leave
+   * tracked changes visible in Word for every header / footer /
+   * note / comment revision.
    */
   public async stripTrackedChanges(): Promise<void> {
-    // Strip revision elements from document.xml
-    await this.stripDocumentRevisions();
+    // Always process the body.
+    await this.stripPartRevisions('word/document.xml');
+
+    // Process every header and footer part present in the ZIP.
+    for (const file of this.zipHandler.getFilePaths()) {
+      if (/^word\/header\d+\.xml$/.exec(file) || /^word\/footer\d+\.xml$/.exec(file)) {
+        await this.stripPartRevisions(file);
+      }
+    }
+
+    // Process singleton notes / comments parts when present.
+    for (const path of ['word/footnotes.xml', 'word/endnotes.xml', 'word/comments.xml']) {
+      if (this.zipHandler.getFileAsString(path)) {
+        await this.stripPartRevisions(path);
+      }
+    }
 
     // Clean up metadata files
     await this.cleanupPeopleXml();
@@ -26,15 +48,18 @@ class TrackedChangesStripper {
   }
 
   /**
-   * Strip ALL revision elements from word/document.xml
+   * Strip ALL revision elements from a single document part.
+   * The per-step pipeline is identical to the historical
+   * document.xml implementation; the only difference is the
+   * configurable source path.
    */
-  private async stripDocumentRevisions(): Promise<void> {
-    const documentXml = this.zipHandler.getFileAsString('word/document.xml');
-    if (!documentXml) {
+  private async stripPartRevisions(partPath: string): Promise<void> {
+    const xml = this.zipHandler.getFileAsString(partPath);
+    if (!xml) {
       return;
     }
 
-    let content = documentXml;
+    let content = xml;
 
     // STEP 1: Remove all range markers (boundary markers for tracked changes)
     content = this.removeRangeMarkers(content);
@@ -56,7 +81,7 @@ class TrackedChangesStripper {
     content = this.removeSelfClosingRevisionTags(content);
 
     // Update the file in the zip
-    this.zipHandler.updateFile('word/document.xml', content);
+    this.zipHandler.updateFile(partPath, content);
   }
 
   /**