@ansonlai/docx-redline-js 0.1.4 → 0.1.6

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@ansonlai/docx-redline-js",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Host-independent OOXML reconciliation engine for .docx manipulation with track changes",
   "license": "MIT",
   "type": "module",
   "main": "./index.js",
   "module": "./index.js",
+  "types": "./index.d.ts",
   "exports": {
     ".": {
+      "types": "./index.d.ts",
       "import": "./index.js",
       "default": "./index.js"
     },
@@ -27,7 +29,10 @@
     "pipeline/",
     "services/",
     "orchestration/",
+    "scripts/",
+    "docs/",
     "index.js",
+    "index.d.ts",
     "dist/",
     "ARCHITECTURE.md",
     "AGENTS.md",
@@ -51,6 +56,8 @@
   },
   "scripts": {
     "build": "node scripts/build.mjs",
+    "check:types": "node scripts/check-types.mjs",
+    "smoke:word": "powershell -File scripts/word-com-smoke.ps1",
     "test": "node scripts/run-tests.mjs",
     "test:isolation": "node tests/no_word_api_index_check.mjs && node tests/core_dependency_graph_check.mjs",
     "prepublishOnly": "npm run test:isolation && npm run build"

package/pipeline/ingestion-export.js

@@ -112,6 +112,7 @@ function collectParagraphSegments(paragraph) {
     const runs = Array.from(paragraph?.getElementsByTagNameNS?.(NS_W, 'r') || []);
     for (const run of runs) {
         if (hasWordAncestorWithin(run, 'del', paragraph)) continue;
+        if (hasWordAncestorWithin(run, 'moveFrom', paragraph)) continue;
         const text = readRunText(run);
         if (!text) continue;
         segments.push({

package/pipeline/ingestion-paragraph.js

@@ -217,13 +217,36 @@ function getNodeHandlers(runModel) {
         return contentResult;
     });
 
-    handlers.set('del', (child, offset) => {
-        const deletionEntry = processDeletion(child, offset);
-        if (deletionEntry) {
-            runModel.push(deletionEntry);
-        }
-        return { offset, text: '' };
-    });
+    handlers.set('del', (child, offset) => {
+        const deletionEntry = processDeletion(child, offset);
+        if (deletionEntry) {
+            runModel.push(deletionEntry);
+        }
+        return { offset, text: '' };
+    });
+
+    handlers.set('moveFrom', (child, offset) => {
+        const deletionEntry = processDeletion(child, offset);
+        if (deletionEntry) {
+            runModel.push(deletionEntry);
+        }
+        return { offset, text: '' };
+    });
+
+    handlers.set('moveTo', (child, offset) => processNodeRecursive(child, offset, runModel));
+
+    for (const markerName of ['moveFromRangeStart', 'moveFromRangeEnd', 'moveToRangeStart', 'moveToRangeEnd']) {
+        handlers.set(markerName, (child, offset) => {
+            runModel.push({
+                kind: RunKind.BOOKMARK,
+                nodeXml: serializeXml(child),
+                startOffset: offset,
+                endOffset: offset,
+                text: ''
+            });
+            return { offset, text: '' };
+        });
+    }
 
     handlers.set('bookmarkStart', (child, offset) => {
         runModel.push({
@@ -320,11 +343,13 @@ function processRun(runElement, startOffset) {
     };
 }
 
-function processDeletion(delElement, offset) {
-    const author = delElement.getAttribute('w:author') || '';
-
-    let text = '';
-    const delTexts = getElementsByTagNS(delElement, NS_W, 'delText');
+function processDeletion(delElement, offset) {
+    const author = delElement.getAttribute('w:author') || '';
+
+    // Deleted text is retained as a zero-width deletion model entry for revision-aware callers.
+    // It is intentionally not added to acceptedText by the w:del handler above.
+    let text = '';
+    const delTexts = getElementsByTagNS(delElement, NS_W, 'delText');
     for (const delText of delTexts) {
         text += delText.textContent || '';
     }

package/pipeline/ingestion-table.js

@@ -20,13 +20,16 @@ import { ingestParagraphElement } from './ingestion-paragraph.js';
  * @param {Element} tableNode - w:tbl element
  * @returns {Object}
  */
-export function ingestTableToVirtualGrid(tableNode) {
-    const tblGrid = getFirstElementByTagNS(tableNode, NS_W, 'tblGrid');
-    const gridCols = tblGrid ? getElementsByTagNS(tblGrid, NS_W, 'gridCol') : [];
-    const colCount = gridCols.length;
-
-    const trElements = getElementsByTagNS(tableNode, NS_W, 'tr');
-    const rowCount = trElements.length;
+export function ingestTableToVirtualGrid(tableNode) {
+    const tblGrid = getFirstElementByTagNS(tableNode, NS_W, 'tblGrid');
+    const gridCols = tblGrid ? getElementsByTagNS(tblGrid, NS_W, 'gridCol') : [];
+    const trElements = getElementsByTagNSOrTag(tableNode, NS_W, 'tr');
+    const rowCount = trElements.length;
+    const inferredColCount = trElements.reduce((max, tr) => {
+        const tcElements = getElementsByTagNSOrTag(tr, NS_W, 'tc');
+        return Math.max(max, tcElements.length);
+    }, 0);
+    const colCount = gridCols.length || inferredColCount;
 
     const grid = Array.from({ length: rowCount }, () =>
         Array.from({ length: colCount }, () => null)
@@ -36,7 +39,7 @@ export function ingestTableToVirtualGrid(tableNode) {
 
     for (let rowIdx = 0; rowIdx < trElements.length; rowIdx++) {
         const tr = trElements[rowIdx];
-        const tcElements = getElementsByTagNS(tr, NS_W, 'tc');
+        const tcElements = getElementsByTagNSOrTag(tr, NS_W, 'tc');
         let gridCol = 0;
 
         for (let tcIdx = 0; tcIdx < tcElements.length; tcIdx++) {

package/scripts/build.mjs

@@ -0,0 +1,35 @@
+import { build } from 'esbuild';
+import { readFileSync } from 'fs';
+
+const pkg = JSON.parse(readFileSync('./package.json', 'utf8'));
+
+// ESM bundle with diff-match-patch inlined (for CDN/browser <script type="module">)
+await build({
+  entryPoints: ['./index.js'],
+  bundle: true,
+  format: 'esm',
+  outfile: 'dist/docx-redline-js.esm.js',
+  platform: 'neutral',         // no Node builtins assumed
+  target: 'es2020',
+  minify: false,                // keep readable for debugging
+  sourcemap: true,
+  banner: {
+    js: `// @ansonlai/docx-redline-js v${pkg.version} — https://github.com/AnsonLai/docx-redline-js`
+  },
+  external: ['@xmldom/xmldom']  // never bundle the Node-only XML parser
+});
+
+// Minified version for production CDN use
+await build({
+  entryPoints: ['./index.js'],
+  bundle: true,
+  format: 'esm',
+  outfile: 'dist/docx-redline-js.esm.min.js',
+  platform: 'neutral',
+  target: 'es2020',
+  minify: true,
+  sourcemap: true,
+  external: ['@xmldom/xmldom']
+});
+
+console.log('Build complete: dist/docx-redline-js.esm.js, dist/docx-redline-js.esm.min.js');

package/scripts/check-types.mjs

@@ -0,0 +1,28 @@
+import { readFileSync } from 'fs';
+
+const dts = readFileSync(new URL('../index.d.ts', import.meta.url), 'utf8');
+
+const requiredSnippets = [
+  'export interface RedlineOptions',
+  'export interface RedlineResult',
+  'export function applyRedlineToOxml',
+  'export function acceptTrackedChangesInOoxml',
+  'export function rejectTrackedChangesInOoxml',
+  'export function deleteCommentsByAuthorInOoxml'
+];
+
+for (const snippet of requiredSnippets) {
+  if (!dts.includes(snippet)) {
+    throw new Error(`Missing declaration snippet: ${snippet}`);
+  }
+}
+
+let balance = 0;
+for (const char of dts) {
+  if (char === '{') balance += 1;
+  if (char === '}') balance -= 1;
+  if (balance < 0) throw new Error('index.d.ts has unbalanced braces');
+}
+if (balance !== 0) throw new Error('index.d.ts has unbalanced braces');
+
+console.log('PASS: index.d.ts declaration smoke check');

package/scripts/export-validation-fixtures.mjs

@@ -0,0 +1,68 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+import { configureXmlProvider } from '../adapters/xml-adapter.js';
+import { applyOperationToDocumentXml } from '../services/standalone-operation-runner.js';
+
+const { DOMParser, XMLSerializer } = await import('@xmldom/xmldom');
+configureXmlProvider({ DOMParser, XMLSerializer });
+
+const NS_W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const outputDir = join(process.cwd(), 'tmp', 'validation-docx');
+mkdirSync(outputDir, { recursive: true });
+
+const baseDocument = text => `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document xmlns:w="${NS_W}">
+  <w:body>
+    <w:p><w:r><w:t>${text}</w:t></w:r></w:p>
+    <w:sectPr/>
+  </w:body>
+</w:document>`;
+
+const cases = [
+  {
+    name: 'simple-redline',
+    documentXml: baseDocument('The old sentence.'),
+    operation: { type: 'redline', target: 'The old sentence.', modified: 'The new sentence.' }
+  },
+  {
+    name: 'paragraph-insert',
+    documentXml: baseDocument('one'),
+    operation: { type: 'redline', target: 'one', modified: 'one\ntwo' }
+  },
+  {
+    name: 'format-only',
+    documentXml: baseDocument('Make word bold'),
+    operation: { type: 'redline', target: 'Make word bold', modified: 'Make **word** bold' }
+  }
+];
+
+for (const testCase of cases) {
+  const result = await applyOperationToDocumentXml(
+    testCase.documentXml,
+    testCase.operation,
+    'Validation',
+    null,
+    { generateRedlines: true }
+  );
+  writeFileSync(join(outputDir, `${testCase.name}.document.xml`), result.documentXml, 'utf8');
+  if (result.numberingXml) {
+    writeFileSync(join(outputDir, `${testCase.name}.numbering.xml`), result.numberingXml, 'utf8');
+  }
+}
+
+writeFileSync(join(outputDir, 'README.md'), `# Validation Fixtures
+
+This folder contains generated OOXML parts for release-time validation.
+
+The script writes document XML rather than complete .docx packages because this
+package intentionally does not add a zip dependency.
+
+To manually inspect these fixtures:
+
+1. Copy a generated *.document.xml file into a minimal .docx package as word/document.xml.
+2. Include any matching *.numbering.xml as word/numbering.xml.
+3. Open with Word, LibreOffice, or another OOXML consumer.
+`, 'utf8');
+
+console.log(`Wrote validation fixtures to ${outputDir}`);

package/scripts/run-tests.mjs

@@ -0,0 +1,43 @@
+import { readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const testDir = join(__dirname, '..', 'tests');
+const testFiles = readdirSync(testDir)
+  .filter(f => f.endsWith('.mjs') && f !== 'setup-xml-provider.mjs')
+  .sort();
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+const failOutputPattern = /(?:❌\s*(?:FAIL|FAILED|FAILURE|TEST FAILED)|\bTEST FAILED\b)/i;
+
+for (const file of testFiles) {
+  const filePath = join(testDir, file);
+  process.stdout.write(`  ${file} ... `);
+  try {
+    const output = execSync(`node "${filePath}"`, { stdio: 'pipe', timeout: 30000 });
+    const outputText = output.toString();
+    if (failOutputPattern.test(outputText)) {
+      throw new Error(`Test printed a failure marker while exiting successfully:\n${outputText}`);
+    }
+    console.log('PASS');
+    passed++;
+  } catch (err) {
+    console.log('FAIL');
+    const stdout = err.stdout?.toString() || '';
+    const stderr = err.stderr?.toString() || '';
+    failures.push({ file, stderr: [stdout, stderr, err.message].filter(Boolean).join('\n') });
+    failed++;
+  }
+}
+
+console.log(`\n${passed} passed, ${failed} failed out of ${passed + failed} tests`);
+if (failures.length > 0) {
+  for (const f of failures) {
+    console.error(`\n--- ${f.file} ---\n${f.stderr}`);
+  }
+  process.exit(1);
+}

package/scripts/word-com-smoke.ps1

@@ -0,0 +1,48 @@
+param(
+    [Parameter(Mandatory = $true, Position = 0)]
+    [string]$Path
+)
+
+$resolved = Resolve-Path -LiteralPath $Path -ErrorAction Stop
+$word = $null
+$document = $null
+
+try {
+    $word = New-Object -ComObject Word.Application
+    $word.Visible = $false
+
+    $document = $word.Documents.Open(
+        [string]$resolved,
+        $false,
+        $true,
+        $false,
+        [Type]::Missing,
+        [Type]::Missing,
+        $false,
+        [Type]::Missing,
+        [Type]::Missing,
+        [Type]::Missing,
+        [Type]::Missing,
+        $false,
+        $false,
+        $false,
+        $false,
+        $false
+    )
+
+    Write-Output "Opened: $resolved"
+    Write-Output "Revisions: $($document.Revisions.Count)"
+    Write-Output "PASS: Word opened the document without throwing."
+}
+catch {
+    Write-Error "FAIL: Word could not open '$resolved'. $($_.Exception.Message)"
+    exit 1
+}
+finally {
+    if ($document -ne $null) {
+        $document.Close($false) | Out-Null
+    }
+    if ($word -ne $null) {
+        $word.Quit() | Out-Null
+    }
+}

package/services/comment-locator.js

@@ -2,8 +2,9 @@
  * Comment text location and marker injection helpers.
  */
 
-import { NS_W } from '../core/types.js';
-import { getElementsByTag, getFirstElementByTag } from '../core/xml-query.js';
+import { NS_W } from '../core/types.js';
+import { createWordElement } from '../core/word-xml.js';
+import { getElementsByTag, getFirstElementByTag } from '../core/xml-query.js';
 
 /**
  * Builds a paragraph text index in a single pass for repeated lookups.
@@ -67,13 +68,13 @@ export function findTextInParagraphIndex(paragraphIndex, searchText) {
     };
 }
 
-function cloneRunWithText(xmlDoc, rPr, newText) {
-    const newRun = xmlDoc.createElementNS(NS_W, 'w:r');
+function cloneRunWithText(xmlDoc, rPr, newText) {
+    const newRun = createWordElement(xmlDoc, 'w:r');
     if (rPr) {
         newRun.appendChild(rPr.cloneNode(true));
     }
 
-    const newTextNode = xmlDoc.createElementNS(NS_W, 'w:t');
+    const newTextNode = createWordElement(xmlDoc, 'w:t');
     newTextNode.setAttribute('xml:space', 'preserve');
     newTextNode.textContent = newText;
     newRun.appendChild(newTextNode);
@@ -97,14 +98,14 @@ export function injectMarkersIntoParagraph(xmlDoc, paragraph, textToFind, commen
         return false;
     }
 
-    const startMarker = xmlDoc.createElementNS(NS_W, 'w:commentRangeStart');
+    const startMarker = createWordElement(xmlDoc, 'w:commentRangeStart');
     startMarker.setAttribute('w:id', String(commentId));
 
-    const endMarker = xmlDoc.createElementNS(NS_W, 'w:commentRangeEnd');
+    const endMarker = createWordElement(xmlDoc, 'w:commentRangeEnd');
     endMarker.setAttribute('w:id', String(commentId));
 
-    const referenceRun = xmlDoc.createElementNS(NS_W, 'w:r');
-    const reference = xmlDoc.createElementNS(NS_W, 'w:commentReference');
+    const referenceRun = createWordElement(xmlDoc, 'w:r');
+    const reference = createWordElement(xmlDoc, 'w:commentReference');
     reference.setAttribute('w:id', String(commentId));
     referenceRun.appendChild(reference);
 

package/services/revision-comment-management.js

@@ -4,6 +4,7 @@
 
 import { NS_W } from '../core/types.js';
 import { createParser, createSerializer } from '../adapters/xml-adapter.js';
+import { createWordElement } from '../core/word-xml.js';
 import { getXmlParseError } from '../core/xml-query.js';
 
 function getAttributeByLocalName(node, localName) {
@@ -97,6 +98,41 @@ function isTableRowRevisionMarker(node) {
     return isWordElement(parent, 'trPr') && isWordElement(parent?.parentNode, 'tr');
 }
 
+function isParagraphMarkRevisionMarker(node) {
+    const rPr = node?.parentNode;
+    const pPr = rPr?.parentNode;
+    const paragraph = pPr?.parentNode;
+    return isWordElement(rPr, 'rPr') && isWordElement(pPr, 'pPr') && isWordElement(paragraph, 'p');
+}
+
+function getContainingParagraphMarkRevision(node) {
+    return isParagraphMarkRevisionMarker(node) ? node.parentNode.parentNode.parentNode : null;
+}
+
+function getNextWordParagraph(paragraph) {
+    let cursor = paragraph?.nextSibling || null;
+    while (cursor) {
+        if (isWordElement(cursor, 'p')) return cursor;
+        cursor = cursor.nextSibling;
+    }
+    return null;
+}
+
+function mergeParagraphIntoNextAndRemove(paragraph) {
+    if (!paragraph?.parentNode) return false;
+    const nextParagraph = getNextWordParagraph(paragraph);
+    if (!nextParagraph) {
+        return removeNode(paragraph);
+    }
+
+    const childrenToMove = Array.from(paragraph.childNodes || []).filter(child => !isWordElement(child, 'pPr'));
+    const insertionPoint = nextParagraph.firstChild || null;
+    for (const child of childrenToMove) {
+        nextParagraph.insertBefore(child, insertionPoint);
+    }
+    return removeNode(paragraph);
+}
+
 /**
  * Accepts tracked changes (`w:ins`, `w:del`, and *PrChange tags) for one author
  * or all authors in the provided OOXML payload.
@@ -122,6 +158,10 @@ export function acceptTrackedChangesInOoxml(oxml, options = {}) {
 
     for (const insNode of getWordElementsByLocalName(xmlDoc, 'ins')) {
         if (!insNode.parentNode || !authorMatchesNode(insNode, filter)) continue;
+        if (isParagraphMarkRevisionMarker(insNode)) {
+            if (removeNode(insNode)) acceptedCount += 1;
+            continue;
+        }
         if (isTableRowRevisionMarker(insNode)) {
             if (removeNode(insNode)) acceptedCount += 1;
             continue;
@@ -131,6 +171,11 @@ export function acceptTrackedChangesInOoxml(oxml, options = {}) {
 
     for (const delNode of getWordElementsByLocalName(xmlDoc, 'del')) {
         if (!delNode.parentNode || !authorMatchesNode(delNode, filter)) continue;
+        const paragraphMark = getContainingParagraphMarkRevision(delNode);
+        if (paragraphMark) {
+            if (mergeParagraphIntoNextAndRemove(paragraphMark)) acceptedCount += 1;
+            continue;
+        }
         if (isTableRowRevisionMarker(delNode)) {
             const rowNode = delNode.parentNode?.parentNode;
             if (removeNode(rowNode)) acceptedCount += 1;
@@ -139,6 +184,18 @@ export function acceptTrackedChangesInOoxml(oxml, options = {}) {
         if (removeNode(delNode)) acceptedCount += 1;
     }
 
+    for (const moveFromNode of getWordElementsByLocalName(xmlDoc, 'moveFrom')) {
+        if (!moveFromNode.parentNode || !authorMatchesNode(moveFromNode, filter)) continue;
+        if (removeNode(moveFromNode)) acceptedCount += 1;
+    }
+
+    for (const moveToNode of getWordElementsByLocalName(xmlDoc, 'moveTo')) {
+        if (!moveToNode.parentNode || !authorMatchesNode(moveToNode, filter)) continue;
+        if (unwrapNode(moveToNode)) acceptedCount += 1;
+    }
+
+    acceptedCount += removeMoveRangeMarkers(xmlDoc, filter);
+
     const changeTags = ['rPrChange', 'pPrChange', 'tblPrChange', 'trPrChange', 'tcPrChange'];
     for (const localName of changeTags) {
         for (const changeNode of getWordElementsByLocalName(xmlDoc, localName)) {
@@ -157,7 +214,7 @@ export function acceptTrackedChangesInOoxml(oxml, options = {}) {
 
 function convertDeletionTextNodes(xmlDoc, delNode) {
     for (const delTextNode of Array.from(delNode.getElementsByTagNameNS(NS_W, 'delText'))) {
-        const normalText = xmlDoc.createElementNS(NS_W, 'w:t');
+        const normalText = createWordElement(xmlDoc, 'w:t');
         const spaceValue = delTextNode.getAttribute('xml:space');
         if (spaceValue) {
             normalText.setAttribute('xml:space', spaceValue);
@@ -212,6 +269,41 @@ function xmlDocImportNode(xmlDoc, node) {
     return node.cloneNode(true);
 }
 
+function collectMoveRangeStartIds(xmlDoc, localName, filter) {
+    const ids = new Set();
+    for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+        if (!authorMatchesNode(node, filter)) continue;
+        const id = getAttributeByLocalName(node, 'id');
+        if (id) ids.add(id);
+    }
+    return ids;
+}
+
+function removeMoveRangeMarkers(xmlDoc, filter) {
+    let removed = 0;
+    const moveFromIds = collectMoveRangeStartIds(xmlDoc, 'moveFromRangeStart', filter);
+    const moveToIds = collectMoveRangeStartIds(xmlDoc, 'moveToRangeStart', filter);
+    const markerSpecs = [
+        ['moveFromRangeStart', moveFromIds, true],
+        ['moveFromRangeEnd', moveFromIds, false],
+        ['moveToRangeStart', moveToIds, true],
+        ['moveToRangeEnd', moveToIds, false]
+    ];
+
+    for (const [localName, ids, isStart] of markerSpecs) {
+        for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+            if (!node.parentNode) continue;
+            const id = getAttributeByLocalName(node, 'id');
+            if (!id) continue;
+            if (filter.allAuthors || ids.has(id) || (isStart && authorMatchesNode(node, filter))) {
+                if (removeNode(node)) removed += 1;
+            }
+        }
+    }
+
+    return removed;
+}
+
 /**
  * Rejects tracked changes (`w:ins`, `w:del`, and *PrChange tags) for one author
  * or all authors in the provided OOXML payload.
@@ -237,6 +329,11 @@ export function rejectTrackedChangesInOoxml(oxml, options = {}) {
 
     for (const insNode of getWordElementsByLocalName(xmlDoc, 'ins')) {
         if (!insNode.parentNode || !authorMatchesNode(insNode, filter)) continue;
+        const paragraphMark = getContainingParagraphMarkRevision(insNode);
+        if (paragraphMark) {
+            if (mergeParagraphIntoNextAndRemove(paragraphMark)) rejectedCount += 1;
+            continue;
+        }
         if (isTableRowRevisionMarker(insNode)) {
             const rowNode = insNode.parentNode?.parentNode;
             if (removeNode(rowNode)) rejectedCount += 1;
@@ -247,6 +344,10 @@ export function rejectTrackedChangesInOoxml(oxml, options = {}) {
 
     for (const delNode of getWordElementsByLocalName(xmlDoc, 'del')) {
         if (!delNode.parentNode || !authorMatchesNode(delNode, filter)) continue;
+        if (isParagraphMarkRevisionMarker(delNode)) {
+            if (removeNode(delNode)) rejectedCount += 1;
+            continue;
+        }
         if (isTableRowRevisionMarker(delNode)) {
             if (removeNode(delNode)) rejectedCount += 1;
             continue;
@@ -255,6 +356,19 @@ export function rejectTrackedChangesInOoxml(oxml, options = {}) {
         if (unwrapNode(delNode)) rejectedCount += 1;
     }
 
+    for (const moveFromNode of getWordElementsByLocalName(xmlDoc, 'moveFrom')) {
+        if (!moveFromNode.parentNode || !authorMatchesNode(moveFromNode, filter)) continue;
+        convertDeletionTextNodes(xmlDoc, moveFromNode);
+        if (unwrapNode(moveFromNode)) rejectedCount += 1;
+    }
+
+    for (const moveToNode of getWordElementsByLocalName(xmlDoc, 'moveTo')) {
+        if (!moveToNode.parentNode || !authorMatchesNode(moveToNode, filter)) continue;
+        if (removeNode(moveToNode)) rejectedCount += 1;
+    }
+
+    rejectedCount += removeMoveRangeMarkers(xmlDoc, filter);
+
     const changeTags = ['rPrChange', 'pPrChange', 'tblPrChange', 'trPrChange', 'tcPrChange'];
     for (const localName of changeTags) {
         for (const changeNode of getWordElementsByLocalName(xmlDoc, localName)) {