@ansonlai/docx-redline-js 0.5.2 → 0.5.4

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

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.5.2 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js v0.5.4 — 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]];
@@ -5713,7 +5717,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 +5725,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 = "";
@@ -5904,12 +5908,13 @@ function refreshRunPropertyChangeIds(root, allocator = null) {
     } else {
       node.setAttribute("w:id", nextId);
     }
+    resolvedAllocator._receiptCollector?.recordRevision(Number(nextId), "rPrChange");
   }
   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 +5966,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 +6003,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 +6033,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 +6056,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;
@@ -6160,7 +6175,15 @@ function processDelete(xmlDoc, spanIndex, startPos, endPos, author, generateRedl
       if (delWrapper && record.deletedPieces.length > 0) {
         delWrapper.appendChild(createRunFromPieces(xmlDoc, record.deletedPieces, record.rPr));
       }
-      insertRunPiecesBefore(xmlDoc, parent, runElement, record.afterPieces, record.rPr);
+      const afterRun = insertRunPiecesBefore(xmlDoc, parent, runElement, record.afterPieces, record.rPr);
+      if (record.globalEnd === endPos && !isWordElement(parent, "ins")) {
+        if (!spanIndex.replacementInsertionAnchors) spanIndex.replacementInsertionAnchors = /* @__PURE__ */ new Map();
+        spanIndex.replacementInsertionAnchors.set(endPos, {
+          parent,
+          referenceNode: afterRun || runElement.nextSibling,
+          rPr: record.rPr
+        });
+      }
       parent.removeChild(runElement);
       changed = true;
     }
@@ -6197,6 +6220,23 @@ function processInsert(xmlDoc, spanIndex, pos, text, author, formatHints = [], i
       revisionMetadata
     );
   }
