@ansonlai/docx-redline-js 0.1.4 → 0.2.0

package/scripts/lib/minimal-zip.mjs

@@ -0,0 +1,155 @@
+/**
+ * Minimal zip writer for assembling validation .docx fixtures.
+ *
+ * Script-only helper (not part of the published API surface) so the package
+ * keeps its no-zip-dependency guarantee while release tooling can still emit
+ * real .docx files for Word/LibreOffice validation. Uses deflate via
+ * node:zlib and a fixed timestamp for deterministic output.
+ */
+
+import { deflateRawSync } from 'zlib';
+
+const CRC_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++) {
+            c = c & 1 ? 0xEDB88320 ^ (c >>> 1) : c >>> 1;
+        }
+        table[n] = c >>> 0;
+    }
+    return table;
+})();
+
+function crc32(buffer) {
+    let crc = 0xFFFFFFFF;
+    for (let i = 0; i < buffer.length; i++) {
+        crc = CRC_TABLE[(crc ^ buffer[i]) & 0xFF] ^ (crc >>> 8);
+    }
+    return (crc ^ 0xFFFFFFFF) >>> 0;
+}
+
+// Fixed DOS date/time (2026-01-01 00:00:00) keeps fixture bytes deterministic.
+const DOS_TIME = 0;
+const DOS_DATE = ((2026 - 1980) << 9) | (1 << 5) | 1;
+
+/**
+ * Builds a zip archive.
+ *
+ * @param {Array<{ name: string, data: Buffer|string }>} entries - Entry names
+ *   must use forward slashes (OPC requirement for .docx parts).
+ * @returns {Buffer}
+ */
+export function buildZip(entries) {
+    const localParts = [];
+    const centralParts = [];
+    let offset = 0;
+
+    for (const entry of entries) {
+        const nameBytes = Buffer.from(entry.name, 'utf8');
+        const data = Buffer.isBuffer(entry.data) ? entry.data : Buffer.from(entry.data, 'utf8');
+        const crc = crc32(data);
+
+        const deflated = deflateRawSync(data, { level: 9 });
+        const useDeflate = deflated.length < data.length;
+        const method = useDeflate ? 8 : 0;
+        const payload = useDeflate ? deflated : data;
+
+        const localHeader = Buffer.alloc(30);
+        localHeader.writeUInt32LE(0x04034B50, 0);
+        localHeader.writeUInt16LE(20, 4);            // version needed
+        localHeader.writeUInt16LE(0, 6);             // flags
+        localHeader.writeUInt16LE(method, 8);
+        localHeader.writeUInt16LE(DOS_TIME, 10);
+        localHeader.writeUInt16LE(DOS_DATE, 12);
+        localHeader.writeUInt32LE(crc, 14);
+        localHeader.writeUInt32LE(payload.length, 18);
+        localHeader.writeUInt32LE(data.length, 22);
+        localHeader.writeUInt16LE(nameBytes.length, 26);
+        localHeader.writeUInt16LE(0, 28);            // extra length
+
+        localParts.push(localHeader, nameBytes, payload);
+
+        const centralHeader = Buffer.alloc(46);
+        centralHeader.writeUInt32LE(0x02014B50, 0);
+        centralHeader.writeUInt16LE(20, 4);          // version made by
+        centralHeader.writeUInt16LE(20, 6);          // version needed
+        centralHeader.writeUInt16LE(0, 8);           // flags
+        centralHeader.writeUInt16LE(method, 10);
+        centralHeader.writeUInt16LE(DOS_TIME, 12);
+        centralHeader.writeUInt16LE(DOS_DATE, 14);
+        centralHeader.writeUInt32LE(crc, 16);
+        centralHeader.writeUInt32LE(payload.length, 20);
+        centralHeader.writeUInt32LE(data.length, 24);
+        centralHeader.writeUInt16LE(nameBytes.length, 28);
+        centralHeader.writeUInt16LE(0, 30);          // extra length
+        centralHeader.writeUInt16LE(0, 32);          // comment length
+        centralHeader.writeUInt16LE(0, 34);          // disk number
+        centralHeader.writeUInt16LE(0, 36);          // internal attrs
+        centralHeader.writeUInt32LE(0, 38);          // external attrs
+        centralHeader.writeUInt32LE(offset, 42);
+
+        centralParts.push(centralHeader, nameBytes);
+        offset += localHeader.length + nameBytes.length + payload.length;
+    }
+
+    const centralDirectory = Buffer.concat(centralParts);
+
+    const endRecord = Buffer.alloc(22);
+    endRecord.writeUInt32LE(0x06054B50, 0);
+    endRecord.writeUInt16LE(0, 4);                   // disk number
+    endRecord.writeUInt16LE(0, 6);                   // central dir start disk
+    endRecord.writeUInt16LE(entries.length, 8);
+    endRecord.writeUInt16LE(entries.length, 10);
+    endRecord.writeUInt32LE(centralDirectory.length, 12);
+    endRecord.writeUInt32LE(offset, 16);
+    endRecord.writeUInt16LE(0, 20);                  // comment length
+
+    return Buffer.concat([...localParts, centralDirectory, endRecord]);
+}
+
+const CONTENT_TYPES_BASE = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
+%OVERRIDES%</Types>`;
+
+const ROOT_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>
+</Relationships>`;
+
+/**
+ * Assembles a minimal .docx package around a word/document.xml payload.
+ *
+ * @param {string} documentXml - Complete word/document.xml content
+ * @param {{ numberingXml?: string|null }} [parts] - Optional extra parts
+ * @returns {Buffer} - .docx bytes
+ */
+export function buildMinimalDocx(documentXml, parts = {}) {
+    const overrides = [];
+    const documentRels = [];
+    const entries = [];
+
+    if (parts.numberingXml) {
+        overrides.push('  <Override PartName="/word/numbering.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"/>\n');
+        documentRels.push('  <Relationship Id="rIdNum1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering" Target="numbering.xml"/>');
+    }
+
+    entries.push({ name: '[Content_Types].xml', data: CONTENT_TYPES_BASE.replace('%OVERRIDES%', overrides.join('')) });
+    entries.push({ name: '_rels/.rels', data: ROOT_RELS });
+    entries.push({
+        name: 'word/_rels/document.xml.rels',
+        data: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+${documentRels.join('\n')}
+</Relationships>`
+    });
+    entries.push({ name: 'word/document.xml', data: documentXml });
+    if (parts.numberingXml) {
+        entries.push({ name: 'word/numbering.xml', data: parts.numberingXml });
+    }
+
+    return buildZip(entries);
+}

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/validate-fixtures-xsd.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+# Validates generated validation fixtures against the ECMA-376 transitional
+# wordprocessingml XSD using xmllint. Used by the nightly validation workflow
+# and runnable locally on any machine with curl, unzip, and xmllint.
+#
+# Usage: scripts/validate-fixtures-xsd.sh [fixtures-dir]
+set -euo pipefail
+
+FIXTURES_DIR="${1:-tmp/validation-docx}"
+CACHE_DIR="${OOXML_SCHEMA_DIR:-.cache/ooxml-schemas}"
+ECMA_ZIP_URL="https://ecma-international.org/wp-content/uploads/ECMA-376-4_5th_edition_december_2016.zip"
+XML_XSD_URL="https://www.w3.org/2001/xml.xsd"
+
+command -v xmllint >/dev/null || { echo "xmllint not found (install libxml2-utils)"; exit 1; }
+
+shopt -s nullglob
+fixtures=("$FIXTURES_DIR"/*.document.xml)
+if [ ${#fixtures[@]} -eq 0 ]; then
+  echo "No *.document.xml fixtures in $FIXTURES_DIR — run: node scripts/export-validation-fixtures.mjs"
+  exit 1
+fi
+
+if [ ! -f "$CACHE_DIR/wml.xsd" ]; then
+  echo "Downloading ECMA-376 Part 4 transitional schemas..."
+  mkdir -p "$CACHE_DIR"
+  curl -sSL --retry 3 -o "$CACHE_DIR/ecma376-4.zip" "$ECMA_ZIP_URL"
+  unzip -o -q "$CACHE_DIR/ecma376-4.zip" "OfficeOpenXML-XMLSchema-Transitional.zip" -d "$CACHE_DIR"
+  unzip -o -q "$CACHE_DIR/OfficeOpenXML-XMLSchema-Transitional.zip" -d "$CACHE_DIR"
+  curl -sSL --retry 3 -o "$CACHE_DIR/xml.xsd" "$XML_XSD_URL"
+  # ECMA's published XSDs import the xml namespace without a schemaLocation;
+  # point them at the local copy so xmllint can compile offline.
+  sed -i.bak 's|<xsd:import namespace="http://www.w3.org/XML/1998/namespace"/>|<xsd:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="xml.xsd"/>|' "$CACHE_DIR"/*.xsd
+  rm -f "$CACHE_DIR"/*.xsd.bak "$CACHE_DIR/ecma376-4.zip"
+fi
+
+xmllint --noout --schema "$CACHE_DIR/wml.xsd" "${fixtures[@]}"
+echo "XSD validation passed for ${#fixtures[@]} fixture(s)."

package/scripts/word-com-differential.ps1

@@ -0,0 +1,133 @@
+param(
+    [string]$FixturesDir = "tmp/validation-docx"
+)
+
+# Differential validation against desktop Microsoft Word (the authoritative
+# OOXML consumer). For each generated fixture, Word itself accepts all
+# revisions and then rejects all revisions, and the resulting document text
+# is compared to the expected outcomes recorded at generation time. This
+# makes Word an independent oracle for the redline engine instead of
+# verifying the library against its own accept/reject transforms.
+#
+# Usage:
+#   node scripts/export-validation-fixtures.mjs
+#   npm run smoke:word:diff
+
+$ErrorActionPreference = 'Stop'
+
+function Get-NormalizedText([string]$text) {
+    if ($null -eq $text) { return '' }
+    $text = $text -replace [string][char]7, ' '   # table cell markers
+    return ($text -replace '\s+', ' ').Trim()
+}
+
+$resolvedDir = Resolve-Path -LiteralPath $FixturesDir -ErrorAction SilentlyContinue
+if (-not $resolvedDir) {
+    Write-Error "Fixtures directory '$FixturesDir' not found. Run: node scripts/export-validation-fixtures.mjs"
+    exit 1
+}
+
+$expectations = Get-ChildItem -LiteralPath $resolvedDir -Filter '*.expected.json' | Sort-Object Name
+if ($expectations.Count -eq 0) {
+    Write-Error "No *.expected.json fixtures in '$resolvedDir'. Run: node scripts/export-validation-fixtures.mjs"
+    exit 1
+}
+
+$word = $null
+$failures = 0
+$results = @()
+
+function Open-FixtureDocument($word, [string]$path) {
+    # Single-argument Open: Windows PowerShell 5.1 COM binding rejects the
+    # long optional-parameter signature. Defaults leave the document
+    # writable, which accept/reject requires; nothing is ever saved.
+    return $word.Documents.Open($path)
+}
+
+try {
+    $word = New-Object -ComObject Word.Application
+    $word.Visible = $false
+    $word.DisplayAlerts = 0  # wdAlertsNone
+
+    foreach ($expectationFile in $expectations) {
+        $name = $expectationFile.BaseName -replace '\.expected$', ''
+        $docxPath = Join-Path $resolvedDir "$name.docx"
+        if (-not (Test-Path -LiteralPath $docxPath)) {
+            Write-Warning "SKIP ${name}: no matching .docx"
+            continue
+        }
+
+        # -Encoding UTF8 is required: Windows PowerShell 5.1 otherwise reads
+        # BOM-less UTF-8 sidecars as ANSI and garbles non-ASCII expectations.
+        $expected = Get-Content -LiteralPath $expectationFile.FullName -Raw -Encoding UTF8 | ConvertFrom-Json
+        $expectedAccepted = Get-NormalizedText $expected.expectedAcceptedText
+        $expectedRejected = Get-NormalizedText $expected.expectedRejectedText
+        $caseFailed = $false
+        $document = $null
+
+        # Phase 1: open cleanly, revisions present, accept-all matches intent.
+        try {
+            $document = Open-FixtureDocument $word ([string]$docxPath)
+            $revisionCount = $document.Revisions.Count
+            if ($revisionCount -lt 1) {
+                Write-Output "FAIL ${name}: Word sees no tracked revisions"
+                $caseFailed = $true
+            }
+            else {
+                $document.AcceptAllRevisions()
+                $acceptedText = Get-NormalizedText $document.Content.Text
+                if ($acceptedText -ne $expectedAccepted) {
+                    Write-Output "FAIL ${name}: accept-all mismatch"
+                    Write-Output "  expected: $expectedAccepted"
+                    Write-Output "  actual:   $acceptedText"
+                    $caseFailed = $true
+                }
+            }
+        }
+        catch {
+            Write-Output "FAIL ${name}: Word could not open/accept: $($_.Exception.Message)"
+            $caseFailed = $true
+        }
+        finally {
+            if ($null -ne $document) { $document.Close(0) | Out-Null; $document = $null }
+        }
+
+        # Phase 2: fresh open, reject-all restores the original text.
+        if (-not $caseFailed) {
+            try {
+                $document = Open-FixtureDocument $word ([string]$docxPath)
+                $document.RejectAllRevisions()
+                $rejectedText = Get-NormalizedText $document.Content.Text
+                if ($rejectedText -ne $expectedRejected) {
+                    Write-Output "FAIL ${name}: reject-all mismatch"
+                    Write-Output "  expected: $expectedRejected"
+                    Write-Output "  actual:   $rejectedText"
+                    $caseFailed = $true
+                }
+            }
+            catch {
+                Write-Output "FAIL ${name}: Word could not open/reject: $($_.Exception.Message)"
+                $caseFailed = $true
+            }
+            finally {
+                if ($null -ne $document) { $document.Close(0) | Out-Null; $document = $null }
+            }
+        }
+
+        if ($caseFailed) {
+            $failures++
+            $results += "FAIL $name"
+        }
+        else {
+            Write-Output "PASS ${name} (revisions: $revisionCount)"
+            $results += "PASS $name"
+        }
+    }
+}
+finally {
+    if ($null -ne $word) { $word.Quit() | Out-Null }
+}
+
+Write-Output ""
+Write-Output "Word differential: $($results.Count - $failures)/$($results.Count) fixtures passed."
+if ($failures -gt 0) { 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)) {