@ansonlai/docx-redline-js 0.2.1 → 0.4.0

package/scripts/word-com-visual-suite.ps1

@@ -0,0 +1,132 @@
+param(
+    [string]$FixturesDir = "tmp/word-visual-review/fixtures",
+    [string]$OutputDir = "tmp/word-visual-review/rendered",
+    [string[]]$Case = @()
+)
+
+# Produces repeatable visual evidence from desktop Microsoft Word. This lane
+# intentionally records "rendered", never "pass": a person or AI reviewer must
+# still inspect the PDFs before certifying visual correctness.
+$ErrorActionPreference = 'Stop'
+$repoRoot = Split-Path -Parent $PSScriptRoot
+$fixturesPath = [System.IO.Path]::GetFullPath((Join-Path $repoRoot $FixturesDir))
+$outputPath = [System.IO.Path]::GetFullPath((Join-Path $repoRoot $OutputDir))
+$manifestPath = Join-Path $outputPath 'manifest.json'
+
+New-Item -ItemType Directory -Force -Path $fixturesPath, $outputPath | Out-Null
+
+Push-Location $repoRoot
+try {
+    & node (Join-Path $PSScriptRoot 'export-validation-fixtures.mjs') --output-dir $fixturesPath
+    if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+
+    $prepareArgs = @((Join-Path $PSScriptRoot 'prepare-word-visual-review.mjs'), "--output=$manifestPath")
+    foreach ($caseName in $Case) { $prepareArgs += "--case=$caseName" }
+    & node @prepareArgs
+    if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+}
+finally {
+    Pop-Location
+}
+
+$manifest = Get-Content -LiteralPath $manifestPath -Raw -Encoding UTF8 | ConvertFrom-Json
+$word = $null
+$rpcDisconnected = -2147417848 # 0x80010108 RPC_E_DISCONNECTED
+
+function Test-RpcDisconnected($exception) {
+    return $exception -is [Runtime.InteropServices.COMException] -and $exception.HResult -eq $rpcDisconnected
+}
+
+function Start-WordApplication {
+    $application = New-Object -ComObject Word.Application
+    $application.Visible = $false
+    $application.DisplayAlerts = 0
+    return $application
+}
+
+function Stop-WordApplicationSafely($application) {
+    if ($null -eq $application) { return }
+    try { $application.Quit() | Out-Null }
+    catch {
+        if (-not (Test-RpcDisconnected $_.Exception)) { throw }
+        Write-Warning 'Word disconnected while quitting; the COM process was already gone.'
+    }
+}
+
+function Close-WordDocumentSafely($document) {
+    if ($null -eq $document) { return }
+    try { $document.Close(0) | Out-Null }
+    catch {
+        if (-not (Test-RpcDisconnected $_.Exception)) { throw }
+        Write-Warning 'Word disconnected after export while closing the document.'
+    }
+}
+
+function Export-View($word, [string]$docxPath, [string]$pdfPath, [string]$viewName) {
+    $document = $null
+    try {
+        $document = $word.Documents.OpenNoRepairDialog($docxPath)
+        if ($viewName -eq 'acceptAll') {
+            $document.AcceptAllRevisions()
+            $exportItem = 0 # wdExportDocumentContent
+        }
+        elseif ($viewName -eq 'rejectAll') {
+            $document.RejectAllRevisions()
+            $exportItem = 0
+        }
+        else {
+            $document.ShowRevisions = $true
+            $document.PrintRevisions = $true
+            $exportItem = 7 # wdExportDocumentWithMarkup
+        }
+
+        $pages = $document.ComputeStatistics(2) # wdStatisticPages
+        $document.ExportAsFixedFormat($pdfPath, 17, $false, 0, 0, 1, 1, $exportItem, $true, $true, 0, $true, $true, $false)
+        $pdf = Get-Item -LiteralPath $pdfPath -ErrorAction Stop
+        if ($pdf.Length -lt 1000) { throw "Word produced an unexpectedly small PDF ($($pdf.Length) bytes)" }
+        if ($pages -lt 1) { throw "Word reported no rendered pages" }
+        return @{ pages = [int]$pages; bytes = [long]$pdf.Length }
+    }
+    finally {
+        Close-WordDocumentSafely $document
+    }
+}
+
+try {
+    $word = Start-WordApplication
+    $manifest.word.version = [string]$word.Version
+    try { $manifest.word.build = [string]$word.Build } catch { $manifest.word.build = $null }
+
+    foreach ($entry in $manifest.cases) {
+        $docxPath = Join-Path $fixturesPath "$($entry.name).docx"
+        if (-not (Test-Path -LiteralPath $docxPath)) { throw "Missing fixture: $docxPath" }
+        foreach ($viewProperty in $entry.views.PSObject.Properties) {
+            $pdfPath = Join-Path $outputPath ([string]$viewProperty.Value.pdf)
+            $render = $null
+            for ($attempt = 1; $attempt -le 2; $attempt++) {
+                try {
+                    $render = Export-View $word $docxPath $pdfPath ([string]$viewProperty.Name)
+                    break
+                }
+                catch {
+                    if (-not (Test-RpcDisconnected $_.Exception) -or $attempt -eq 2) { throw }
+                    Write-Warning "Word disconnected while rendering $($entry.name) $($viewProperty.Name); restarting and retrying once."
+                    Stop-WordApplicationSafely $word
+                    $word = Start-WordApplication
+                }
+            }
+            $viewProperty.Value.status = 'rendered'
+            $viewProperty.Value.pages = $render.pages
+            $viewProperty.Value.bytes = $render.bytes
+        }
+        $entry.renderStatus = 'rendered'
+        Write-Output "RENDERED $($entry.name) (markup, accept-all, reject-all)"
+    }
+}
+finally {
+    Stop-WordApplicationSafely $word
+    $manifest | ConvertTo-Json -Depth 12 | Set-Content -LiteralPath $manifestPath -Encoding UTF8
+}
+
+Write-Output "Visual evidence: $($manifest.cases.Count) cases, $($manifest.cases.Count * 3) PDFs."
+Write-Output "Manifest: $manifestPath"

