@ansonlai/docx-redline-js 0.5.3 → 0.6.0

package/dist/docx-redline-js.esm.js

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.5.3 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js v0.6.0 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -2634,6 +2634,10 @@ function computeWordDiffs(originalText, newText, options = {}) {
   }
   return decodeBmpDiffs(charDiffs, wordArray);
 }
+function computeCharacterDiffs(originalText, newText, options = {}) {
+  if (originalText === newText) return [[0, originalText]];
+  return createDiffEngine(options).diff_main(originalText, newText);
+}
 function computeInsertionOnlyDiffs(originalText, newText) {
   if (originalText === newText) return [[0, originalText]];
   if (!originalText) return [[1, newText]];
@@ -4886,6 +4890,47 @@ function extractFormattingFromOoxml(xmlDoc) {
   return { existingFormatHints, textSpans, paragraphs };
 }
 
+// core/revision-cloning.js
+var REVISION_HISTORY_ELEMENTS = /* @__PURE__ */ new Set([
+  "ins",
+  "del",
+  "moveFrom",
+  "moveTo",
+  "pPrChange",
+  "rPrChange",
+  "tblPrChange",
+  "trPrChange",
+  "tcPrChange",
+  "sectPrChange"
+]);
+function clonePropertiesWithoutRevisionHistory(root) {
+  if (!root) return null;
+  const clone = root.cloneNode(true);
+  const candidates = [clone, ...Array.from(clone.getElementsByTagName?.("*") || [])];
+  for (const node of candidates.reverse()) {
+    if (!REVISION_HISTORY_ELEMENTS.has(String(node.localName || node.nodeName || "").replace(/^.*:/, ""))) continue;
+    node.parentNode?.removeChild(node);
+  }
+  return clone;
+}
+function refreshRunPropertyChangeIds(root, allocator = null) {
+  if (!root) return root;
+  const xmlDoc = root.nodeType === 9 ? root : root.ownerDocument;
+  const resolvedAllocator = allocator instanceof RevisionIdAllocator ? allocator : getRevisionIdAllocatorForDocument(xmlDoc) || createRevisionIdAllocator(xmlDoc);
+  const candidates = [root, ...Array.from(root.getElementsByTagName?.("*") || [])];
+  for (const node of candidates) {
+    if (!isWordElement(node, "rPrChange")) continue;
+    const nextId = String(resolvedAllocator.next());
+    if (typeof node.setAttributeNS === "function") {
+      node.setAttributeNS(NS_W, "w:id", nextId);
+    } else {
+      node.setAttribute("w:id", nextId);
+    }
+    resolvedAllocator._receiptCollector?.recordRevision(Number(nextId), "rPrChange");
+  }
+  return root;
+}
+
 // engine/run-builders.js
 function createTrackChange(xmlDoc, type, run, author, revisionMetadata = null) {
   const wrapper = createWordElement(xmlDoc, type === "ins" ? "w:ins" : "w:del");
@@ -5074,13 +5119,8 @@ function snapshotAndAttachRPrChange(xmlDoc, rPr, author, dateStr, sourceNode) {
   rPrChange.setAttribute("w:id", String(metadata.id));
   rPrChange.setAttribute("w:author", metadata.author);
   rPrChange.setAttribute("w:date", dateStr || metadata.date);
-  const previousRPr = createWordElement(xmlDoc, "w:rPr");
   const source = sourceNode || rPr;
-  Array.from(source.childNodes).forEach((child) => {
-    if (child.nodeName !== "w:rPrChange") {
-      previousRPr.appendChild(child.cloneNode(true));
-    }
-  });
+  const previousRPr = clonePropertiesWithoutRevisionHistory(source) || createWordElement(xmlDoc, "w:rPr");
   rPrChange.appendChild(previousRPr);
   const existing = getFirstElementByTag(rPr, "w:rPrChange");
   if (existing) {
@@ -5713,7 +5753,7 @@ function getParagraphId(paragraph) {
 
 // engine/surgical-spans.js
 function getRunChildText(child) {
-  if (isWordElement(child, "t")) return child.textContent || "";
+  if (isWordElement(child, "t") || isWordElement(child, "delText")) return child.textContent || "";
   if (isWordElement(child, "br") || isWordElement(child, "cr")) return "\n";
   if (isWordElement(child, "tab")) return "	";
   if (isWordElement(child, "noBreakHyphen")) return "\u2011";
@@ -5721,7 +5761,7 @@ function getRunChildText(child) {
   return "";
 }
 function isTextLikeRunChild(child) {
-  return isWordElement(child, "t") || isWordElement(child, "br") || isWordElement(child, "cr") || isWordElement(child, "tab") || isWordElement(child, "noBreakHyphen") || isWordElement(child, "softHyphen");
+  return isWordElement(child, "t") || isWordElement(child, "delText") || isWordElement(child, "br") || isWordElement(child, "cr") || isWordElement(child, "tab") || isWordElement(child, "noBreakHyphen") || isWordElement(child, "softHyphen");
 }
 function buildSurgicalTextSpans(paragraphs) {
   let fullText = "";
@@ -5890,26 +5930,8 @@ function describeInsertionBoundary(spanIndex, pos, fallbackParagraph = null) {
   };
 }
 
-// core/revision-cloning.js
-function refreshRunPropertyChangeIds(root, allocator = null) {
-  if (!root) return root;
-  const xmlDoc = root.nodeType === 9 ? root : root.ownerDocument;
-  const resolvedAllocator = allocator instanceof RevisionIdAllocator ? allocator : getRevisionIdAllocatorForDocument(xmlDoc) || createRevisionIdAllocator(xmlDoc);
-  const candidates = [root, ...Array.from(root.getElementsByTagName?.("*") || [])];
-  for (const node of candidates) {
-    if (!isWordElement(node, "rPrChange")) continue;
-    const nextId = String(resolvedAllocator.next());
-    if (typeof node.setAttributeNS === "function") {
-      node.setAttributeNS(NS_W, "w:id", nextId);
-    } else {
-      node.setAttribute("w:id", nextId);
-    }
-  }
-  return root;
-}
-
 // engine/surgical-run-splitting.js
-var TRACK_CHANGE_CARRIERS = /* @__PURE__ */ new Set(["ins"]);
+var TRACK_CHANGE_CARRIERS = /* @__PURE__ */ new Set(["ins", "del"]);
 function getRunContentPieces(runElement) {
   const pieces = [];
   let offset = 0;
@@ -5961,7 +5983,7 @@ function insertRunPiecesBefore(xmlDoc, parent, referenceNode, pieces, rPr) {
 function splitTrackChangeCarrier(xmlDoc, carrierElement, splitOffset, allocator = null) {
   const carrierName = getLocalName(carrierElement);
   if (!TRACK_CHANGE_CARRIERS.has(carrierName)) {
-    throw new TypeError("splitTrackChangeCarrier requires a w:ins carrier.");
+    throw new TypeError("splitTrackChangeCarrier requires a w:ins or w:del carrier.");
   }
   if (!Number.isInteger(splitOffset) || splitOffset < 0) {
     throw new RangeError("splitOffset must be a non-negative integer.");
@@ -5998,16 +6020,17 @@ function splitTrackChangeCarrier(xmlDoc, carrierElement, splitOffset, allocator
     } else {
       const localOffset = splitOffset - offset;
       const rPr = Array.from(child.childNodes || []).find((node) => isWordElement(node, "rPr")) || null;
-      const leftPieces = sliceRunPieces(xmlDoc, pieces, 0, localOffset, false);
-      const rightPieces = sliceRunPieces(xmlDoc, pieces, localOffset, runLength, false);
+      const asDeletedText = carrierName === "del";
+      const leftPieces = sliceRunPieces(xmlDoc, pieces, 0, localOffset, asDeletedText);
+      const rightPieces = sliceRunPieces(xmlDoc, pieces, localOffset, runLength, asDeletedText);
       leftCarrier.appendChild(createRunFromPieces(xmlDoc, leftPieces, rPr));
       const rightRun = createRunFromPieces(xmlDoc, rightPieces, rPr);
-      refreshRunPropertyChangeIds(rightRun, resolveAllocator(xmlDoc, allocator));
       rightCarrier.appendChild(rightRun);
     }
     offset = runEnd;
   }
   const resolvedAllocator = resolveAllocator(xmlDoc, allocator);
+  refreshRunPropertyChangeIds(rightCarrier, resolvedAllocator);
   const nextId = resolvedAllocator.next();
   setWordAttribute(rightCarrier, "id", String(nextId));
   resolvedAllocator._receiptCollector?.recordRevision(nextId, carrierName);
@@ -6027,7 +6050,7 @@ function getLocalName(element) {
   return String(element?.localName || element?.nodeName || "").replace(/^.*:/, "");
 }
 function cloneRunPiece(xmlDoc, sourceNode, text, asDeletedText) {
-  if (asDeletedText) {
+  if (asDeletedText && (isWordElement(sourceNode, "delText") || isWordElement(sourceNode, "t"))) {
     const delText = createWordElement(xmlDoc, "w:delText");
     delText.setAttribute("xml:space", "preserve");
     delText.textContent = text;
@@ -6050,6 +6073,15 @@ function cloneRunPiece(xmlDoc, sourceNode, text, asDeletedText) {
   if (text === "\u2011" && isWordElement(sourceNode, "noBreakHyphen")) {
     return sourceNode.cloneNode(true);
   }
+  if (text === "\xAD" && isWordElement(sourceNode, "softHyphen")) {
+    return sourceNode.cloneNode(true);
+  }
+  if (asDeletedText) {
+    const delText = createWordElement(xmlDoc, "w:delText");
+    delText.setAttribute("xml:space", "preserve");
+    delText.textContent = text;
+    return delText;
+  }
   const textNode = createWordElement(xmlDoc, "w:t");
   textNode.setAttribute("xml:space", "preserve");
   textNode.textContent = text;
@@ -6584,7 +6616,10 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
   const allParagraphs = targetParagraph ? [targetParagraph] : getDocumentParagraphs(xmlDoc);
   const { fullText, textSpans } = buildSurgicalTextSpans(allParagraphs);
   const insertionOnlyDiffs = options.existingRevisions === "slice-cross-author" ? computeInsertionOnlyDiffs(fullText, modifiedText) : null;
-  const diffs = insertionOnlyDiffs || computeWordDiffs(fullText, modifiedText, diffOptions);
+  const diffs = insertionOnlyDiffs || refineSpaceEquivalentReplacements(
+    computeWordDiffs(fullText, modifiedText, diffOptions),
+    diffOptions
+  );
   const spanIndex = buildSpanIndex(textSpans);
   const pairReplacements = options.pairReplacements === true;
   const warnings = [];
@@ -6622,6 +6657,82 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
       }
       if (insertResult === true) hasChanges = true;
     }
+  } else if (formatHints.length === 0) {
+    const editOperations = collectTextEditOperations(diffs);
+    for (const operation of editOperations.reverse()) {
+      const liveSpanIndex = buildSpanIndex(buildSurgicalTextSpans(allParagraphs).textSpans);
+      if (operation.type === "insert") {
+        const inserted = processInsert(
+          xmlDoc,
+          liveSpanIndex,
+          operation.start,
+          operation.text.replace(/\n/g, " "),
+          author,
+          formatHints,
+          operation.newPos,
+          generateRedlines,
+          allParagraphs[0] || null,
+          null,
+          options?.insertionAffinity || null,
+          options?.existingRevisions || "merge-same-author"
+        );
+        if (inserted && typeof inserted === "object" && inserted.error) {
+          return withOoxmlSourceType({
+            oxml: serializer.serializeToString(xmlDoc),
+            hasChanges: false,
+            status: "error",
+            error: inserted.error
+          });
+        }
+        if (inserted === true) hasChanges = true;
+        continue;
+      }
+      let delMetadata = null;
+      let insMetadata = null;
+      if (operation.type === "replace" && pairReplacements && generateRedlines && operation.text.replace(/\n/g, " ")) {
+        const checkResult = checkSafeAdjacencyForPairing(
+          liveSpanIndex,
+          operation.start,
+          operation.end,
+          options?.existingRevisions === "slice-cross-author"
+        );
+        if (checkResult.safe) {
+          const event = createReplacementRevisionEvent(author, xmlDoc);
+          delMetadata = { id: event.deletionId, author: event.author, date: event.date };
+          insMetadata = { id: event.insertionId, author: event.author, date: event.date };
+        } else if (checkResult.structuralBoundary) {
+          warnings.push("PAIRING_SKIPPED_STRUCTURAL_BOUNDARY");
+        }
+      }
+      if (processDelete(xmlDoc, liveSpanIndex, operation.start, operation.end, author, generateRedlines, delMetadata)) {
+        hasChanges = true;
+      }
+      if (operation.type === "replace") {
+        const inserted = processInsert(
+          xmlDoc,
+          liveSpanIndex,
+          operation.end,
+          operation.text.replace(/\n/g, " "),
+          author,
+          formatHints,
+          operation.newPos,
+          generateRedlines,
+          allParagraphs[0] || null,
+          insMetadata,
+          options?.insertionAffinity || null,
+          options?.existingRevisions || "merge-same-author"
+        );
+        if (inserted && typeof inserted === "object" && inserted.error) {
+          return withOoxmlSourceType({
+            oxml: serializer.serializeToString(xmlDoc),
+            hasChanges: false,
+            status: "error",
+            error: inserted.error
+          });
+        }
+        if (inserted === true) hasChanges = true;
+      }
+    }
   } else {
     for (let i = 0; i < diffs.length; i++) {
       const [op, text] = diffs[i];
@@ -6725,7 +6836,9 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
         message: "Generated OOXML accepted-view text does not match the requested modified text; the mutation was rejected.",
         mismatchOffset,
         expectedExcerpt: excerptAt(expectedText, mismatchOffset),
-        actualExcerpt: excerptAt(actualText, mismatchOffset)
+        actualExcerpt: excerptAt(actualText, mismatchOffset),
+        expectedCodePoint: codePointAtOffset(expectedText, mismatchOffset),
+        actualCodePoint: codePointAtOffset(actualText, mismatchOffset)
       },
       ...warnings.length > 0 ? { warnings: [...new Set(warnings)] } : {}
     });
@@ -6748,6 +6861,59 @@ function excerptAt(text, offset, radius = 40) {
   const end = Math.min(text.length, offset + radius);
   return text.slice(start, end);
 }
+function codePointAtOffset(text, offset) {
+  if (offset >= text.length) return "END";
+  return `U+${text.codePointAt(offset).toString(16).toUpperCase().padStart(4, "0")}`;
+}
+function refineSpaceEquivalentReplacements(diffs, diffOptions) {
+  const refined = [];
+  for (let index = 0; index < diffs.length; index++) {
+    const [op, text] = diffs[index];
+    const next = diffs[index + 1];
+    if (op === -1 && next?.[0] === 1 && text !== next[1] && text.length === next[1].length && text.replace(/\u00a0/g, " ") === next[1].replace(/\u00a0/g, " ")) {
+      refined.push(...computeCharacterDiffs(text, next[1], diffOptions));
+      index++;
+      continue;
+    }
+    refined.push([op, text]);
+  }
+  return refined;
+}
+function collectTextEditOperations(diffs) {
+  const operations = [];
+  let originalPos = 0;
+  let newPos = 0;
+  for (let index = 0; index < diffs.length; index++) {
+    const [op, text] = diffs[index];
+    if (op === 0) {
+      originalPos += text.length;
+      newPos += text.length;
+      continue;
+    }
+    if (op === -1) {
+      const next = diffs[index + 1];
+      if (next?.[0] === 1) {
+        operations.push({
+          type: "replace",
+          start: originalPos,
+          end: originalPos + text.length,
+          newPos,
+          text: next[1]
+        });
+        originalPos += text.length;
+        newPos += next[1].length;
+        index++;
+      } else {
+        operations.push({ type: "delete", start: originalPos, end: originalPos + text.length, newPos, text: "" });
+        originalPos += text.length;
+      }
+      continue;
+    }
+    operations.push({ type: "insert", start: originalPos, end: originalPos, newPos, text });
+    newPos += text.length;
+  }
+  return operations;
+}
 function collectInsertionOperations(diffs) {
   const operations = [];
   let originalPos = 0;
@@ -8266,6 +8432,51 @@ function getCommentIdsInOoxml(node) {
   }
   return [...ids].sort((a, b) => Number(a) - Number(b) || a.localeCompare(b));
 }
+function directWordChild(node, localName2) {
+  return Array.from(node?.childNodes || []).find((child) => child?.nodeType === 1 && child.namespaceURI === NS_W && child.localName === localName2) || null;
+}
+function insertedParagraphMarkMetadata(paragraph, author) {
+  const marker = directWordChild(directWordChild(directWordChild(paragraph, "pPr"), "rPr"), "ins");
+  if (!marker) return null;
+  const markerAuthor = marker.getAttribute("w:author") || marker.getAttributeNS(NS_W, "author") || "";
+  if (markerAuthor.trim().toLowerCase() !== String(author || "").trim().toLowerCase()) return null;
+  return {
+    id: marker.getAttribute("w:id") || marker.getAttributeNS(NS_W, "id") || "",
+    author: markerAuthor,
+    date: marker.getAttribute("w:date") || marker.getAttributeNS(NS_W, "date") || ""
+  };
+}
+function emptyParagraphBaseline(paragraph, serializer) {
+  const clone = paragraph.cloneNode(false);
+  const pPr = directWordChild(paragraph, "pPr");
+  if (pPr) clone.appendChild(clonePropertiesWithoutRevisionHistory(pPr));
+  return serializer.serializeToString(clone);
+}
+function restoreInsertedParagraphMark(oxml, metadata) {
+  if (!metadata || typeof oxml !== "string" || !oxml.trim()) return oxml;
+  const parsed = parseOoxmlSafe(oxml, "text/xml");
+  if (!parsed.doc || parsed.error) return oxml;
+  const paragraph = parsed.doc.documentElement?.localName === "p" ? parsed.doc.documentElement : getDocumentParagraphs(parsed.doc)[0];
+  if (!paragraph) return oxml;
+  let pPr = directWordChild(paragraph, "pPr");
+  if (!pPr) {
+    pPr = createWordElement(parsed.doc, "w:pPr");
+    paragraph.insertBefore(pPr, paragraph.firstChild);
+  }
+  let rPr = directWordChild(pPr, "rPr");
+  if (!rPr) {
+    rPr = createWordElement(parsed.doc, "w:rPr");
+    pPr.appendChild(rPr);
+  }
+  if (!directWordChild(rPr, "ins")) {
+    const marker = createWordElement(parsed.doc, "w:ins");
+    if (metadata.id) marker.setAttribute("w:id", metadata.id);
+    marker.setAttribute("w:author", metadata.author);
+    if (metadata.date) marker.setAttribute("w:date", metadata.date);
+    rPr.appendChild(marker);
+  }
+  return serializeXml(parsed.doc);
+}
 async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}) {
   const inputOoxml = oxml;
   let workingOoxml = oxml;
@@ -8277,6 +8488,7 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   let parseWarnings = [];
   const operationWarnings = [];
   let normalizedExistingRevisions = false;
+  let preservedInsertedParagraphMark = null;
   const existingRevisionsPolicy = options.existingRevisions || "merge-same-author";
   const keepNormalizedNoOp = existingRevisionsPolicy === "accept-all-first-keep-normalized";
   const finalize = (result) => {
@@ -8307,6 +8519,9 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
     if (!withStatus.status) {
       withStatus.status = withStatus.hasChanges ? "ok" : "no-op";
     }
+    if (preservedInsertedParagraphMark && withStatus.hasChanges && typeof withStatus.oxml === "string") {
+      withStatus.oxml = restoreInsertedParagraphMark(withStatus.oxml, preservedInsertedParagraphMark);
+    }
     return withOoxmlSourceType(withStatus);
   };
   const finalizeUnchanged = () => {
@@ -8372,9 +8587,11 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
           });
         }
         log("[OxmlEngine] Existing revisions from same author detected; rejecting previous changes to merge against baseline");
+        const soleParagraph = inputParagraphs.length === 1 ? inputParagraphs[0] : null;
+        preservedInsertedParagraphMark = insertedParagraphMarkMetadata(soleParagraph, author);
         const rejected = rejectTrackedChangesInOoxml(inputOoxml, { author });
         if (rejected.status === "error") return finalize(rejected);
-        workingOoxml = rejected.oxml;
+        workingOoxml = preservedInsertedParagraphMark && !String(rejected.oxml || "").trim() ? emptyParagraphBaseline(soleParagraph, serializer) : rejected.oxml;
         normalizedExistingRevisions = true;
         const rejectedParsed = parseOoxmlSafe(workingOoxml, "text/xml");
         parseWarnings.push(...rejectedParsed.warnings);
@@ -8416,7 +8633,9 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
           status: "error",
           error: {
             code: "EXISTING_REVISIONS",
-            message: `Input OOXML contains tracked changes from another author (${authors.length ? authors.join(", ") : "unattributed"}). Pass existingRevisions: "accept-all-first" or resolve revisions first.`
+            message: `Input OOXML contains tracked changes from another author (${authors.length ? authors.join(", ") : "unattributed"}). Use existingRevisions: "slice-cross-author" for a surgical edit that preserves reviewer history; accepting or rejecting revisions requires separate authorization.`,
+            revisionAuthors: authors,
+            currentPolicy: existingRevisionsPolicy
           }
         });
       } else {
@@ -9024,9 +9243,12 @@ function resolveTargetParagraph(xmlDoc, options = {}) {
       );
     }
     if (descriptor.fingerprint && descriptor.fingerprint !== actualFingerprint) {
+      const alternateView = revisionView === "rejected" ? "accepted" : "rejected";
+      const alternateFingerprint = createParagraphFingerprint(byId, { revisionView: alternateView });
+      const viewHint = descriptor.fingerprint === alternateFingerprint ? ` The supplied fingerprint matches the ${alternateView} view; set target.revisionView to "${alternateView}" or use a fingerprint extracted from the ${revisionView} view.` : "";
       throw createTargetError(
         "TARGET_FINGERPRINT_MISMATCH",
-        `Target paragraphId "${descriptor.paragraphId}" no longer matches its source fingerprint.`,
+        `Target paragraphId "${descriptor.paragraphId}" no longer matches its source fingerprint.${viewHint}`,
         cachedEntry ? [serializeTargetCandidate(cachedEntry)] : null
       );
     }
@@ -9038,9 +9260,14 @@ function resolveTargetParagraph(xmlDoc, options = {}) {
       );
     }
     if (cleanTargetText && actualText !== normalizeWhitespaceForTargeting(cleanTargetText)) {
+      const alternateView = revisionView === "rejected" ? "accepted" : "rejected";
+      const alternateText = normalizeWhitespaceForTargeting(
+        extractCanonicalParagraphText(byId, { revisionView: alternateView })
+      );
+      const viewHint = alternateText === normalizeWhitespaceForTargeting(cleanTargetText) ? ` The supplied text matches the ${alternateView} view; set target.revisionView to "${alternateView}".` : "";
       throw createTargetError(
         "TARGET_TEXT_MISMATCH",
-        `Target paragraphId "${descriptor.paragraphId}" no longer matches the supplied text.`,
+        `Target paragraphId "${descriptor.paragraphId}" no longer matches the supplied text.${viewHint}`,
         cachedEntry ? [serializeTargetCandidate(cachedEntry)] : null
       );
     }
@@ -10140,11 +10367,12 @@ function parseOoxmlForValidation(oxml) {
 function validateRedlineOoxml(oxml) {
   const issues = [];
   const addIssue = (code, severity, message) => issues.push({ code, severity, message });
-  if (typeof oxml !== "string" || oxml.trim() === "") {
-    addIssue("PARSE_ERROR", "error", "Input is not a non-empty OOXML string.");
+  const isDomNode = oxml && typeof oxml === "object" && (oxml.nodeType === 9 || oxml.nodeType === 1);
+  if (!isDomNode && (typeof oxml !== "string" || oxml.trim() === "")) {
+    addIssue("PARSE_ERROR", "error", "Input is not non-empty OOXML or a parsed XML DOM.");
     return { valid: false, issues };
   }
-  const { doc, error: error2 } = parseOoxmlForValidation(oxml);
+  const { doc, error: error2 } = isDomNode ? { doc: oxml.nodeType === 9 ? oxml : oxml.ownerDocument } : parseOoxmlForValidation(oxml);
   if (!doc) {
     addIssue("PARSE_ERROR", "error", `OOXML does not parse as XML: ${error2}`);
     return { valid: false, issues };
@@ -11253,9 +11481,10 @@ function inspectDocumentParts(parts, options = {}) {
   const resolveNumbering = createNumberingResolver(numberingPart.doc);
   let nearestHeading = null;
   const paragraphNodes = getDocumentParagraphNodes(documentPart.doc);
-  const commentAnchors = collectDocumentCommentAnchors(paragraphNodes, options.revisionView || "accepted");
+  const revisionView = options.revisionView === "rejected" ? "rejected" : "accepted";
+  const commentAnchors = collectDocumentCommentAnchors(paragraphNodes, revisionView);
   let paragraphs = paragraphNodes.map((paragraph, zeroIndex) => {
-    const text = extractCanonicalParagraphText(paragraph, { revisionView: options.revisionView || "accepted" });
+    const text = extractCanonicalParagraphText(paragraph, { revisionView });
     const level = headingLevel(paragraph);
     if (level) nearestHeading = { level, text };
     const ids = [...new Set([...descendants(paragraph, "commentRangeStart"), ...descendants(paragraph, "commentReference")].map((node) => attr2(node, "id")).filter(Boolean))];
@@ -11272,7 +11501,8 @@ function inspectDocumentParts(parts, options = {}) {
       index,
       ref: `P${index}`,
       paragraphId: getParagraphId2(paragraph),
-      fingerprint: createParagraphFingerprint(paragraph),
+      fingerprint: createParagraphFingerprint(paragraph, { text, index, revisionView }),
+      revisionView,
       text,
       exactText: text,
       excerpt: text.slice(0, options.excerptLength || 120),