@ansonlai/docx-redline-js 0.8.3 → 0.9.0

package/services/revision-comment-management.js

@@ -1,594 +1,634 @@
-/**
- * Revision/comment management utilities for OOXML payloads.
- */
-
-import { NS_W } from '../core/types.js';
-import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
-import { createWordElement } from '../core/word-xml.js';
-import { getXmlParseError } from '../core/xml-query.js';
-
-function getAttributeByLocalName(node, localName) {
-    if (!node || !node.attributes) return '';
-    for (const attr of Array.from(node.attributes)) {
-        if ((attr.localName || '').toLowerCase() === localName.toLowerCase()) {
-            return String(attr.value || '');
-        }
-    }
-    return String(
-        node.getAttribute?.(`w:${localName}`)
-        || node.getAttribute?.(localName)
-        || ''
-    );
-}
-
-function normalizeAuthor(author) {
-    return typeof author === 'string' ? author.trim().toLowerCase() : '';
-}
-
-function isElement(node) {
-    return !!node && node.nodeType === 1;
-}
-
-function isWordElement(node, localName) {
-    return isElement(node)
-        && node.namespaceURI === NS_W
-        && String(node.localName || '').toLowerCase() === localName.toLowerCase();
-}
-
-function getWordElementsByLocalName(xmlDoc, localName) {
-    return Array.from(xmlDoc.getElementsByTagNameNS(NS_W, localName));
-}
-
-function resolveAuthorFilter(options = {}) {
-    if (options?.allAuthors === true) {
-        return { valid: true, allAuthors: true, normalizedAuthor: '' };
-    }
-    const normalizedAuthor = normalizeAuthor(options?.author);
-    if (!normalizedAuthor) {
-        return {
-            valid: false,
-            allAuthors: false,
-            normalizedAuthor: '',
-            warning: 'No author provided. Pass { author } or set { allAuthors: true }.'
-        };
-    }
-    return { valid: true, allAuthors: false, normalizedAuthor };
-}
-
-function authorMatchesNode(node, filter) {
-    if (filter.allAuthors) return true;
-    const nodeAuthor = normalizeAuthor(getAttributeByLocalName(node, 'author'));
-    return !!nodeAuthor && nodeAuthor === filter.normalizedAuthor;
-}
-
-function parseXmlWithWarnings(oxml, parseFailurePrefix) {
-    let rawOxml = typeof oxml === 'string' ? oxml.replace(/^\uFEFF/, '').trim() : '';
-    let isFragmentWrapped = false;
-    let parsed = parseOoxmlSafe(rawOxml, 'application/xml');
-    if (parsed.error && (parsed.error.message.includes('HierarchyRequestError') || parsed.error.message.includes('Only one element'))) {
-        const wrapped = `<w:body xmlns:w="${NS_W}">${rawOxml}</w:body>`;
-        const wrappedParsed = parseOoxmlSafe(wrapped, 'application/xml');
-        if (!wrappedParsed.error) {
-            parsed = wrappedParsed;
-            isFragmentWrapped = true;
-        }
-    }
-    const parseError = parsed.doc ? getXmlParseError(parsed.doc) : null;
-    if (parsed.error || parseError) {
-        const message = parsed.error?.message || parseError?.textContent || 'parse error';
-        return {
-            xmlDoc: null,
-            serializer: null,
-            isFragmentWrapped: false,
-            warning: `${parseFailurePrefix}: ${message}`,
-            warnings: parsed.warnings,
-            error: { code: 'PARSE_ERROR', message }
-        };
-    }
-    return {
-        xmlDoc: parsed.doc,
-        serializer: createSerializer(),
-        isFragmentWrapped,
-        warning: null,
-        warnings: parsed.warnings,
-        error: null
-    };
-}
-
-function removeNode(node) {
-    if (node?.parentNode) {
-        node.parentNode.removeChild(node);
-        return true;
-    }
-    return false;
-}
-
-function unwrapNode(node) {
-    const parent = node?.parentNode;
-    if (!parent) return false;
-    while (node.firstChild) {
-        parent.insertBefore(node.firstChild, node);
-    }
-    parent.removeChild(node);
-    return true;
-}
-
-function nextElementSibling(node) {
-    let sibling = node?.nextSibling || null;
-    while (sibling && sibling.nodeType !== 1) sibling = sibling.nextSibling;
-    return sibling;
-}
-
-function revisionMetadataWithoutId(node) {
-    return Array.from(node?.attributes || [])
-        .filter(attribute => String(attribute.localName || attribute.name || '').toLowerCase() !== 'id')
-        .map(attribute => `${attribute.namespaceURI || ''}|${attribute.localName || attribute.name}=${attribute.value}`)
-        .sort()
-        .join('\n');
-}
-
-function coalesceAdjacentCompatibleInsertions(xmlDoc) {
-    let coalesced = 0;
-    const insertions = getWordElementsByLocalName(xmlDoc, 'ins');
-
-    for (const insertion of insertions) {
-        if (!insertion.parentNode || isParagraphMarkRevisionMarker(insertion)) continue;
-        let sibling = nextElementSibling(insertion);
-        while (
-            isWordElement(sibling, 'ins')
-            && normalizeAuthor(getAttributeByLocalName(sibling, 'author'))
-                === normalizeAuthor(getAttributeByLocalName(insertion, 'author'))
-            && revisionMetadataWithoutId(sibling) === revisionMetadataWithoutId(insertion)
-        ) {
-            const next = nextElementSibling(sibling);
-            while (sibling.firstChild) insertion.appendChild(sibling.firstChild);
-            sibling.parentNode?.removeChild(sibling);
-            coalesced += 1;
-            sibling = next;
-        }
-    }
-
-    return coalesced;
-}
-
-function isTableRowRevisionMarker(node) {
-    const parent = node?.parentNode;
-    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) {
-        if (isWordElement(paragraph.parentNode, 'tc') && getWordElementsByLocalName(paragraph.parentNode, 'p').length <= 1) {
-            return false;
-        }
-        return removeNode(paragraph);
-    }
-
-    const childrenToMove = Array.from(paragraph.childNodes || []).filter(child => !isWordElement(child, 'pPr'));
-    let insertionPoint = nextParagraph.firstChild || null;
-    if (isWordElement(insertionPoint, 'pPr')) {
-        insertionPoint = insertionPoint.nextSibling || 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.
- *
- * @param {string} oxml
- * @param {{ author?: string, allAuthors?: boolean }} [options]
- * @returns {{ oxml: string, hasChanges: boolean, acceptedCount: number, warnings: string[] }}
- */
-export function acceptTrackedChangesInOoxml(oxml, options = {}) {
-    const warnings = [];
-    const filter = resolveAuthorFilter(options);
-    if (!filter.valid) {
-        return { oxml, hasChanges: false, acceptedCount: 0, warnings: [filter.warning] };
-    }
-
-    const parseResult = parseXmlWithWarnings(oxml, 'Failed to parse OOXML');
-    if (!parseResult.xmlDoc) {
-        return {
-            oxml,
-            hasChanges: false,
-            acceptedCount: 0,
-            status: 'error',
-            error: parseResult.error,
-            warnings: [...(parseResult.warnings || []), parseResult.warning]
-        };
-    }
-
-    const { xmlDoc, serializer } = parseResult;
-    warnings.push(...(parseResult.warnings || []));
-    let acceptedCount = 0;
-
-    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;
-        }
-        if (unwrapNode(insNode)) acceptedCount += 1;
-    }
-
-    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;
-            continue;
-        }
-        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)) {
-            if (!changeNode.parentNode || !authorMatchesNode(changeNode, filter)) continue;
-            if (removeNode(changeNode)) acceptedCount += 1;
-        }
-    }
-
-    const serializedOxml = parseResult.isFragmentWrapped
-        ? Array.from(xmlDoc.documentElement.childNodes).map(n => serializer.serializeToString(n)).join('')
-        : serializer.serializeToString(xmlDoc);
-
-    return {
-        oxml: serializedOxml,
-        hasChanges: acceptedCount > 0,
-        acceptedCount,
-        warnings
-    };
-}
-
-function convertDeletionTextNodes(xmlDoc, delNode) {
-    for (const delTextNode of Array.from(delNode.getElementsByTagNameNS(NS_W, 'delText'))) {
-        const normalText = createWordElement(xmlDoc, 'w:t');
-        const spaceValue = delTextNode.getAttribute('xml:space');
-        if (spaceValue) {
-            normalText.setAttribute('xml:space', spaceValue);
-        }
-        while (delTextNode.firstChild) {
-            normalText.appendChild(delTextNode.firstChild);
-        }
-        delTextNode.parentNode?.replaceChild(normalText, delTextNode);
-    }
-}
-
-function rejectPropertyChangeNode(changeNode, localName) {
-    const parent = changeNode?.parentNode;
-    if (!parent) return false;
-
-    const baseLocalName = localName.endsWith('Change')
-        ? localName.slice(0, -'Change'.length)
-        : '';
-
-    if (
-        !baseLocalName
-        || String(parent.localName || '').toLowerCase() !== baseLocalName.toLowerCase()
-        || parent.namespaceURI !== NS_W
-    ) {
-        return removeNode(changeNode);
-    }
-
-    const historicalNode = Array.from(changeNode.childNodes || []).find(
-        child => child.nodeType === 1 && child.namespaceURI === NS_W
-            && String(child.localName || '').toLowerCase() === baseLocalName.toLowerCase()
-    );
-
-    if (!historicalNode) {
-        return removeNode(changeNode);
-    }
-
-    const toAppend = Array.from(historicalNode.childNodes || []);
-    while (parent.firstChild) {
-        parent.removeChild(parent.firstChild);
-    }
-    for (const node of toAppend) {
-        const clone = xmlDocImportNode(parent.ownerDocument, node);
-        parent.appendChild(clone);
-    }
-    return true;
-}
-
-function xmlDocImportNode(xmlDoc, node) {
-    if (xmlDoc && typeof xmlDoc.importNode === 'function') {
-        return xmlDoc.importNode(node, true);
-    }
-    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.
- *
- * @param {string} oxml
- * @param {{ author?: string, allAuthors?: boolean }} [options]
- * @returns {{ oxml: string, hasChanges: boolean, rejectedCount: number, warnings: string[] }}
- */
-export function rejectTrackedChangesInOoxml(oxml, options = {}) {
-    const warnings = [];
-    const filter = resolveAuthorFilter(options);
-    if (!filter.valid) {
-        return { oxml, hasChanges: false, rejectedCount: 0, warnings: [filter.warning] };
-    }
-
-    const parseResult = parseXmlWithWarnings(oxml, 'Failed to parse OOXML');
-    if (!parseResult.xmlDoc) {
-        return {
-            oxml,
-            hasChanges: false,
-            rejectedCount: 0,
-            status: 'error',
-            error: parseResult.error,
-            warnings: [...(parseResult.warnings || []), parseResult.warning]
-        };
-    }
-
-    const { xmlDoc, serializer } = parseResult;
-    warnings.push(...(parseResult.warnings || []));
-    let rejectedCount = 0;
-
-    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;
-            continue;
-        }
-        if (removeNode(insNode)) rejectedCount += 1;
-    }
-
-    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;
-        }
-        convertDeletionTextNodes(xmlDoc, delNode);
-        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)) {
-            if (!changeNode.parentNode || !authorMatchesNode(changeNode, filter)) continue;
-            if (rejectPropertyChangeNode(changeNode, localName)) rejectedCount += 1;
-        }
-    }
-
-    coalesceAdjacentCompatibleInsertions(xmlDoc);
-
-    const serializedOxml = parseResult.isFragmentWrapped
-        ? Array.from(xmlDoc.documentElement.childNodes).map(n => serializer.serializeToString(n)).join('')
-        : serializer.serializeToString(xmlDoc);
-
-    return {
-        oxml: serializedOxml,
-        hasChanges: rejectedCount > 0,
-        rejectedCount,
-        warnings
-    };
-}
-
-function collectCommentTargetIds(xmlDoc, filter) {
-    const targetIds = new Set();
-    const commentNodes = getWordElementsByLocalName(xmlDoc, 'comment');
-
-    for (const commentNode of commentNodes) {
-        if (!authorMatchesNode(commentNode, filter)) continue;
-        const id = getAttributeByLocalName(commentNode, 'id');
-        if (id) targetIds.add(id);
-    }
-
-    return { targetIds, commentNodes };
-}
-
-function removeCommentNodesById(commentNodes, targetIds) {
-    let removed = 0;
-    for (const commentNode of commentNodes) {
-        const id = getAttributeByLocalName(commentNode, 'id');
-        if (!id || !targetIds.has(id)) continue;
-        if (removeNode(commentNode)) removed += 1;
-    }
-    return removed;
-}
-
-function runIsOnlyCommentReference(runNode) {
-    if (!isWordElement(runNode, 'r')) return false;
-    const meaningfulChildren = Array.from(runNode.childNodes || []).filter(child => {
-        if (child.nodeType === 3) return String(child.nodeValue || '').trim().length > 0;
-        if (child.nodeType !== 1) return false;
-        if (child.namespaceURI !== NS_W) return true;
-        const local = String(child.localName || '').toLowerCase();
-        return local !== 'rpr' && local !== 'commentreference';
-    });
-    return meaningfulChildren.length === 0;
-}
-
-function removeCommentAnchors(xmlDoc, targetIds) {
-    let removed = 0;
-    const anchorTags = ['commentRangeStart', 'commentRangeEnd', 'commentReference'];
-
-    for (const localName of anchorTags) {
-        for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
-            if (!node.parentNode) continue;
-            const id = getAttributeByLocalName(node, 'id');
-            if (!id || !targetIds.has(id)) continue;
-
-            if (localName === 'commentReference' && runIsOnlyCommentReference(node.parentNode)) {
-                if (removeNode(node.parentNode)) {
-                    removed += 1;
-                }
-                continue;
-            }
-            if (removeNode(node)) {
-                removed += 1;
-            }
-        }
-    }
-    return removed;
-}
-
-/**
- * Deletes comments authored by one user (or all users) and removes matching
- * comment anchors/references from the OOXML payload.
- *
- * @param {string} oxml
- * @param {{ author?: string, allAuthors?: boolean }} [options]
- * @returns {{ oxml: string, hasChanges: boolean, commentsRemoved: number, referencesRemoved: number, warnings: string[] }}
- */
-export function deleteCommentsByAuthorInOoxml(oxml, options = {}) {
-    const warnings = [];
-    const filter = resolveAuthorFilter(options);
-    if (!filter.valid) {
-        return {
-            oxml,
-            hasChanges: false,
-            commentsRemoved: 0,
-            referencesRemoved: 0,
-            warnings: [filter.warning]
-        };
-    }
-
-    const parseResult = parseXmlWithWarnings(oxml, 'Failed to parse OOXML');
-    if (!parseResult.xmlDoc) {
-        return {
-            oxml,
-            hasChanges: false,
-            commentsRemoved: 0,
-            referencesRemoved: 0,
-            status: 'error',
-            error: parseResult.error,
-            warnings: [...(parseResult.warnings || []), parseResult.warning]
-        };
-    }
-
-    const { xmlDoc, serializer } = parseResult;
-    warnings.push(...(parseResult.warnings || []));
-    const { targetIds, commentNodes } = collectCommentTargetIds(xmlDoc, filter);
-
-    if (filter.allAuthors) {
-        for (const localName of ['commentRangeStart', 'commentRangeEnd', 'commentReference']) {
-            for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
-                const id = getAttributeByLocalName(node, 'id');
-                if (id) targetIds.add(id);
-            }
-        }
-    }
-
-    const commentsRemoved = removeCommentNodesById(commentNodes, targetIds);
-    const referencesRemoved = removeCommentAnchors(xmlDoc, targetIds);
-
-    return {
-        oxml: serializer.serializeToString(xmlDoc),
-        hasChanges: commentsRemoved > 0 || referencesRemoved > 0,
-        commentsRemoved,
-        referencesRemoved,
-        warnings
-    };
-}
+/**
+ * Revision/comment management utilities for OOXML payloads.
+ */
+
+import { NS_W } from '../core/types.js';
+import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
+import { createWordElement } from '../core/word-xml.js';
+import { getXmlParseError } from '../core/xml-query.js';
+
+function getAttributeByLocalName(node, localName) {
+    if (!node || !node.attributes) return '';
+    for (const attr of Array.from(node.attributes)) {
+        if ((attr.localName || '').toLowerCase() === localName.toLowerCase()) {
+            return String(attr.value || '');
+        }
+    }
+    return String(
+        node.getAttribute?.(`w:${localName}`)
+        || node.getAttribute?.(localName)
+        || ''
+    );
+}
+
+function normalizeAuthor(author) {
+    return typeof author === 'string' ? author.trim().toLowerCase() : '';
+}
+
+function isElement(node) {
+    return !!node && node.nodeType === 1;
+}
+
+function isWordElement(node, localName) {
+    return isElement(node)
+        && node.namespaceURI === NS_W
+        && String(node.localName || '').toLowerCase() === localName.toLowerCase();
+}
+
+function getWordElementsByLocalName(xmlDoc, localName) {
+    return Array.from(xmlDoc.getElementsByTagNameNS(NS_W, localName));
+}
+
+function resolveAuthorFilter(options = {}) {
+    if (options?.allAuthors === true) {
+        return { valid: true, allAuthors: true, normalizedAuthor: '' };
+    }
+    const normalizedAuthor = normalizeAuthor(options?.author);
+    if (!normalizedAuthor) {
+        return {
+            valid: false,
+            allAuthors: false,
+            normalizedAuthor: '',
+            warning: 'No author provided. Pass { author } or set { allAuthors: true }.'
+        };
+    }
+    return { valid: true, allAuthors: false, normalizedAuthor };
+}
+
+function authorMatchesNode(node, filter) {
+    if (filter.allAuthors) return true;
+    const nodeAuthor = normalizeAuthor(getAttributeByLocalName(node, 'author'));
+    return !!nodeAuthor && nodeAuthor === filter.normalizedAuthor;
+}
+
+function parseXmlWithWarnings(oxml, parseFailurePrefix) {
+    let rawOxml = typeof oxml === 'string' ? oxml.replace(/^\uFEFF/, '').trim() : '';
+    let isFragmentWrapped = false;
+    let parsed = parseOoxmlSafe(rawOxml, 'application/xml');
+    if (parsed.error && (parsed.error.message.includes('HierarchyRequestError') || parsed.error.message.includes('Only one element'))) {
+        const wrapped = `<w:body xmlns:w="${NS_W}">${rawOxml}</w:body>`;
+        const wrappedParsed = parseOoxmlSafe(wrapped, 'application/xml');
+        if (!wrappedParsed.error) {
+            parsed = wrappedParsed;
+            isFragmentWrapped = true;
+        }
+    }
+    const parseError = parsed.doc ? getXmlParseError(parsed.doc) : null;
+    if (parsed.error || parseError) {
+        const message = parsed.error?.message || parseError?.textContent || 'parse error';
+        return {
+            xmlDoc: null,
+            serializer: null,
+            isFragmentWrapped: false,
+            warning: `${parseFailurePrefix}: ${message}`,
+            warnings: parsed.warnings,
+            error: { code: 'PARSE_ERROR', message }
+        };
+    }
+    return {
+        xmlDoc: parsed.doc,
+        serializer: createSerializer(),
+        isFragmentWrapped,
+        warning: null,
+        warnings: parsed.warnings,
+        error: null
+    };
+}
+
+function removeNode(node) {
+    if (node?.parentNode) {
+        node.parentNode.removeChild(node);
+        return true;
+    }
+    return false;
+}
+
+function unwrapNode(node) {
+    const parent = node?.parentNode;
+    if (!parent) return false;
+    while (node.firstChild) {
+        parent.insertBefore(node.firstChild, node);
+    }
+    parent.removeChild(node);
+    return true;
+}
+
+function nextElementSibling(node) {
+    let sibling = node?.nextSibling || null;
+    while (sibling && sibling.nodeType !== 1) sibling = sibling.nextSibling;
+    return sibling;
+}
+
+function revisionMetadataWithoutId(node) {
+    return Array.from(node?.attributes || [])
+        .filter(attribute => String(attribute.localName || attribute.name || '').toLowerCase() !== 'id')
+        .map(attribute => `${attribute.namespaceURI || ''}|${attribute.localName || attribute.name}=${attribute.value}`)
+        .sort()
+        .join('\n');
+}
+
+function coalesceAdjacentCompatibleInsertions(xmlDoc) {
+    let coalesced = 0;
+    const insertions = getWordElementsByLocalName(xmlDoc, 'ins');
+
+    for (const insertion of insertions) {
+        if (!insertion.parentNode || isParagraphMarkRevisionMarker(insertion)) continue;
+        let sibling = nextElementSibling(insertion);
+        while (
+            isWordElement(sibling, 'ins')
+            && normalizeAuthor(getAttributeByLocalName(sibling, 'author'))
+                === normalizeAuthor(getAttributeByLocalName(insertion, 'author'))
+            && revisionMetadataWithoutId(sibling) === revisionMetadataWithoutId(insertion)
+        ) {
+            const next = nextElementSibling(sibling);
+            while (sibling.firstChild) insertion.appendChild(sibling.firstChild);
+            sibling.parentNode?.removeChild(sibling);
+            coalesced += 1;
+            sibling = next;
+        }
+    }
+
+    return coalesced;
+}
+
+function isTableRowRevisionMarker(node) {
+    const parent = node?.parentNode;
+    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;
+}
+
+/**
+ * Resolves a paragraph whose mark is being removed. `view` is 'accept' or 'reject'.
+ * A table cell must keep its last paragraph: Word keeps it on Reject even when the
+ * cell has other paragraphs, and on Accept only when it is the cell's sole paragraph
+ * (otherwise the previous paragraph absorbs the mark). `keptCellParagraphs`
+ * collects the sole kept paragraphs so Accept can drop fully-deleted tables.
+ */
+function mergeParagraphIntoNextAndRemove(paragraph, view = 'accept', keptCellParagraphs = null) {
+    if (!paragraph?.parentNode) return false;
+    const nextParagraph = getNextWordParagraph(paragraph);
+    if (!nextParagraph) {
+        if (isWordElement(paragraph.parentNode, 'tc')) {
+            const sole = getWordElementsByLocalName(paragraph.parentNode, 'p').length <= 1;
+            if (view === 'reject' || sole) {
+                if (sole && keptCellParagraphs) keptCellParagraphs.add(paragraph);
+                return false;
+            }
+        }
+        return removeNode(paragraph);
+    }
+
+    const childrenToMove = Array.from(paragraph.childNodes || []).filter(child => !isWordElement(child, 'pPr'));
+    let insertionPoint = nextParagraph.firstChild || null;
+    if (isWordElement(insertionPoint, 'pPr')) {
+        insertionPoint = insertionPoint.nextSibling || 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.
+ *
+ * @param {string} oxml
+ * @param {{ author?: string, allAuthors?: boolean }} [options]
+ * @returns {{ oxml: string, hasChanges: boolean, acceptedCount: number, warnings: string[] }}
+ */
+export function acceptTrackedChangesInOoxml(oxml, options = {}) {
+    const warnings = [];
+    const filter = resolveAuthorFilter(options);
+    if (!filter.valid) {
+        return { oxml, hasChanges: false, acceptedCount: 0, warnings: [filter.warning] };
+    }
+
+    const parseResult = parseXmlWithWarnings(oxml, 'Failed to parse OOXML');
+    if (!parseResult.xmlDoc) {
+        return {
+            oxml,
+            hasChanges: false,
+            acceptedCount: 0,
+            status: 'error',
+            error: parseResult.error,
+            warnings: [...(parseResult.warnings || []), parseResult.warning]
+        };
+    }
+
+    const { xmlDoc, serializer } = parseResult;
+    warnings.push(...(parseResult.warnings || []));
+    let acceptedCount = 0;
+    const keptCellParagraphs = new Set();
+
+    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;
+        }
+        if (unwrapNode(insNode)) acceptedCount += 1;
+    }
+
+    for (const delNode of getWordElementsByLocalName(xmlDoc, 'del')) {
+        if (!delNode.parentNode || !authorMatchesNode(delNode, filter)) continue;
+        const paragraphMark = getContainingParagraphMarkRevision(delNode);
+        if (paragraphMark) {
+            if (mergeParagraphIntoNextAndRemove(paragraphMark, 'accept', keptCellParagraphs)) acceptedCount += 1;
+            else if (removeNode(delNode)) acceptedCount += 1;
+            continue;
+        }
+        if (isTableRowRevisionMarker(delNode)) {
+            const rowNode = delNode.parentNode?.parentNode;
+            if (removeNode(rowNode)) acceptedCount += 1;
+            continue;
+        }
+        if (removeNode(delNode)) acceptedCount += 1;
+    }
+
+    // Word removes a table outright when accepting leaves every cell with only a
+    // deleted, content-free paragraph.
+    for (const tableNode of getWordElementsByLocalName(xmlDoc, 'tbl')) {
+        if (!tableNode.parentNode) continue;
+        const cells = getWordElementsByLocalName(tableNode, 'tc');
+        const allDeleted = cells.length > 0 && cells.every(cell => {
+            const paragraphs = getWordElementsByLocalName(cell, 'p');
+            return paragraphs.length === 1 && keptCellParagraphs.has(paragraphs[0])
+                && !Array.from(paragraphs[0].childNodes || []).some(child => !isWordElement(child, 'pPr'));
+        });
+        if (allDeleted && removeNode(tableNode)) 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)) {
+            if (!changeNode.parentNode || !authorMatchesNode(changeNode, filter)) continue;
+            if (removeNode(changeNode)) acceptedCount += 1;
+        }
+    }
+
+    const serializedOxml = parseResult.isFragmentWrapped
+        ? Array.from(xmlDoc.documentElement.childNodes).map(n => serializer.serializeToString(n)).join('')
+        : serializer.serializeToString(xmlDoc);
+
+    return {
+        oxml: serializedOxml,
+        hasChanges: acceptedCount > 0,
+        acceptedCount,
+        warnings
+    };
+}
+
+function convertDeletionTextNodes(xmlDoc, delNode) {
+    for (const delTextNode of Array.from(delNode.getElementsByTagNameNS(NS_W, 'delText'))) {
+        const normalText = createWordElement(xmlDoc, 'w:t');
+        const spaceValue = delTextNode.getAttribute('xml:space');
+        if (spaceValue) {
+            normalText.setAttribute('xml:space', spaceValue);
+        }
+        while (delTextNode.firstChild) {
+            normalText.appendChild(delTextNode.firstChild);
+        }
+        delTextNode.parentNode?.replaceChild(normalText, delTextNode);
+    }
+}
+
+function rejectPropertyChangeNode(changeNode, localName) {
+    const parent = changeNode?.parentNode;
+    if (!parent) return false;
+
+    const baseLocalName = localName.endsWith('Change')
+        ? localName.slice(0, -'Change'.length)
+        : '';
+
+    if (
+        !baseLocalName
+        || String(parent.localName || '').toLowerCase() !== baseLocalName.toLowerCase()
+        || parent.namespaceURI !== NS_W
+    ) {
+        return removeNode(changeNode);
+    }
+
+    const historicalNode = Array.from(changeNode.childNodes || []).find(
+        child => child.nodeType === 1 && child.namespaceURI === NS_W
+            && String(child.localName || '').toLowerCase() === baseLocalName.toLowerCase()
+    );
+
+    if (!historicalNode) {
+        return removeNode(changeNode);
+    }
+
+    const toAppend = Array.from(historicalNode.childNodes || []);
+    // pPrChange records only paragraph properties: the paragraph-mark rPr and sectPr
+    // live in the same pPr but are not part of the recorded change, so they survive.
+    const keepNames = baseLocalName.toLowerCase() === 'ppr' ? ['rpr', 'sectpr'] : [];
+    const kept = Array.from(parent.childNodes || []).filter(child => child.nodeType === 1
+        && child.namespaceURI === NS_W && keepNames.includes(String(child.localName || '').toLowerCase()));
+    while (parent.firstChild) {
+        parent.removeChild(parent.firstChild);
+    }
+    for (const node of toAppend) {
+        const clone = xmlDocImportNode(parent.ownerDocument, node);
+        parent.appendChild(clone);
+    }
+    for (const node of kept) parent.appendChild(node);
+    return true;
+}
+
+function xmlDocImportNode(xmlDoc, node) {
+    if (xmlDoc && typeof xmlDoc.importNode === 'function') {
+        return xmlDoc.importNode(node, true);
+    }
+    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.
+ *
+ * @param {string} oxml
+ * @param {{ author?: string, allAuthors?: boolean }} [options]
+ * @returns {{ oxml: string, hasChanges: boolean, rejectedCount: number, warnings: string[] }}
+ */
+export function rejectTrackedChangesInOoxml(oxml, options = {}) {
+    const warnings = [];
+    const filter = resolveAuthorFilter(options);
+    if (!filter.valid) {
+        return { oxml, hasChanges: false, rejectedCount: 0, warnings: [filter.warning] };
+    }
+
+    const parseResult = parseXmlWithWarnings(oxml, 'Failed to parse OOXML');
+    if (!parseResult.xmlDoc) {
+        return {
+            oxml,
+            hasChanges: false,
+            rejectedCount: 0,
+            status: 'error',
+            error: parseResult.error,
+            warnings: [...(parseResult.warnings || []), parseResult.warning]
+        };
+    }
+
+    const { xmlDoc, serializer } = parseResult;
+    warnings.push(...(parseResult.warnings || []));
+    let rejectedCount = 0;
+
+    for (const insNode of getWordElementsByLocalName(xmlDoc, 'ins')) {
+        if (!insNode.parentNode || !authorMatchesNode(insNode, filter)) continue;
+        const paragraphMark = getContainingParagraphMarkRevision(insNode);
+        if (paragraphMark) {
+            if (mergeParagraphIntoNextAndRemove(paragraphMark, 'reject')) rejectedCount += 1;
+            else if (removeNode(insNode)) rejectedCount += 1;
+            continue;
+        }
+        if (isTableRowRevisionMarker(insNode)) {
+            const rowNode = insNode.parentNode?.parentNode;
+            if (removeNode(rowNode)) rejectedCount += 1;
+            continue;
+        }
+        if (removeNode(insNode)) rejectedCount += 1;
+    }
+
+    // A table whose every row was an inserted row is itself an inserted table: drop the empty shell.
+    for (const tableNode of getWordElementsByLocalName(xmlDoc, 'tbl')) {
+        if (!tableNode.parentNode) continue;
+        const hasRow = Array.from(tableNode.childNodes || []).some(child => isWordElement(child, 'tr'));
+        if (!hasRow && removeNode(tableNode)) rejectedCount += 1;
+    }
+
+    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;
+        }
+        convertDeletionTextNodes(xmlDoc, delNode);
+        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)) {
+            if (!changeNode.parentNode || !authorMatchesNode(changeNode, filter)) continue;
+            if (rejectPropertyChangeNode(changeNode, localName)) rejectedCount += 1;
+        }
+    }
+
+    coalesceAdjacentCompatibleInsertions(xmlDoc);
+
+    const serializedOxml = parseResult.isFragmentWrapped
+        ? Array.from(xmlDoc.documentElement.childNodes).map(n => serializer.serializeToString(n)).join('')
+        : serializer.serializeToString(xmlDoc);
+
+    return {
+        oxml: serializedOxml,
+        hasChanges: rejectedCount > 0,
+        rejectedCount,
+        warnings
+    };
+}
+
+function collectCommentTargetIds(xmlDoc, filter) {
+    const targetIds = new Set();
+    const commentNodes = getWordElementsByLocalName(xmlDoc, 'comment');
+
+    for (const commentNode of commentNodes) {
+        if (!authorMatchesNode(commentNode, filter)) continue;
+        const id = getAttributeByLocalName(commentNode, 'id');
+        if (id) targetIds.add(id);
+    }
+
+    return { targetIds, commentNodes };
+}
+
+function removeCommentNodesById(commentNodes, targetIds) {
+    let removed = 0;
+    for (const commentNode of commentNodes) {
+        const id = getAttributeByLocalName(commentNode, 'id');
+        if (!id || !targetIds.has(id)) continue;
+        if (removeNode(commentNode)) removed += 1;
+    }
+    return removed;
+}
+
+function runIsOnlyCommentReference(runNode) {
+    if (!isWordElement(runNode, 'r')) return false;
+    const meaningfulChildren = Array.from(runNode.childNodes || []).filter(child => {
+        if (child.nodeType === 3) return String(child.nodeValue || '').trim().length > 0;
+        if (child.nodeType !== 1) return false;
+        if (child.namespaceURI !== NS_W) return true;
+        const local = String(child.localName || '').toLowerCase();
+        return local !== 'rpr' && local !== 'commentreference';
+    });
+    return meaningfulChildren.length === 0;
+}
+
+function removeCommentAnchors(xmlDoc, targetIds) {
+    let removed = 0;
+    const anchorTags = ['commentRangeStart', 'commentRangeEnd', 'commentReference'];
+
+    for (const localName of anchorTags) {
+        for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+            if (!node.parentNode) continue;
+            const id = getAttributeByLocalName(node, 'id');
+            if (!id || !targetIds.has(id)) continue;
+
+            if (localName === 'commentReference' && runIsOnlyCommentReference(node.parentNode)) {
+                if (removeNode(node.parentNode)) {
+                    removed += 1;
+                }
+                continue;
+            }
+            if (removeNode(node)) {
+                removed += 1;
+            }
+        }
+    }
+    return removed;
+}
+
+/**
+ * Deletes comments authored by one user (or all users) and removes matching
+ * comment anchors/references from the OOXML payload.
+ *
+ * @param {string} oxml
+ * @param {{ author?: string, allAuthors?: boolean }} [options]
+ * @returns {{ oxml: string, hasChanges: boolean, commentsRemoved: number, referencesRemoved: number, warnings: string[] }}
+ */
+export function deleteCommentsByAuthorInOoxml(oxml, options = {}) {
+    const warnings = [];
+    const filter = resolveAuthorFilter(options);
+    if (!filter.valid) {
+        return {
+            oxml,
+            hasChanges: false,
+            commentsRemoved: 0,
+            referencesRemoved: 0,
+            warnings: [filter.warning]
+        };
+    }
+
+    const parseResult = parseXmlWithWarnings(oxml, 'Failed to parse OOXML');
+    if (!parseResult.xmlDoc) {
+        return {
+            oxml,
+            hasChanges: false,
+            commentsRemoved: 0,
+            referencesRemoved: 0,
+            status: 'error',
+            error: parseResult.error,
+            warnings: [...(parseResult.warnings || []), parseResult.warning]
+        };
+    }
+
+    const { xmlDoc, serializer } = parseResult;
+    warnings.push(...(parseResult.warnings || []));
+    const { targetIds, commentNodes } = collectCommentTargetIds(xmlDoc, filter);
+
+    if (filter.allAuthors) {
+        for (const localName of ['commentRangeStart', 'commentRangeEnd', 'commentReference']) {
+            for (const node of getWordElementsByLocalName(xmlDoc, localName)) {
+                const id = getAttributeByLocalName(node, 'id');
+                if (id) targetIds.add(id);
+            }
+        }
+    }
+
+    const commentsRemoved = removeCommentNodesById(commentNodes, targetIds);
+    const referencesRemoved = removeCommentAnchors(xmlDoc, targetIds);
+
+    return {
+        oxml: serializer.serializeToString(xmlDoc),
+        hasChanges: commentsRemoved > 0 || referencesRemoved > 0,
+        commentsRemoved,
+        referencesRemoved,
+        warnings
+    };
+}