package/services/comment-engine.js

@@ -5,7 +5,7 @@
  */
 
 import { NS_W, getNextRevisionId, getRevisionTimestamp, resetRevisionIdCounter } from '../core/types.js';
-import { createParser, createSerializer } from '../adapters/xml-adapter.js';
+import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { log, error as logError } from '../adapters/logger.js';
 import { getElementsByTag, getFirstElementByTag, getXmlParseError } from '../core/xml-query.js';
 import { buildCommentElement, buildCommentsPartXml, buildCommentMarkers } from './comment-builders.js';
@@ -35,17 +35,19 @@ export { buildCommentElement, buildCommentsPartXml, buildCommentMarkers };
  * @property {string[]} warnings - Any issues encountered
  */
 
-function parseDocumentOxml(oxml, parser, parseFailureWarning) {
-    try {
-        const xmlDoc = parser.parseFromString(oxml, 'text/xml');
-        const parseError = getXmlParseError(xmlDoc);
-        if (parseError) {
-            return { xmlDoc: null, warning: parseFailureWarning(parseError.textContent || 'parse error') };
-        }
-        return { xmlDoc, warning: null };
-    } catch (error) {
-        return { xmlDoc: null, warning: parseFailureWarning(error.message) };
-    }
+function parseDocumentOxml(oxml, parseFailureWarning) {
+    const parsed = parseOoxmlSafe(oxml, 'text/xml');
+    const parseError = parsed.doc ? getXmlParseError(parsed.doc) : null;
+    if (parsed.error || parseError) {
+        const message = parsed.error?.message || parseError?.textContent || 'parse error';
+        return {
+            xmlDoc: null,
+            warning: parseFailureWarning(message),
+            warnings: parsed.warnings,
+            error: { code: 'PARSE_ERROR', message }
+        };
+    }
+    return { xmlDoc: parsed.doc, warning: null, warnings: parsed.warnings, error: null };
 }
 
 /**
@@ -60,32 +62,35 @@ function parseDocumentOxml(oxml, parser, parseFailureWarning) {
 export function injectCommentsIntoOoxml(oxml, comments, options = {}) {
     const author = options?.author || getDefaultAuthor();
     const date = getRevisionTimestamp();
-    const warnings = [];
+    const warnings = [];
     const placedComments = [];
 
     if (!comments || comments.length === 0) {
-        return {
-            oxml,
-            commentsApplied: 0,
-            warnings: ['No comments to inject']
-        };
-    }
-
-    const parser = createParser();
-    const serializer = createSerializer();
-    const parseResult = parseDocumentOxml(
-        oxml,
-        parser,
-        warning => `Failed to parse OXML: ${warning}`
-    );
+        return {
+            oxml,
+            hasChanges: false,
+            commentsApplied: 0,
+            warnings: ['No comments to inject']
+        };
+    }
+
+    const serializer = createSerializer();
+    const parseResult = parseDocumentOxml(
+        oxml,
+        warning => `Failed to parse OXML: ${warning}`
+    );
+    warnings.push(...(parseResult.warnings || []));
 
     if (!parseResult.xmlDoc) {
         logError('[CommentEngine] Parse failure:', parseResult.warning);
-        return {
-            oxml,
-            commentsApplied: 0,
-            warnings: [parseResult.warning]
-        };
+        return {
+            oxml,
+            hasChanges: false,
+            commentsApplied: 0,
+            status: 'error',
+            error: parseResult.error,
+            warnings: [...warnings, parseResult.warning]
+        };
     }
 
     const xmlDoc = parseResult.xmlDoc;
@@ -155,16 +160,18 @@ export function injectCommentsIntoOoxml(oxml, comments, options = {}) {
     }
 
     if (placedComments.length === 0) {
-        return {
-            oxml,
-            commentsApplied: 0,
-            warnings
-        };
+        return {
+            oxml,
+            hasChanges: false,
+            commentsApplied: 0,
+            warnings
+        };
     }
 
-    return {
-        oxml: serializer.serializeToString(xmlDoc),
-        commentsXml: buildCommentsPartXml(placedComments),
+    return {
+        oxml: serializer.serializeToString(xmlDoc),
+        hasChanges: true,
+        commentsXml: buildCommentsPartXml(placedComments),
         commentsApplied: placedComments.length,
         warnings
     };
@@ -185,12 +192,10 @@ export function injectCommentIntoParagraphOoxml(paragraphOoxml, textToFind, comm
     const date = getRevisionTimestamp();
     const commentId = getNextRevisionId();
 
-    const parser = createParser();
-    const serializer = createSerializer();
-    const parseResult = parseDocumentOxml(
-        paragraphOoxml,
-        parser,
-        warning => `Failed to parse paragraph OOXML: ${warning}`
+    const serializer = createSerializer();
+    const parseResult = parseDocumentOxml(
+        paragraphOoxml,
+        warning => `Failed to parse paragraph OOXML: ${warning}`
     );
 
     if (!parseResult.xmlDoc) {

package/services/comment-locator.js

@@ -2,7 +2,6 @@
  * Comment text location and marker injection helpers.
  */
 
-import { NS_W } from '../core/types.js';
 import { createWordElement } from '../core/word-xml.js';
 import { getElementsByTag, getFirstElementByTag } from '../core/xml-query.js';
 

package/services/comment-package.js

@@ -2,7 +2,7 @@
  * Comment package builders and pkg:part wiring.
  */
 
-import { createParser, createSerializer } from '../adapters/xml-adapter.js';
+import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { error as logError } from '../adapters/logger.js';
 import { buildDocumentCommentsPackage, buildParagraphCommentsPackage } from './package-builder.js';
 import { getElementsByTagNS, getXmlParseError } from '../core/xml-query.js';
@@ -29,14 +29,14 @@ export function wrapParagraphWithComments(paragraphXml, commentsXml) {
  * @returns {string}
  */
 export function injectCommentsIntoPackage(packageOxml, commentsXml) {
-    const parser = createParser();
-    const serializer = createSerializer();
-    const pkgDoc = parser.parseFromString(packageOxml, 'text/xml');
-
-    const parseError = getXmlParseError(pkgDoc);
-    if (parseError) {
-        logError('[CommentEngine] Failed to parse package:', parseError.textContent);
-        return packageOxml;
+    const serializer = createSerializer();
+    const packageParsed = parseOoxmlSafe(packageOxml, 'text/xml');
+    const pkgDoc = packageParsed.doc;
+
+    const parseError = pkgDoc ? getXmlParseError(pkgDoc) : null;
+    if (packageParsed.error || parseError) {
+        logError('[CommentEngine] Failed to parse package:', packageParsed.error?.message || parseError?.textContent);
+        return packageOxml;
     }
 
     const pkgPackage = pkgDoc.documentElement;
@@ -46,7 +46,8 @@ export function injectCommentsIntoPackage(packageOxml, commentsXml) {
     commentsPart.setAttribute('pkg:contentType', 'application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml');
 
     const commentsXmlData = pkgDoc.createElementNS(PKG_NS, 'pkg:xmlData');
-    const commentsDoc = parser.parseFromString(commentsXml, 'text/xml');
+    const commentsDoc = parseOoxmlSafe(commentsXml, 'text/xml').doc;
+    if (!commentsDoc) return packageOxml;
     commentsXmlData.appendChild(pkgDoc.importNode(commentsDoc.documentElement, true));
     commentsPart.appendChild(commentsXmlData);
     pkgPackage.appendChild(commentsPart);

package/services/numbering-service.js

@@ -4,7 +4,7 @@
  * Manages list numbering to ensure continuation and consistent formatting.
  */
 
-import { NS_W, NumberFormat, NumberSuffix } from '../core/types.js';
+import { NumberFormat, NumberSuffix } from '../core/types.js';
 
 export class NumberingService {
     constructor() {

package/services/revision-comment-management.js

@@ -3,7 +3,7 @@
  */
 
 import { NS_W } from '../core/types.js';
-import { createParser, createSerializer } from '../adapters/xml-adapter.js';
+import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
 import { createWordElement } from '../core/word-xml.js';
 import { getXmlParseError } from '../core/xml-query.js';
 
@@ -62,17 +62,19 @@ function authorMatchesNode(node, filter) {
 }
 
 function parseXmlWithWarnings(oxml, parseFailurePrefix) {
-    const parser = createParser();
-    const xmlDoc = parser.parseFromString(oxml, 'application/xml');
-    const parseError = getXmlParseError(xmlDoc);
-    if (parseError) {
+    const parsed = parseOoxmlSafe(oxml, 'application/xml');
+    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,
-            warning: `${parseFailurePrefix}: ${parseError.textContent || 'parse error'}`
+            warning: `${parseFailurePrefix}: ${message}`,
+            warnings: parsed.warnings,
+            error: { code: 'PARSE_ERROR', message }
         };
     }
-    return { xmlDoc, serializer: createSerializer(), warning: null };
+    return { xmlDoc: parsed.doc, serializer: createSerializer(), warning: null, warnings: parsed.warnings, error: null };
 }
 
 function removeNode(node) {
@@ -150,10 +152,18 @@ export function acceptTrackedChangesInOoxml(oxml, options = {}) {
 
     const parseResult = parseXmlWithWarnings(oxml, 'Failed to parse OOXML');
     if (!parseResult.xmlDoc) {
-        return { oxml, hasChanges: false, acceptedCount: 0, warnings: [parseResult.warning] };
+        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')) {
@@ -321,10 +331,18 @@ export function rejectTrackedChangesInOoxml(oxml, options = {}) {
 
     const parseResult = parseXmlWithWarnings(oxml, 'Failed to parse OOXML');
     if (!parseResult.xmlDoc) {
-        return { oxml, hasChanges: false, rejectedCount: 0, warnings: [parseResult.warning] };
+        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')) {
@@ -472,11 +490,14 @@ export function deleteCommentsByAuthorInOoxml(oxml, options = {}) {
             hasChanges: false,
             commentsRemoved: 0,
             referencesRemoved: 0,
-            warnings: [parseResult.warning]
+            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) {

package/services/standalone-docx-plumbing.js

@@ -2,7 +2,7 @@
  * Standalone OOXML/Docx plumbing helpers shared by browser and Node hosts.
  */
 
-import { createParser, createSerializer } from '../adapters/xml-adapter.js';
+import { createSerializer, parseOoxmlSafe } from '../adapters/xml-adapter.js';
 
 const NS_W = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const NS_CT = 'http://schemas.openxmlformats.org/package/2006/content-types';
@@ -19,13 +19,13 @@ const CONTENT_TYPES_PATH = '[Content_Types].xml';
 const DOCUMENT_RELS_PATH = 'word/_rels/document.xml.rels';
 
 export function parseXmlStrictStandalone(xmlText, label = 'xml') {
-    const parser = createParser();
-    const xmlDoc = parser.parseFromString(xmlText, 'application/xml');
-    const parseError = xmlDoc.getElementsByTagName('parsererror')[0];
-    if (parseError) {
-        throw new Error(`[XML parse error] ${label}: ${parseError.textContent || 'Unknown'}`);
+    const parsed = parseOoxmlSafe(xmlText, 'application/xml');
+    if (parsed.error || !parsed.doc) {
+        const error = new Error(`[XML parse error] ${label}: ${parsed.error?.message || 'Unknown'}`);
+        error.code = 'PARSE_ERROR';
+        throw error;
     }
-    return xmlDoc;
+    return parsed.doc;
 }
 
 function isSectionPropertiesElement(node) {
@@ -104,9 +104,8 @@ export function getPackagePartName(partElement) {
 }
 
 function extractFromPackageXml(packageXml) {
-    const parser = createParser();
     const serializer = createSerializer();
-    const pkgDoc = parser.parseFromString(packageXml, 'application/xml');
+    const pkgDoc = parseXmlStrictStandalone(packageXml, 'package OOXML');
     const parts = Array.from(pkgDoc.getElementsByTagNameNS('*', 'part'));
     const documentPart = parts.find(part => getPackagePartName(part) === '/word/document.xml');
     if (!documentPart) {
@@ -154,28 +153,42 @@ function extractFromPackageXml(packageXml) {
  */
 export function extractReplacementNodesFromOoxml(outputOxml) {
     if (typeof outputOxml !== 'string' || !outputOxml.trim()) {
-        throw new Error('Reconciliation engine returned no OOXML payload for this operation');
-    }
+        return {
+            replacementNodes: [],
+            numberingXml: null,
+            sourceType: 'fragment',
+            status: 'error',
+            error: { code: 'PARSE_ERROR', message: 'Reconciliation engine returned no OOXML payload for this operation' }
+        };
+    }
+
+    try {
+        if (outputOxml.includes('<pkg:package')) {
+            return extractFromPackageXml(outputOxml);
+        }
 
-    if (outputOxml.includes('<pkg:package')) {
-        return extractFromPackageXml(outputOxml);
-    }
+        if (outputOxml.includes('<w:document')) {
+            const doc = parseXmlStrictStandalone(outputOxml, 'document OOXML');
+            const body = doc.getElementsByTagNameNS('*', 'body')[0];
+            const replacementNodes = body
+                ? Array.from(body.childNodes || []).filter(node => node.nodeType === 1 && !isSectionPropertiesElement(node))
+                : Array.from(doc.childNodes || []).filter(node => node.nodeType === 1);
+            return { replacementNodes, numberingXml: null, sourceType: 'document' };
+        }
 
-    if (outputOxml.includes('<w:document')) {
-        const parser = createParser();
-        const doc = parser.parseFromString(outputOxml, 'application/xml');
-        const body = doc.getElementsByTagNameNS('*', 'body')[0];
-        const replacementNodes = body
-            ? Array.from(body.childNodes || []).filter(node => node.nodeType === 1 && !isSectionPropertiesElement(node))
-            : Array.from(doc.childNodes || []).filter(node => node.nodeType === 1);
-        return { replacementNodes, numberingXml: null, sourceType: 'document' };
+        const wrapped = `<root xmlns:w="${NS_W}">${outputOxml}</root>`;
+        const fragmentDoc = parseXmlStrictStandalone(wrapped, 'OOXML fragment');
+        const replacementNodes = Array.from(fragmentDoc.documentElement.childNodes || []).filter(node => node.nodeType === 1);
+        return { replacementNodes, numberingXml: null, sourceType: 'fragment' };
+    } catch (caught) {
+        return {
+            replacementNodes: [],
+            numberingXml: null,
+            sourceType: 'fragment',
+            status: 'error',
+            error: { code: 'PARSE_ERROR', message: caught?.message || 'Could not parse OOXML payload.' }
+        };
     }
-
-    const wrapped = `<root xmlns:w="${NS_W}">${outputOxml}</root>`;
-    const parser = createParser();
-    const fragmentDoc = parser.parseFromString(wrapped, 'application/xml');
-    const replacementNodes = Array.from(fragmentDoc.documentElement.childNodes || []).filter(node => node.nodeType === 1);
-    return { replacementNodes, numberingXml: null, sourceType: 'fragment' };
 }
 
 function upsertContentTypeOverride(ctDoc, partName, contentType) {
@@ -258,12 +271,11 @@ export async function ensureNumberingArtifactsInZip(zip, numberingXmlList, optio
     }
     zip.file(NUMBERING_PATH, mergedNumberingXml);
 
-    const parser = createParser();
     const serializer = createSerializer();
 
     const ctText = await readZipText(zip, CONTENT_TYPES_PATH);
     if (ctText) {
-        const ctDoc = parser.parseFromString(ctText, 'application/xml');
+        const ctDoc = parseXmlStrictStandalone(ctText, CONTENT_TYPES_PATH);
         if (upsertContentTypeOverride(ctDoc, '/word/numbering.xml', NUMBERING_CONTENT_TYPE)) {
             zip.file(CONTENT_TYPES_PATH, serializer.serializeToString(ctDoc));
         }
@@ -271,7 +283,7 @@ export async function ensureNumberingArtifactsInZip(zip, numberingXmlList, optio
 
     const relsText = await readZipText(zip, DOCUMENT_RELS_PATH);
     if (relsText) {
-        const relsDoc = parser.parseFromString(relsText, 'application/xml');
+        const relsDoc = parseXmlStrictStandalone(relsText, DOCUMENT_RELS_PATH);
         if (upsertDocumentRelationship(relsDoc, NUMBERING_REL_TYPE, 'numbering.xml')) {
             zip.file(DOCUMENT_RELS_PATH, serializer.serializeToString(relsDoc));
         }
@@ -289,7 +301,6 @@ export async function ensureCommentsArtifactsInZip(zip, commentsXml, options = {
     const onInfo = typeof options?.onInfo === 'function' ? options.onInfo : () => {};
     if (!commentsXml) return;
 
-    const parser = createParser();
     const serializer = createSerializer();
     const existingText = await readZipText(zip, COMMENTS_PATH);
     if (!existingText) {
@@ -316,7 +327,7 @@ export async function ensureCommentsArtifactsInZip(zip, commentsXml, options = {
 
     const ctText = await readZipText(zip, CONTENT_TYPES_PATH);
     if (ctText) {
-        const ctDoc = parser.parseFromString(ctText, 'application/xml');
+        const ctDoc = parseXmlStrictStandalone(ctText, CONTENT_TYPES_PATH);
         if (upsertContentTypeOverride(ctDoc, '/word/comments.xml', COMMENTS_CONTENT_TYPE)) {
             zip.file(CONTENT_TYPES_PATH, serializer.serializeToString(ctDoc));
         }
@@ -324,7 +335,7 @@ export async function ensureCommentsArtifactsInZip(zip, commentsXml, options = {
 
     const relsText = await readZipText(zip, DOCUMENT_RELS_PATH);
     if (relsText) {
-        const relsDoc = parser.parseFromString(relsText, 'application/xml');
+        const relsDoc = parseXmlStrictStandalone(relsText, DOCUMENT_RELS_PATH);
         if (upsertDocumentRelationship(relsDoc, COMMENTS_REL_TYPE, 'comments.xml')) {
             zip.file(DOCUMENT_RELS_PATH, serializer.serializeToString(relsDoc));
         }