@ansonlai/docx-redline-js 0.8.1 → 0.8.3

package/core/list-targeting.js

@@ -9,12 +9,13 @@ import {
 } from './paragraph-targeting.js';
 import { parseListItem, stripListMarker } from '../pipeline/list-markers.js';
 
-function getFirstDescendantByLocalName(node, localName) {
-    if (!node || typeof node.getElementsByTagNameNS !== 'function') return null;
-    const namespaced = node.getElementsByTagNameNS(WORD_MAIN_NS, localName);
-    if (namespaced.length > 0) return namespaced[0];
-    const anyNs = node.getElementsByTagNameNS('*', localName);
-    return anyNs.length > 0 ? anyNs[0] : null;
+/** Direct element child by local name; never crosses w:pPrChange / w:rPrChange boundaries. */
+function getDirectChildByLocalName(node, localName) {
+    if (!node) return null;
+    for (const child of Array.from(node.childNodes || [])) {
+        if (child?.nodeType === 1 && child.localName === localName) return child;
+    }
+    return null;
 }
 
 function readValAttribute(element) {
@@ -178,17 +179,18 @@ function buildListEntriesForInsertion(parsedItems, normalizedTargetText, anchorL
 export function getParagraphListInfo(paragraph) {
     if (!paragraph) return null;
 
-    const pPr = getFirstDescendantByLocalName(paragraph, 'pPr');
+    // Current properties only: direct w:pPr/w:numPr, never historical w:pPrChange/w:pPr.
+    const pPr = getDirectChildByLocalName(paragraph, 'pPr');
     if (!pPr) return null;
-    const numPr = getFirstDescendantByLocalName(pPr, 'numPr');
+    const numPr = getDirectChildByLocalName(pPr, 'numPr');
     if (!numPr) return null;
-    const numIdEl = getFirstDescendantByLocalName(numPr, 'numId');
+    const numIdEl = getDirectChildByLocalName(numPr, 'numId');
     if (!numIdEl) return null;
 
     const numId = readValAttribute(numIdEl);
     if (!numId || numId === '0') return null;
 
-    const ilvlEl = getFirstDescendantByLocalName(numPr, 'ilvl');
+    const ilvlEl = getDirectChildByLocalName(numPr, 'ilvl');
     const ilvlRaw = readValAttribute(ilvlEl);
     const ilvl = Number.parseInt(ilvlRaw || '0', 10);
 

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

@@ -1,4 +1,4 @@
-// @ansonlai/docx-redline-js v0.8.1 — https://github.com/AnsonLai/docx-redline-js
+// @ansonlai/docx-redline-js v0.8.3 — https://github.com/AnsonLai/docx-redline-js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -2522,15 +2522,29 @@ function createDiffEngine(options = {}) {
   engine.Diff_Timeout = timeout;
   return engine;
 }
-function tokenize(text2) {
+function tokenize(text2, atomicChars = null) {
   const tokens = [];
+  const pushWord = (word) => {
+    if (!atomicChars || atomicChars.size === 0) {
+      tokens.push(word);
+      return;
+    }
+    let start = 0;
+    for (let index = 0; index < word.length; index++) {
+      if (!atomicChars.has(word[index])) continue;
+      if (index > start) tokens.push(word.slice(start, index));
+      tokens.push(word[index]);
+      start = index + 1;
+    }
+    if (start < word.length) tokens.push(word.slice(start));
+  };
   const leading = text2.match(/^\s+/);
   if (leading) tokens.push(leading[0]);
   const regex = /(\S+)(\s*)/g;
   regex.lastIndex = leading?.[0].length || 0;
   let match;
   while ((match = regex.exec(text2)) !== null) {
-    if (match[1]) tokens.push(match[1]);
+    if (match[1]) pushWord(match[1]);
     if (match[2]) tokens.push(match[2]);
   }
   return tokens;
@@ -2558,8 +2572,8 @@ function wordsToChars(text1, text2, options = {}) {
     }
     return { chars, tokenIds };
   }
-  const tokens1 = tokenize(text1);
-  const tokens2 = tokenize(text2);
+  const tokens1 = tokenize(text1, options.atomicChars);
+  const tokens2 = tokenize(text2, options.atomicChars);
   const encoded1 = mapTokensToChars(tokens1);
   const encoded2 = mapTokensToChars(tokens2);
   return {
@@ -3959,7 +3973,37 @@ async function executeListGeneration(options) {
       }];
     }
   }
-  if (generateRedlines && deletionRuns.length > 0) {
+  const sourceParagraphCount = (originalRunModel || []).filter((run) => run.kind === RunKind.PARAGRAPH_START).length;
+  if (generateRedlines && sourceParagraphCount > 0 && (sourceParagraphCount > 1 || deletionRuns.length === 0)) {
+    let segment = null;
+    const flushSegment = () => {
+      if (!segment) return;
+      results.push(serializeToOoxml(segment, null, [], {
+        author,
+        generateRedlines,
+        revisionIdAllocator
+      }));
+      segment = null;
+    };
+    for (const run of originalRunModel) {
+      if (run.kind === RunKind.PARAGRAPH_START) {
+        flushSegment();
+        segment = [{
+          ...run,
+          pPrElement: null,
+          pPrXml: addParagraphMarkRevision(
+            run.pPrElement || run.pPrXml || null,
+            "del",
+            author,
+            revisionIdAllocator
+          )
+        }];
+      } else if (segment && (run.kind === "text" || run.kind === "run")) {
+        segment.push({ ...run, kind: "deletion", author });
+      }
+    }
+    flushSegment();
+  } else if (generateRedlines && deletionRuns.length > 0) {
     const deletedPPr = addParagraphMarkRevision(sourcePPr, "del", author, revisionIdAllocator);
     const deletedParagraph = serializeToOoxml(deletionRuns, deletedPPr, [], {
       author,
@@ -7964,7 +8008,11 @@ function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer,
   if (mapping.paragraphs.length === 0) {
     return withOoxmlSourceType({ oxml: serializer.serializeToString(xmlDoc), hasChanges: false });
   }
-  const diffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText, diffOptions);
+  const wordDiffs = computeWordDiffs(mapping.originalFullText, mapping.processedModifiedText, {
+    ...diffOptions,
+    atomicChars: new Set(mapping.referenceMap.keys())
+  });
+  const diffs = keepUnchangedTextOutsideWrappers(anchorSharedReferences(wordDiffs, mapping.referenceMap), mapping);
   return withOoxmlSourceType(applyReconstructionDiffs(
     xmlDoc,
     diffs,
@@ -7976,6 +8024,109 @@ function applyReconstructionMode(xmlDoc, originalText, modifiedText, serializer,
     options
   ));
 }
+function forEachChangeGroup(diffs, onEqual, onGroup) {
+  let index = 0;
+  while (index < diffs.length) {
+    if (diffs[index][0] === 0) {
+      onEqual(diffs[index]);
+      index++;
+      continue;
+    }
+    const group = [];
+    while (index < diffs.length && diffs[index][0] !== 0) group.push(diffs[index++]);
+    onGroup(
+      group,
+      group.filter(([op]) => op === -1).map(([, text2]) => text2).join(""),
+      group.filter(([op]) => op === 1).map(([, text2]) => text2).join("")
+    );
+  }
+}
+function pushChange(result, deleted, inserted) {
+  if (deleted === inserted) {
+    if (deleted) result.push([0, deleted]);
+    return;
+  }
+  if (deleted) result.push([-1, deleted]);
+  if (inserted) result.push([1, inserted]);
+}
+function anchorSharedReferences(diffs, referenceMap) {
+  if (referenceMap.size === 0) return diffs;
+  const result = [];
+  forEachChangeGroup(diffs, (part) => result.push(part), (group, deleted, inserted) => {
+    const deletedRefs = [...deleted].filter((char) => referenceMap.has(char) && inserted.includes(char));
+    const insertedRefs = [...inserted].filter((char) => deletedRefs.includes(char));
+    if (deletedRefs.length === 0 || deletedRefs.join("") !== insertedRefs.join("")) {
+      result.push(...group);
+      return;
+    }
+    let deletedStart = 0;
+    let insertedStart = 0;
+    for (const ref of deletedRefs) {
+      const deletedAt = deleted.indexOf(ref, deletedStart);
+      const insertedAt = inserted.indexOf(ref, insertedStart);
+      pushChange(result, deleted.slice(deletedStart, deletedAt), inserted.slice(insertedStart, insertedAt));
+      result.push([0, ref]);
+      deletedStart = deletedAt + 1;
+      insertedStart = insertedAt + 1;
+    }
+    pushChange(result, deleted.slice(deletedStart), inserted.slice(insertedStart));
+  });
+  return result;
+}
+function commonPrefixLength(left, right) {
+  const limit = Math.min(left.length, right.length);
+  let length = 0;
+  while (length < limit && left[length] === right[length]) length++;
+  return length;
+}
+function commonSuffixLength(left, right, limit) {
+  let length = 0;
+  while (length < limit && left[left.length - 1 - length] === right[right.length - 1 - length]) length++;
+  return length;
+}
+function keepUnchangedTextOutsideWrappers(diffs, mapping) {
+  const wrapperAt = (index) => mapping.getRunProperties(index).wrapper || null;
+  const result = [];
+  let originalOffset = 0;
+  forEachChangeGroup(diffs, (part) => {
+    result.push(part);
+    originalOffset += part[1].length;
+  }, (group, deleted, inserted) => {
+    const start = originalOffset;
+    const end = start + deleted.length;
+    originalOffset = end;
+    const isWrapperBoundary = (index) => index > start && index < end && wrapperAt(index - 1) !== wrapperAt(index);
+    let prefix = 0;
+    let suffix = 0;
+    if (deleted && inserted) {
+      const sharedSuffix = commonSuffixLength(deleted, inserted, Math.min(deleted.length, inserted.length));
+      for (let length = sharedSuffix; length > 0; length--) {
+        if (isWrapperBoundary(end - length)) {
+          suffix = length;
+          break;
+        }
+      }
+      const sharedPrefix = Math.min(
+        commonPrefixLength(deleted, inserted),
+        Math.min(deleted.length, inserted.length) - suffix
+      );
+      for (let length = sharedPrefix; length > 0; length--) {
+        if (isWrapperBoundary(start + length)) {
+          prefix = length;
+          break;
+        }
+      }
+    }
+    if (prefix === 0 && suffix === 0) {
+      result.push(...group);
+      return;
+    }
+    if (prefix > 0) result.push([0, deleted.slice(0, prefix)]);
+    pushChange(result, deleted.slice(prefix, deleted.length - suffix), inserted.slice(prefix, inserted.length - suffix));
+    if (suffix > 0) result.push([0, deleted.slice(deleted.length - suffix)]);
+  });
+  return result;
+}
 
 // engine/table-mode.js
 function noChanges(serializer, xmlDoc) {
@@ -10050,12 +10201,12 @@ function validateParagraphBoundaryMutation(targetParagraph, modifiedText, option
 }
 
 // core/list-targeting.js
-function getFirstDescendantByLocalName(node, localName2) {
-  if (!node || typeof node.getElementsByTagNameNS !== "function") return null;
-  const namespaced = node.getElementsByTagNameNS(WORD_MAIN_NS, localName2);
-  if (namespaced.length > 0) return namespaced[0];
-  const anyNs = node.getElementsByTagNameNS("*", localName2);
-  return anyNs.length > 0 ? anyNs[0] : null;
+function getDirectChildByLocalName(node, localName2) {
+  if (!node) return null;
+  for (const child of Array.from(node.childNodes || [])) {
+    if (child?.nodeType === 1 && child.localName === localName2) return child;
+  }
+  return null;
 }
 function readValAttribute(element) {
   if (!element) return null;
@@ -10172,15 +10323,15 @@ function buildListEntriesForInsertion(parsedItems, normalizedTargetText, anchorL
 }
 function getParagraphListInfo(paragraph) {
   if (!paragraph) return null;
-  const pPr = getFirstDescendantByLocalName(paragraph, "pPr");
+  const pPr = getDirectChildByLocalName(paragraph, "pPr");
   if (!pPr) return null;
-  const numPr = getFirstDescendantByLocalName(pPr, "numPr");
+  const numPr = getDirectChildByLocalName(pPr, "numPr");
   if (!numPr) return null;
-  const numIdEl = getFirstDescendantByLocalName(numPr, "numId");
+  const numIdEl = getDirectChildByLocalName(numPr, "numId");
   if (!numIdEl) return null;
   const numId = readValAttribute(numIdEl);
   if (!numId || numId === "0") return null;
-  const ilvlEl = getFirstDescendantByLocalName(numPr, "ilvl");
+  const ilvlEl = getDirectChildByLocalName(numPr, "ilvl");
   const ilvlRaw = readValAttribute(ilvlEl);
   const ilvl = Number.parseInt(ilvlRaw || "0", 10);
   return {
@@ -10590,8 +10741,13 @@ function enforceListBindingOnParagraphNodes(nodes, options = {}) {
   }
   return updated;
 }
+function parseOxmlFragment(oxml) {
+  const text2 = String(oxml || "");
+  const declared = /xmlns:w\s*=/.test(text2);
+  return parseOoxmlSafe(declared ? text2 : `<w:root xmlns:w="${NS_W}">${text2}</w:root>`, "application/xml").doc;
+}
 function getFirstParagraphFromOxml(oxml) {
-  const doc = parseOoxmlSafe(oxml, "application/xml").doc;
+  const doc = parseOxmlFragment(oxml);
   if (!doc) return null;
   const parseError = getXmlParseError(doc);
   if (parseError) return null;
@@ -10618,17 +10774,17 @@ function setElementVal(element, value) {
   element.setAttribute("w:val", String(value));
 }
 function extractFirstParagraphNumIdFromOxml(oxml) {
-  const doc = parseOoxmlSafe(oxml, "application/xml").doc;
+  const doc = parseOxmlFragment(oxml);
   if (!doc) return null;
   const parseError = getXmlParseError(doc);
   if (parseError) return null;
   const paragraphs = getDocumentParagraphNodes(doc);
-  const firstParagraph = paragraphs[0] || null;
-  if (!firstParagraph) return null;
-  const numIdNodes = Array.from(firstParagraph.getElementsByTagNameNS("*", "numId"));
-  for (const numIdNode of numIdNodes) {
-    const numId = getElementId(numIdNode, ["w:val", "val"]);
-    if (numId != null) return String(numId);
+  for (const paragraph of paragraphs) {
+    const numIdNodes = Array.from(paragraph.getElementsByTagNameNS("*", "numId"));
+    for (const numIdNode of numIdNodes) {
+      const numId = getElementId(numIdNode, ["w:val", "val"]);
+      if (numId != null) return String(numId);
+    }
   }
   return null;
 }
@@ -11124,6 +11280,8 @@ function createDynamicNumberingIdState(numberingXml, options = {}) {
   const baseNumId = Math.max(minId, maxUsedNumId + 1);
   const baseAbstractNumId = Math.max(minId, maxUsedAbstractNumId + 1);
   return {
+    // Kept so list edits can recognise which existing definition a source list uses and continue it.
+    sourceNumberingXml: String(numberingXml || ""),
     nextNumId: nextAvailableId(baseNumId, usedNumIds, maxPreferred),
     nextAbstractNumId: nextAvailableId(baseAbstractNumId, usedAbstractNumIds, maxPreferred),
     usedNumIds,
@@ -11264,6 +11422,82 @@ function buildExplicitDecimalMultilevelNumberingXml(numId, abstractNumId, startA
     </w:num>
 </w:numbering>`.trim();
 }
+function isTrackedDeletedParagraph(node) {
+  if (!node || node.nodeType !== 1 || node.localName !== "p") return false;
+  const pPr = Array.from(node.childNodes || []).find((child) => isDirectWordChild(child, "pPr"));
+  const rPr = pPr && Array.from(pPr.childNodes || []).find((child) => isDirectWordChild(child, "rPr"));
+  return !!rPr && Array.from(rPr.childNodes || []).some((child) => isDirectWordChild(child, "del"));
+}
+function paragraphNumIdNodes(node) {
+  return Array.from(node?.getElementsByTagNameNS?.("*", "numId") || []).filter((numIdNode) => numIdNode.parentNode?.localName === "numPr");
+}
+function levelFormats(abstractNum) {
+  const formats = /* @__PURE__ */ new Map();
+  for (const lvl of Array.from(abstractNum?.getElementsByTagNameNS?.("*", "lvl") || [])) {
+    const ilvl = getElementId2(lvl, ["w:ilvl", "ilvl"]);
+    const fmt = Array.from(lvl.getElementsByTagNameNS("*", "numFmt"))[0]?.getAttribute("w:val") || null;
+    if (ilvl != null && fmt) formats.set(ilvl, fmt);
+  }
+  return formats;
+}
+function normalizeListFormat(format) {
+  return format === "bullet" || format === "circle" || format === "square" ? "bullet" : format;
+}
+function abstractNumForNumId(numberingDoc, numId) {
+  const num = Array.from(numberingDoc.getElementsByTagNameNS("*", "num")).find((candidate) => getElementId2(candidate, ["w:numId", "numId"]) === numId);
+  const abstractId = num && getElementId2(Array.from(num.getElementsByTagNameNS("*", "abstractNumId"))[0], ["w:val", "val"]);
+  if (abstractId == null) return null;
+  return Array.from(numberingDoc.getElementsByTagNameNS("*", "abstractNum")).find((candidate) => getElementId2(candidate, ["w:abstractNumId", "abstractNumId"]) === abstractId) || null;
+}
+function reuseSourceListNumbering(numberingXml, replacementNodes, sourceParagraphs, numberingIdState) {
+  const sourceXml = numberingIdState?.sourceNumberingXml;
+  if (!numberingXml || !String(sourceXml || "").trim() || !Array.isArray(replacementNodes)) return null;
+  const sourceNumIds = /* @__PURE__ */ new Set();
+  for (const paragraph of sourceParagraphs || []) {
+    for (const numIdNode of paragraphNumIdNodes(paragraph)) {
+      const id = getElementId2(numIdNode, ["w:val", "val"]);
+      if (id != null && id !== 0) sourceNumIds.add(id);
+    }
+  }
+  if (sourceNumIds.size !== 1) return null;
+  const [sourceNumId] = sourceNumIds;
+  const sourceDoc = parseOoxml(sourceXml);
+  const payloadDoc = parseOoxml(numberingXml);
+  if (hasXmlParseError(sourceDoc) || hasXmlParseError(payloadDoc)) return null;
+  const sourceAbstract = abstractNumForNumId(sourceDoc, sourceNumId);
+  if (!sourceAbstract) return null;
+  const sourceFormats = levelFormats(sourceAbstract);
+  const newParagraphNumIds = [];
+  for (const node of replacementNodes) {
+    if (isTrackedDeletedParagraph(node)) continue;
+    for (const numIdNode of paragraphNumIdNodes(node)) {
+      const ilvlNode = Array.from(numIdNode.parentNode.childNodes || []).find((child) => child.localName === "ilvl");
+      newParagraphNumIds.push({
+        numId: getElementId2(numIdNode, ["w:val", "val"]),
+        ilvl: ilvlNode ? getElementId2(ilvlNode, ["w:val", "val"]) ?? 0 : 0
+      });
+    }
+  }
+  if (newParagraphNumIds.length === 0) return null;
+  const payloadFormats = /* @__PURE__ */ new Map();
+  for (const { numId, ilvl } of newParagraphNumIds) {
+    if (numId == null) return null;
+    if (!payloadFormats.has(numId)) {
+      const abstract = abstractNumForNumId(payloadDoc, numId);
+      if (!abstract) return null;
+      payloadFormats.set(numId, levelFormats(abstract));
+    }
+    const generated = payloadFormats.get(numId).get(ilvl);
+    const existing = sourceFormats.get(ilvl);
+    if (!generated || !existing || normalizeListFormat(generated) !== normalizeListFormat(existing)) return null;
+  }
+  const clonedNodes = replacementNodes.map((node) => node?.cloneNode ? node.cloneNode(true) : node);
+  for (const node of clonedNodes) {
+    if (isTrackedDeletedParagraph(node)) continue;
+    for (const numIdNode of paragraphNumIdNodes(node)) setElementVal2(numIdNode, sourceNumId);
+  }
+  return { numId: sourceNumId, replacementNodes: clonedNodes };
+}
 function remapNumberingPayloadForDocument(numberingXml, replacementNodes, numberingIdState) {
   const numberingDoc = parseOoxml(numberingXml);
   if (hasXmlParseError(numberingDoc)) {
@@ -11301,6 +11535,7 @@ function remapNumberingPayloadForDocument(numberingXml, replacementNodes, number
   }
   const clonedNodes = Array.isArray(replacementNodes) ? replacementNodes.map((node) => node?.cloneNode ? node.cloneNode(true) : node) : [];
   for (const node of clonedNodes) {
+    if (isTrackedDeletedParagraph(node)) continue;
     const numIdNodes = Array.from(node?.getElementsByTagNameNS?.("*", "numId") || []);
     for (const numIdNode of numIdNodes) {
       const oldNumRef = getElementId2(numIdNode, ["w:val", "val"]);
@@ -12121,6 +12356,8 @@ function areRevisionTokensEqual(a, b) {
 var attr2 = (node, name) => node?.getAttribute?.(`w:${name}`) || node?.getAttribute?.(name) || "";
 var descendants = (node, name) => Array.from(node?.getElementsByTagNameNS?.(NS_W, name) || []);
 var first = (node, name) => descendants(node, name)[0] || null;
+var directChild2 = (node, name) => Array.from(node?.childNodes || []).find((child) => child?.nodeType === 1 && child.localName === name && (!child.namespaceURI || child.namespaceURI === NS_W)) || null;
+var currentPPr = (paragraph) => directChild2(paragraph, "pPr");
 function hasAncestor(node, localName2) {
   let cursor = node?.parentNode;
   while (cursor) {
@@ -12136,11 +12373,11 @@ function parseXml2(xml, partName, required = false) {
   return { doc: parsed.doc, warnings: parsed.warnings || [] };
 }
 function paragraphListProperties(paragraph) {
-  const numPr = first(first(paragraph, "pPr"), "numPr");
+  const numPr = directChild2(currentPPr(paragraph), "numPr");
   if (!numPr) return null;
-  const numId = attr2(first(numPr, "numId"), "val");
+  const numId = attr2(directChild2(numPr, "numId"), "val");
   if (!numId || numId === "0") return null;
-  return { numId, level: Number.parseInt(attr2(first(numPr, "ilvl"), "val") || "0", 10) || 0 };
+  return { numId, level: Number.parseInt(attr2(directChild2(numPr, "ilvl"), "val") || "0", 10) || 0 };
 }
 function parseNumbering(numberingDoc) {
   const abstracts = /* @__PURE__ */ new Map();
@@ -12225,11 +12462,11 @@ function createNumberingResolver(numberingDoc) {
   };
 }
 function headingLevel(paragraph) {
-  const pPr = first(paragraph, "pPr");
-  const style = attr2(first(pPr, "pStyle"), "val");
+  const pPr = currentPPr(paragraph);
+  const style = attr2(directChild2(pPr, "pStyle"), "val");
   const match = style.match(/^heading\s*([1-9])$/i);
   if (match) return Math.min(Number(match[1]), 6);
-  const outline = Number.parseInt(attr2(first(pPr, "outlineLvl"), "val"), 10);
+  const outline = Number.parseInt(attr2(directChild2(pPr, "outlineLvl"), "val"), 10);
   return Number.isInteger(outline) ? Math.min(outline + 1, 6) : null;
 }
 function structuralContext(paragraph, text2) {
@@ -12408,7 +12645,7 @@ function inspectDocumentParts(parts, options = {}) {
     const ids = [...new Set([...descendants(paragraph, "commentRangeStart"), ...descendants(paragraph, "commentReference")].map((node) => attr2(node, "id")).filter(Boolean))];
     const authors = revisionAuthors(paragraph);
     const list = resolveNumbering(paragraphListProperties(paragraph));
-    const styleId = attr2(first(first(paragraph, "pPr"), "pStyle"), "val") || null;
+    const styleId = attr2(directChild2(currentPPr(paragraph), "pStyle"), "val") || null;
     const structure = structuralContext(paragraph, text2);
     const index = zeroIndex + 1;
     const provision = list?.label && list.format !== "bullet" ? list.label : null;
@@ -17809,7 +18046,9 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
         paragraphText,
         generateRedlines ? createRevisionMetadata(author, xmlDoc) : null,
         author,
-        { generateRedlines }
+        // A wholly inserted paragraph must track its own paragraph mark; otherwise Word's
+        // Reject All removes the text but leaves an empty paragraph behind.
+        { generateRedlines, trackParagraphMark: true }
       );
       const imported = xmlDoc.importNode(plainParagraph, true);
       ensureParagraphIdsOnImportedNode(imported, operationSession);
@@ -17940,6 +18179,14 @@ async function applyToParagraphByExactText(documentXml, targetText, modifiedText
   const extracted = extractReplacementNodes(result.oxml);
   let replacementNodes = removeListPackagingSentinel(extracted.replacementNodes, result.warnings);
   let numberingXml = extracted.numberingXml;
+  if (numberingXml && runtimeContext?.numberingIdState && !useTableScope) {
+    const sourceParagraphs = useListScope ? listScopeEdit.paragraphs : explicitRangeParagraphs || [targetParagraph];
+    const continued = reuseSourceListNumbering(numberingXml, replacementNodes, sourceParagraphs, runtimeContext.numberingIdState);
+    if (continued) {
+      replacementNodes = continued.replacementNodes;
+      numberingXml = null;
+    }
+  }
   if (numberingXml && runtimeContext?.numberingIdState) {
     const normalizedNumbering = remapNumberingPayloadForDocument(numberingXml, replacementNodes, runtimeContext.numberingIdState);
     replacementNodes = normalizedNumbering.replacementNodes;