+  const replacementAnchor = spanIndex.replacementInsertionAnchors?.get(pos) || null;
+  if (replacementAnchor && !affinity && isConnected(replacementAnchor.parent) && (!replacementAnchor.referenceNode || replacementAnchor.referenceNode.parentNode === replacementAnchor.parent)) {
+    spanIndex.replacementInsertionAnchors.delete(pos);
+    insertTextRuns(
+      xmlDoc,
+      replacementAnchor.parent,
+      replacementAnchor.referenceNode,
+      text,
+      replacementAnchor.rPr,
+      author,
+      formatHints,
+      insertOffset,
+      generateRedlines,
+      revisionMetadata
+    );
+    return true;
+  }
   if (!affinity) {
     let targetSpan = findContainingSpan(spanIndex, pos);
     if (!targetSpan && pos > 0) {
@@ -6559,68 +6599,197 @@ 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 = [];
   let originalPos = 0;
   let newPos = 0;
   let hasChanges = false;
-  for (let i = 0; i < diffs.length; i++) {
-    const [op, text] = diffs[i];
-    if (op === 0) {
-      const len = text.length;
-      const startPos = originalPos;
-      const endPos = originalPos + len;
-      forEachOverlappingSpan(spanIndex, startPos, endPos, (span) => {
-        const overlapStartOriginal = Math.max(span.charStart, startPos);
-        const overlapEndOriginal = Math.min(span.charEnd, endPos);
-        const segmentLen = overlapEndOriginal - overlapStartOriginal;
-        const relativeOffset = overlapStartOriginal - startPos;
-        const overlapStartNew = newPos + relativeOffset;
-        const overlapEndNew = overlapStartNew + segmentLen;
-        const applicableHints = getApplicableFormatHints(formatHints, overlapStartNew, overlapEndNew);
-        if (reconcileFormattingForTextSpan(xmlDoc, span, overlapStartOriginal, overlapEndOriginal, applicableHints, author, generateRedlines)) {
-          hasChanges = true;
+  const insertionOperations = insertionOnlyDiffs ? collectInsertionOperations(insertionOnlyDiffs) : [];
+  if (insertionOperations.length > 1 && formatHints.length === 0) {
+    for (const operation of insertionOperations.slice().reverse()) {
+      const liveSpans = buildSurgicalTextSpans(allParagraphs).textSpans;
+      const liveSpanIndex = buildSpanIndex(liveSpans);
+      const textWithoutNewlines = operation.text.replace(/\n/g, " ");
+      if (textWithoutNewlines.length === 0) continue;
+      const insertResult = processInsert(
+        xmlDoc,
+        liveSpanIndex,
+        operation.originalPos,
+        textWithoutNewlines,
+        author,
+        formatHints,
+        operation.newPos,
+        generateRedlines,
+        allParagraphs[0] || null,
+        null,
+        options?.insertionAffinity || null,
+        options?.existingRevisions || "merge-same-author"
+      );
+      if (insertResult && typeof insertResult === "object" && insertResult.error) {
+        return withOoxmlSourceType({
+          oxml: serializer.serializeToString(xmlDoc),
+          hasChanges: false,
+          status: "error",
+          error: insertResult.error
+        });
+      }
+      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
+          });
         }
-      });
-      originalPos += len;
-      newPos += len;
-    } else if (op === -1) {
-      const hasNextInsert = i + 1 < diffs.length && diffs[i + 1][0] === 1;
-      let paired = false;
+        if (inserted === true) hasChanges = true;
+        continue;
+      }
       let delMetadata = null;
       let insMetadata = null;
-      if (pairReplacements && generateRedlines && hasNextInsert) {
-        const nextText = diffs[i + 1][1];
-        const textWithoutNewlines = nextText.replace(/\n/g, " ");
-        if (textWithoutNewlines.length > 0) {
-          const checkResult = checkSafeAdjacencyForPairing(
-            spanIndex,
-            originalPos,
-            originalPos + text.length,
-            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 };
-            paired = true;
-          } else if (checkResult.structuralBoundary) {
-            warnings.push("PAIRING_SKIPPED_STRUCTURAL_BOUNDARY");
-          }
+      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, spanIndex, originalPos, originalPos + text.length, author, generateRedlines, delMetadata)) {
+      if (processDelete(xmlDoc, liveSpanIndex, operation.start, operation.end, author, generateRedlines, delMetadata)) {
         hasChanges = true;
       }
-      originalPos += text.length;
-      if (paired) {
-        i++;
-        const [, nextText] = diffs[i];
-        const textWithoutNewlines = nextText.replace(/\n/g, " ");
+      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];
+      if (op === 0) {
+        const len = text.length;
+        const startPos = originalPos;
+        const endPos = originalPos + len;
+        forEachOverlappingSpan(spanIndex, startPos, endPos, (span) => {
+          const overlapStartOriginal = Math.max(span.charStart, startPos);
+          const overlapEndOriginal = Math.min(span.charEnd, endPos);
+          const segmentLen = overlapEndOriginal - overlapStartOriginal;
+          const relativeOffset = overlapStartOriginal - startPos;
+          const overlapStartNew = newPos + relativeOffset;
+          const overlapEndNew = overlapStartNew + segmentLen;
+          const applicableHints = getApplicableFormatHints(formatHints, overlapStartNew, overlapEndNew);
+          if (reconcileFormattingForTextSpan(xmlDoc, span, overlapStartOriginal, overlapEndOriginal, applicableHints, author, generateRedlines)) {
+            hasChanges = true;
+          }
+        });
+        originalPos += len;
+        newPos += len;
+      } else if (op === -1) {
+        const hasNextInsert = i + 1 < diffs.length && diffs[i + 1][0] === 1;
+        let paired = false;
+        let delMetadata = null;
+        let insMetadata = null;
+        if (pairReplacements && generateRedlines && hasNextInsert) {
+          const nextText = diffs[i + 1][1];
+          const textWithoutNewlines = nextText.replace(/\n/g, " ");
+          if (textWithoutNewlines.length > 0) {
+            const checkResult = checkSafeAdjacencyForPairing(
+              spanIndex,
+              originalPos,
+              originalPos + text.length,
+              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 };
+              paired = true;
+            } else if (checkResult.structuralBoundary) {
+              warnings.push("PAIRING_SKIPPED_STRUCTURAL_BOUNDARY");
+            }
+          }
+        }
+        if (processDelete(xmlDoc, spanIndex, originalPos, originalPos + text.length, author, generateRedlines, delMetadata)) {
+          hasChanges = true;
+        }
+        originalPos += text.length;
+        if (paired) {
+          i++;
+          const [, nextText] = diffs[i];
+          const textWithoutNewlines = nextText.replace(/\n/g, " ");
+          if (textWithoutNewlines.length > 0) {
+            const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, insMetadata, options?.insertionAffinity || null, options?.existingRevisions || "merge-same-author");
+            if (insertResult && typeof insertResult === "object" && insertResult.error) {
+              return withOoxmlSourceType({
+                oxml: serializer.serializeToString(xmlDoc),
+                hasChanges: false,
+                status: "error",
+                error: insertResult.error
+              });
+            }
+            if (insertResult === true) {
+              hasChanges = true;
+            }
+          }
+          newPos += nextText.length;
+        }
+      } else if (op === 1) {
+        const textWithoutNewlines = text.replace(/\n/g, " ");
         if (textWithoutNewlines.length > 0) {
-          const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, insMetadata, options?.insertionAffinity || null, options?.existingRevisions || "merge-same-author");
+          const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, null, options?.insertionAffinity || null, options?.existingRevisions || "merge-same-author");
           if (insertResult && typeof insertResult === "object" && insertResult.error) {
             return withOoxmlSourceType({
               oxml: serializer.serializeToString(xmlDoc),
@@ -6633,25 +6802,8 @@ function applySurgicalMode(xmlDoc, originalText, modifiedText, serializer, autho
             hasChanges = true;
           }
         }
-        newPos += nextText.length;
-      }
-    } else if (op === 1) {
-      const textWithoutNewlines = text.replace(/\n/g, " ");
-      if (textWithoutNewlines.length > 0) {
-        const insertResult = processInsert(xmlDoc, spanIndex, originalPos, textWithoutNewlines, author, formatHints, newPos, generateRedlines, allParagraphs[0] || null, null, options?.insertionAffinity || null, options?.existingRevisions || "merge-same-author");
-        if (insertResult && typeof insertResult === "object" && insertResult.error) {
-          return withOoxmlSourceType({
-            oxml: serializer.serializeToString(xmlDoc),
-            hasChanges: false,
-            status: "error",
-            error: insertResult.error
-          });
-        }
-        if (insertResult === true) {
-          hasChanges = true;
-        }
+        newPos += text.length;
       }
-      newPos += text.length;
     }
   }
   const actualText = allParagraphs.map((paragraph) => extractCanonicalParagraphText(paragraph)).join("\n");
@@ -6667,7 +6819,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)] } : {}
     });
@@ -6690,6 +6844,76 @@ 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;
+  let newPos = 0;
+  for (const [op, text] of diffs) {
+    if (op === 0) {
+      originalPos += text.length;
+      newPos += text.length;
+    } else if (op === -1) {
+      originalPos += text.length;
+    } else if (op === 1) {
+      operations.push({ originalPos, newPos, text });
+      newPos += text.length;
+    }
+  }
+  return operations;
+}
 
 // engine/reconstruction-mapper.js
 var import_diff_match_patch2 = __toESM(require_diff_match_patch(), 1);
@@ -7592,8 +7816,8 @@ function resolveAuthorFilter(options = {}) {
   if (options?.allAuthors === true) {
     return { valid: true, allAuthors: true, normalizedAuthor: "" };
   }
-  const normalizedAuthor = normalizeAuthor(options?.author);
-  if (!normalizedAuthor) {
+  const normalizedAuthor2 = normalizeAuthor(options?.author);
+  if (!normalizedAuthor2) {
     return {
       valid: false,
       allAuthors: false,
@@ -7601,7 +7825,7 @@ function resolveAuthorFilter(options = {}) {
       warning: "No author provided. Pass { author } or set { allAuthors: true }."
     };
   }
-  return { valid: true, allAuthors: false, normalizedAuthor };
+  return { valid: true, allAuthors: false, normalizedAuthor: normalizedAuthor2 };
 }
 function authorMatchesNode(node, filter) {
   if (filter.allAuthors) return true;
@@ -8053,6 +8277,133 @@ function recordRouteSelection(options, route, context = {}) {
   }));
 }
 
+// core/paragraph-revision-safety.js
+var NON_CONTENT_CHILDREN = /* @__PURE__ */ new Set([
+  "pPr",
+  "bookmarkStart",
+  "bookmarkEnd",
+  "commentRangeStart",
+  "commentRangeEnd",
+  "commentReference",
+  "customXmlInsRangeStart",
+  "customXmlInsRangeEnd",
+  "customXmlDelRangeStart",
+  "customXmlDelRangeEnd",
+  "moveFromRangeStart",
+  "moveFromRangeEnd",
+  "moveToRangeStart",
+  "moveToRangeEnd",
+  "permStart",
+  "permEnd",
+  "proofErr"
+]);
+function localNameOf2(node) {
+  return String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
+}
+function directElementChildren(node) {
+  return Array.from(node?.childNodes || []).filter((child) => child.nodeType === 1);
+}
+function directChild(node, localName2) {
+  return directElementChildren(node).find((child) => localNameOf2(child) === localName2) || null;
+}
+function wordAttribute2(node, localName2) {
+  return node?.getAttribute?.(`w:${localName2}`) || node?.getAttribute?.(localName2) || "";
+}
+function normalizedAuthor(author) {
+  return String(author || "").trim().toLowerCase();
+}
+function isAnchorOnlyRun(node) {
+  if (localNameOf2(node) !== "r") return false;
+  return directElementChildren(node).every((child) => [
+    "rPr",
+    "commentReference",
+    "bookmarkStart",
+    "bookmarkEnd",
+    "commentRangeStart",
+    "commentRangeEnd",
+    "proofErr"
+  ].includes(localNameOf2(child)));
+}
+function isNonContentChild(node) {
+  return NON_CONTENT_CHILDREN.has(localNameOf2(node)) || isAnchorOnlyRun(node);
+}
+function isWhollyDeletedContentNode(node) {
+  if (localNameOf2(node) === "del") return true;
+  if (!["customXml", "smartTag", "sdt", "sdtContent"].includes(localNameOf2(node))) return false;
+  const contentChildren = directElementChildren(node).filter((child) => !isNonContentChild(child) && localNameOf2(child) !== "sdtPr");
+  return contentChildren.every(isWhollyDeletedContentNode);
+}
+function paragraphMarkDeletion(paragraph) {
+  const pPr = directChild(paragraph, "pPr");
+  const rPr = directChild(pPr, "rPr");
+  return directChild(rPr, "del");
+}
+function hasVisibleInsertionContent(insertion) {
+  for (const node of Array.from(insertion?.getElementsByTagName?.("*") || [])) {
+    const localName2 = localNameOf2(node);
+    if (!["t", "tab", "br", "cr", "noBreakHyphen", "softHyphen"].includes(localName2)) continue;
+    let ancestor = node.parentNode;
+    let hidden = false;
+    while (ancestor && ancestor !== insertion) {
+      const ancestorName = localNameOf2(ancestor);
+      if (ancestorName === "del" || ancestorName === "moveFrom") {
+        hidden = true;
+        break;
+      }
+      ancestor = ancestor.parentNode;
+    }
+    if (hidden) continue;
+    if (localName2 !== "t" || (node.textContent || "").length > 0) return true;
+  }
+  return false;
+}
+function inspectForeignDeletedParagraphTarget(paragraph, mutationAuthor) {
+  const markDeletion = paragraphMarkDeletion(paragraph);
+  if (!markDeletion) {
+    return {
+      matches: false,
+      hasParagraphMarkDeletion: false,
+      foreignParagraphMarkDeletion: false,
+      allContentDeleted: false,
+      ownerAuthor: null,
+      markDeletion: null
+    };
+  }
+  const ownerAuthor = wordAttribute2(markDeletion, "author") || null;
+  const foreignParagraphMarkDeletion = !ownerAuthor || normalizedAuthor(ownerAuthor) !== normalizedAuthor(mutationAuthor);
+  const contentChildren = directElementChildren(paragraph).filter((child) => !isNonContentChild(child));
+  const allContentDeleted = contentChildren.every(isWhollyDeletedContentNode);
+  return {
+    matches: foreignParagraphMarkDeletion && allContentDeleted,
+    hasParagraphMarkDeletion: true,
+    foreignParagraphMarkDeletion,
+    allContentDeleted,
+    ownerAuthor,
+    markDeletion
+  };
+}
+function findForeignDeletedParagraphResurrections(root) {
+  const paragraphs = localNameOf2(root) === "p" ? [root] : Array.from(root?.getElementsByTagName?.("*") || []).filter((node) => localNameOf2(node) === "p");
+  const matches = [];
+  for (const paragraph of paragraphs) {
+    const markDeletion = paragraphMarkDeletion(paragraph);
+    if (!markDeletion) continue;
+    const ownerAuthor = wordAttribute2(markDeletion, "author") || null;
+    const contentChildren = directElementChildren(paragraph).filter((child) => !isNonContentChild(child));
+    const foreignInsertions = contentChildren.filter((child) => {
+      if (localNameOf2(child) !== "ins" || !hasVisibleInsertionContent(child)) return false;
+      return normalizedAuthor(wordAttribute2(child, "author")) !== normalizedAuthor(ownerAuthor);
+    });
+    const onlyDeletedContentAndForeignInsertions = contentChildren.every((child) => {
+      return isWhollyDeletedContentNode(child) || foreignInsertions.includes(child);
+    });
+    if (foreignInsertions.length > 0 && onlyDeletedContentAndForeignInsertions) {
+      matches.push({ paragraph, markDeletion, ownerAuthor, foreignInsertions });
+    }
+  }
+  return matches;
+}
+
 // engine/oxml-engine.js
 function getCommentIdsInOoxml(node) {
   const ids = /* @__PURE__ */ new Set();
@@ -8133,6 +8484,23 @@ async function applyRedlineToOxml(oxml, originalText, modifiedText, options = {}
   }
   const revisionIdAllocator = options?._revisionIdAllocator instanceof RevisionIdAllocator ? options._revisionIdAllocator : new RevisionIdAllocator();
   seedRevisionIdsFromDocument(xmlDoc, revisionIdAllocator);
+  const inputParagraphs = xmlDoc.documentElement && String(xmlDoc.documentElement.localName || "").toLowerCase() === "p" ? [xmlDoc.documentElement] : getDocumentParagraphs(xmlDoc);
+  if (inputParagraphs.length === 1 && modifiedText.length > 0) {
+    const resurrectionTarget = inspectForeignDeletedParagraphTarget(inputParagraphs[0], author);
+    if (resurrectionTarget.matches) {
+      const ownerAuthor = resurrectionTarget.ownerAuthor || "unattributed";
+      return finalize({
+        oxml: inputOoxml,
+        hasChanges: false,
+        status: "error",
+        error: {
+          code: "FOREIGN_PARAGRAPH_MARK_DELETION",
+          message: `Refusing to add visible text to a paragraph whose paragraph mark is deleted by another author (${ownerAuthor}). Use explicit paragraph restoration when supported.`,
+          ownerAuthor
+        }
+      });
+    }
+  }
   if (containsTrackedChanges(xmlDoc)) {
     if (existingRevisionsPolicy === "merge-same-author" || existingRevisionsPolicy === "slice-cross-author") {
       const authors = getTrackedChangeAuthors(xmlDoc);
@@ -8839,6 +9207,23 @@ function resolveTargetParagraph(xmlDoc, options = {}) {
     }
     return { paragraph: byId, resolvedBy: "paragraph_id" };
   }
+  if (descriptor?.fingerprint && !cleanTargetText && !parsedRef) {
+    let fingerprintCandidates = (paragraphMetadataIndex?.entries || []).filter((candidate) => candidate.fingerprint === descriptor.fingerprint);
+    if (typeof descriptor.inTable === "boolean") {
+      fingerprintCandidates = fingerprintCandidates.filter((candidate) => candidate.inTable === descriptor.inTable);
+    }
+    if (fingerprintCandidates.length === 1) {
+      return { paragraph: fingerprintCandidates[0].paragraph, resolvedBy: "fingerprint" };
+    }
+    if (fingerprintCandidates.length > 1) {
+      throw createTargetError(
+        "AMBIGUOUS_TARGET",
+        "Target fingerprint matched multiple paragraphs; provide paragraphId or index.",
+        fingerprintCandidates.map(serializeTargetCandidate)
+      );
+    }
+    throw createTargetError("TARGET_NOT_FOUND", `Target fingerprint not found: "${descriptor.fingerprint}".`);
+  }
   let candidates = [];
   if (cleanTargetText) {
     const unfilteredCandidates = findStrictTargetCandidates(xmlDoc, cleanTargetText, paragraphMetadataIndex);
@@ -9867,20 +10252,20 @@ async function executeSingleLineListStructuralFallback(plan, options = {}) {
 // core/redline-validation.js
 var REVISION_ID_ELEMENTS = /* @__PURE__ */ new Set(["ins", "del", "rPrChange", "pPrChange"]);
 var REVISION_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T/;
-function localNameOf2(node) {
+function localNameOf3(node) {
   return String(node?.localName || node?.nodeName || "").replace(/^.*:/, "");
 }
 function elementsByLocalName(root, name) {
-  return Array.from(root.getElementsByTagName("*")).filter((el) => localNameOf2(el) === name);
+  return Array.from(root.getElementsByTagName("*")).filter((el) => localNameOf3(el) === name);
 }
-function wordAttribute2(node, name) {
+function wordAttribute3(node, name) {
   return node.getAttribute(`w:${name}`) || node.getAttribute(name) || "";
 }
 function xmlSpaceAttribute(node) {
   return node.getAttribute("xml:space") || node.getAttribute("space") || node.getAttributeNS?.("http://www.w3.org/XML/1998/namespace", "space") || "";
 }
 function isParagraphMarkRevision(node) {
-  return localNameOf2(node.parentNode) === "rPr";
+  return localNameOf3(node.parentNode) === "rPr";
 }
 function parseOoxmlForValidation(oxml) {
   const attempt = (xml) => {
@@ -9904,11 +10289,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 };
@@ -9917,14 +10303,14 @@ function validateRedlineOoxml(oxml) {
   const delElements = elementsByLocalName(doc, "del");
   const revisions = insElements.concat(delElements);
   for (const paragraph of elementsByLocalName(doc, "p")) {
-    const nested = Array.from(paragraph.getElementsByTagName("*")).find((el) => el !== paragraph && localNameOf2(el) === "p");
+    const nested = Array.from(paragraph.getElementsByTagName("*")).find((el) => el !== paragraph && localNameOf3(el) === "p");
     if (nested) {
       addIssue("NESTED_PARAGRAPH", "error", `<${paragraph.nodeName}> contains nested <${nested.nodeName}>.`);
     }
   }
   for (const body of elementsByLocalName(doc, "body")) {
     const children = Array.from(body.childNodes || []).filter((child) => child.nodeType === 1);
-    const sectPrIndexes = children.map((child, index) => localNameOf2(child) === "sectPr" ? index : -1).filter((index) => index >= 0);
+    const sectPrIndexes = children.map((child, index) => localNameOf3(child) === "sectPr" ? index : -1).filter((index) => index >= 0);
     if (sectPrIndexes.length > 1) {
       addIssue("MULTIPLE_BODY_SECTPR", "error", "<w:body> contains multiple direct <w:sectPr> elements.");
     } else if (sectPrIndexes.length === 1 && sectPrIndexes[0] !== children.length - 1) {
@@ -9932,16 +10318,16 @@ function validateRedlineOoxml(oxml) {
     }
   }
   for (const revision of revisions) {
-    const nested = Array.from(revision.getElementsByTagName("*")).filter((el) => el !== revision && ["ins", "del"].includes(localNameOf2(el)));
+    const nested = Array.from(revision.getElementsByTagName("*")).filter((el) => el !== revision && ["ins", "del"].includes(localNameOf3(el)));
     const invalidNested = nested.find((candidate) => {
-      if (localNameOf2(revision) !== "ins" || localNameOf2(candidate) !== "del") return true;
+      if (localNameOf3(revision) !== "ins" || localNameOf3(candidate) !== "del") return true;
       return candidate.parentNode !== revision;
     });
     if (invalidNested) {
       addIssue(
         "NESTED_REVISION",
         "error",
-        `<${revision.nodeName}> (w:id="${wordAttribute2(revision, "id")}") contains invalid nested <${invalidNested.nodeName}>.`
+        `<${revision.nodeName}> (w:id="${wordAttribute3(revision, "id")}") contains invalid nested <${invalidNested.nodeName}>.`
       );
     }
   }
@@ -9951,15 +10337,15 @@ function validateRedlineOoxml(oxml) {
       addIssue(
         "DEL_CONTAINS_T",
         "error",
-        `<w:del> (w:id="${wordAttribute2(del, "id")}") contains <w:t>; deleted text must use <w:delText>.`
+        `<w:del> (w:id="${wordAttribute3(del, "id")}") contains <w:t>; deleted text must use <w:delText>.`
       );
     }
   }
   for (const revision of revisions) {
     const missing = [];
-    if (!wordAttribute2(revision, "id")) missing.push("w:id");
-    if (!wordAttribute2(revision, "author")) missing.push("w:author");
-    if (!REVISION_DATE_PATTERN.test(wordAttribute2(revision, "date"))) missing.push("w:date");
+    if (!wordAttribute3(revision, "id")) missing.push("w:id");
+    if (!wordAttribute3(revision, "author")) missing.push("w:author");
+    if (!REVISION_DATE_PATTERN.test(wordAttribute3(revision, "date"))) missing.push("w:date");
     if (missing.length > 0) {
       addIssue(
         "MISSING_REVISION_METADATA",
@@ -9970,8 +10356,8 @@ function validateRedlineOoxml(oxml) {
   }
   const seenIds = /* @__PURE__ */ new Set();
   for (const node of Array.from(doc.getElementsByTagName("*"))) {
-    if (!REVISION_ID_ELEMENTS.has(localNameOf2(node))) continue;
-    const id = wordAttribute2(node, "id");
+    if (!REVISION_ID_ELEMENTS.has(localNameOf3(node))) continue;
+    const id = wordAttribute3(node, "id");
     if (!id) continue;
     if (seenIds.has(id)) {
       addIssue("DUPLICATE_REVISION_ID", "error", `Revision id ${id} appears more than once.`);
@@ -9999,10 +10385,18 @@ function validateRedlineOoxml(oxml) {
       addIssue(
         "EMPTY_REVISION_WRAPPER",
         "warning",
-        `<${revision.nodeName}> (w:id="${wordAttribute2(revision, "id")}") wraps no content.`
+        `<${revision.nodeName}> (w:id="${wordAttribute3(revision, "id")}") wraps no content.`
       );
     }
   }
+  for (const resurrection of findForeignDeletedParagraphResurrections(doc)) {
+    const ownerAuthor = resurrection.ownerAuthor || "unattributed";
+    addIssue(
+      "FOREIGN_PARAGRAPH_MARK_DELETION",
+      "warning",
+      `Paragraph deleted by ${ownerAuthor} also contains non-empty insertion content from another author; Accept/Reject lifecycle may not preserve the apparent restoration.`
+    );
+  }
   return { valid: !issues.some((issue) => issue.severity === "error"), issues };
 }