@usejunior/docx-core 0.20.1 → 0.21.2

package/dist/primitives/text.js

@@ -1,7 +1,10 @@
 import { OOXML, W } from './namespaces.js';
 import { SafeDocxError } from './errors.js';
-import { getAttributeSafe, getFirstChild } from './xml-helpers.js';
+import { getFirstChild } from './xml-helpers.js';
 import { buildRPrChangeElement, createRevisionContainer, prepareElementForDeletion, } from './track-changes-emitter.js';
+import { buildParagraphIndex } from './paragraph-index.js';
+import { canSafelyRemoveEmptyParagraph } from './paragraph_structure.js';
+import { SYM_LOCAL_NAME } from './symbol_run_content.js';
 /**
  * Return the paragraph's visible runs while retaining enough complex-field
  * provenance to distinguish a safe cached-result edit from a field-boundary
@@ -11,93 +14,14 @@ import { buildRPrChangeElement, createRevisionContainer, prepareElementForDeleti
  * @see #651
  */
 export function getParagraphRuns(p) {
-    function currentResultId(stack) {
-        if (stack.length === 0 || stack.some((frame) => frame.phase === 'instruction'))
-            return null;
-        return stack.at(-1).id;
-    }
-    function getWAttr(el, localName) {
-        return getAttributeSafe(el, OOXML.W_NS, localName, 'w');
-    }
-    const runs = [];
-    const rElems = Array.from(p.getElementsByTagNameNS(OOXML.W_NS, W.r));
-    const fieldStack = [];
-    const fieldInstructions = new Map();
-    let nextFieldId = 1;
-    for (const r of rElems) {
-        let runText = '';
-        let sawResult = false;
-        let runFieldResultId;
-        const appendVisibleText = (text) => {
-            const resultId = currentResultId(fieldStack);
-            sawResult ||= resultId !== null;
-            if (runFieldResultId === undefined) {
-                runFieldResultId = resultId;
-            }
-            else if (runFieldResultId !== resultId) {
-                // A run whose visible content straddles a field boundary cannot be
-                // rewritten as one unit without moving content across that boundary.
-                runFieldResultId = null;
-            }
-            runText += text;
-        };
-        // Walk children in order so we can handle rare cases where fldChar and result text
-        // appear in the same run.
-        for (const child of Array.from(r.childNodes)) {
-            if (child.nodeType !== 1)
-                continue;
-            const el = child;
-            if (el.namespaceURI !== OOXML.W_NS)
-                continue;
-            if (el.localName === W.fldChar) {
-                const typ = getWAttr(el, 'fldCharType') ?? '';
-                if (typ === 'begin') {
-                    fieldStack.push({ id: nextFieldId++, phase: 'instruction', instruction: '' });
-                }
-                else if (typ === 'separate') {
-                    const frame = fieldStack.at(-1);
-                    if (frame) {
-                        frame.phase = 'result';
-                        fieldInstructions.set(frame.id, frame.instruction.trim());
-                    }
-                }
-                else if (typ === 'end') {
-                    fieldStack.pop();
-                }
-                continue;
-            }
-            const instructionFrame = [...fieldStack].reverse().find((frame) => frame.phase === 'instruction');
-            if (instructionFrame) {
-                if (el.localName === W.instrText || el.localName === 'delInstrText') {
-                    instructionFrame.instruction += el.textContent ?? '';
-                }
-                // Skip field code/instruction text.
-                continue;
-            }
-            if (el.localName === W.t) {
-                appendVisibleText(el.textContent ?? '');
-            }
-            else if (el.localName === W.tab) {
-                appendVisibleText('\t');
-            }
-            else if (el.localName === W.br) {
-                appendVisibleText('\n');
-            }
-        }
-        if (runText) {
-            runs.push({
-                r,
-                text: runText,
-                isFieldResult: sawResult,
-                fieldResultId: runFieldResultId ?? null,
-            });
-        }
-    }
-    return runs.map((run) => ({
-        ...run,
-        fieldInstruction: run.fieldResultId === null
-            ? null
-            : (fieldInstructions.get(run.fieldResultId) ?? null),
+    return buildParagraphIndex(p).runs
+        .filter((run) => run.visibleText.length > 0)
+        .map((run) => ({
+        r: run.element,
+        text: run.visibleText,
+        isFieldResult: run.isFieldResult,
+        fieldResultId: run.fieldResultId,
+        fieldInstruction: run.fieldInstruction,
     }));
 }
 export function getParagraphText(p) {
@@ -172,14 +96,19 @@ function cloneRPrWithoutChangeRecords(doc, rPr) {
     }
     return clone;
 }
-function appendTextToRun(doc, run, text) {
+function appendTextToRun(doc, run, text, preserveXmlSpace = false) {
     // Convert \t and \n to OOXML equivalents where possible.
     let buf = '';
     const flush = () => {
         if (!buf)
             return;
         const t = doc.createElementNS(OOXML.W_NS, 'w:t');
-        setXmlSpacePreserveIfNeeded(t, buf);
+        if (preserveXmlSpace) {
+            t.setAttributeNS('http://www.w3.org/XML/1998/namespace', 'xml:space', 'preserve');
+        }
+        else {
+            setXmlSpacePreserveIfNeeded(t, buf);
+        }
         t.appendChild(doc.createTextNode(buf));
         run.appendChild(t);
         buf = '';
@@ -226,7 +155,7 @@ export function getDirectContentElements(run) {
     }
     return out;
 }
-export function splitRunAtVisibleOffset(run, offset) {
+export function splitRunAtVisibleOffset(run, offset, zeroLengthAtOffset = 'right') {
     const doc = run.ownerDocument;
     if (!doc)
         throw new Error('Run has no ownerDocument');
@@ -244,8 +173,9 @@ export function splitRunAtVisibleOffset(run, offset) {
         const len = visibleLengthForEl(lEl);
         if (len === 0) {
             // Zero-length nodes (proofing, field markers, etc.) should not be duplicated. Keep them on the side
-            // determined by the current visible position.
-            if (pos < offset)
+            // determined by the current visible position; a node exactly at the offset goes to the caller's side.
+            const keepLeft = pos < offset || (pos === offset && zeroLengthAtOffset === 'left');
+            if (keepLeft)
                 rEl.parentNode?.removeChild(rEl);
             else
                 lEl.parentNode?.removeChild(lEl);
@@ -312,17 +242,100 @@ function cleanupEmptyRuns(parent) {
 function getRunVisibleLength(run) {
     return getDirectContentElements(run).reduce((sum, child) => sum + visibleLengthForEl(child), 0);
 }
-// OOXML embedded run content that references package parts: DrawingML drawing
-// (w:drawing), VML picture (w:pict), embedded OLE object (w:object), and
-// imported content part (w:contentPart, a CT_Rel relationship reference).
-// These carry no visible text length, so a caller-approved text match never
-// covers them — a text replacement must not destroy them (issue #739).
+/** True when the run's first direct content element carries no visible length. */
+function runStartsWithZeroLengthContent(run) {
+    const first = getDirectContentElements(run)[0];
+    return first !== undefined && visibleLengthForEl(first) === 0;
+}
+/** True when the run's last direct content element carries no visible length. */
+function runEndsWithZeroLengthContent(run) {
+    const last = getDirectContentElements(run).at(-1);
+    return last !== undefined && visibleLengthForEl(last) === 0;
+}
+/**
+ * Zero-visible-length run content that a replaced range deletes with the
+ * surrounding text: a `w:sym` symbol character (issue #1044), the
+ * `w:fldChar` / `w:instrText` markers of a complex field whose markers sit
+ * inside the range (issue #1082: a result-less field such as an `XE` index
+ * entry or a `TC` entry — begin, instruction, end, no `separate`), and a
+ * footnote or endnote reference mark (issue #1094). A field whose cached
+ * result is empty (begin, instruction, separate, end) is also zero-length and
+ * is handled the same way. A field with a non-empty cached result never
+ * reaches here with its markers in range: the range would include the result
+ * text, and that edit is refused earlier.
+ *
+ * A note reference is deleted with the text, as Word does when a tracked
+ * deletion covers it, rather than kept live like a comment reference: the
+ * comment's range markers stay live around the edit, so its reference must
+ * too (issue #1083), whereas a note is anchored only by its reference, and a
+ * caller replacing the text around it has covered it.
+ */
+const DELETABLE_ZERO_LENGTH_LOCALS = new Set([
+    SYM_LOCAL_NAME,
+    W.fldChar,
+    W.instrText,
+    W.footnoteReference,
+    W.endnoteReference,
+]);
+/**
+ * True when a run removed from a replaced range must be kept for `w:del`
+ * wrapping. Visible text qualifies, and so does zero-length content the range
+ * deletes with the text. A `w:sym` symbol character (a Wingdings checkbox, a
+ * bullet) is run content that Word renders as a character, but it contributes
+ * no visible length in the paragraph text coordinate space, so the length test
+ * alone let a sym-only run be detached and never recorded — an untracked
+ * deletion inside a tracked edit (issue #1044). Complex field markers
+ * (`w:fldChar`, `w:instrText`) had the same defect (issue #1082): a run
+ * holding only a marker was dropped, so reject-all could not restore the
+ * field. Recording the run puts it in the same `w:del` as the surrounding
+ * text, so accept-all removes it with the text and reject-all restores it in
+ * place; the emitter renames a deleted `w:instrText` to `w:delInstrText`.
+ * A footnote or endnote reference mark alone in a run — the shape Word
+ * writes, with `w:rStyle` FootnoteReference — was dropped the same way
+ * (issue #1094); it now joins the `w:del` so reject-all restores the note.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.3.3.30
+ * @conformance ECMA-376 edition 5, Part 1 § 17.16.18
+ * @conformance ECMA-376 edition 5, Part 1 § 17.11.14
+ * @conformance ECMA-376 edition 5, Part 1 § 17.13.5.14
+ * @see https://github.com/UseJunior/safe-docx/issues/1044
+ * @see https://github.com/UseJunior/safe-docx/issues/1082
+ * @see https://github.com/UseJunior/safe-docx/issues/1094
+ */
+function runCarriesDeletableContent(run) {
+    if (getRunVisibleLength(run) > 0)
+        return true;
+    return getDirectContentElements(run).some((el) => DELETABLE_ZERO_LENGTH_LOCALS.has(el.localName ?? ''));
+}
+// Run content a text replacement keeps live, in place. OOXML embedded content
+// that references package parts: DrawingML drawing (w:drawing), VML picture
+// (w:pict), embedded OLE object (w:object), and imported content part
+// (w:contentPart, a CT_Rel relationship reference) (issue #739). And a comment
+// anchor's reference mark (w:commentReference): deleting it with the text
+// would leave the comment's live w:commentRangeStart/End without a reference
+// after accept-all, or, when it sat alone in its run, drop it untracked
+// (issue #1083). None of these carry visible text length, so a caller-approved
+// text match never covers them — a text replacement must not destroy them.
 const EMBEDDED_CONTENT_LOCALS = new Set([
     W.drawing,
     W.pict,
     W.object,
     W.contentPart,
+    W.commentReference,
+]);
+const FORMAT_RANGE_CONTENT_LOCALS = new Set([
+    W.t,
+    W.tab,
+    W.br,
+    'lastRenderedPageBreak',
 ]);
+function belongsToParagraph(run, paragraph) {
+    for (let parent = run.parentNode; parent; parent = parent.parentNode) {
+        if (parent.nodeType === 1 && isW(parent, W.p))
+            return parent === paragraph;
+    }
+    return false;
+}
 function isEmbeddedContentElement(node) {
     return (node.nodeType === 1 &&
         node.namespaceURI === OOXML.W_NS &&
@@ -331,6 +344,73 @@ function isEmbeddedContentElement(node) {
 function getEmbeddedContentElements(run) {
     return getDirectContentElements(run).filter((el) => EMBEDDED_CONTENT_LOCALS.has(el.localName ?? ''));
 }
+/**
+ * Change direct run properties over an exact visible-text range while keeping
+ * every character and each touched run's undeclared direct properties.
+ *
+ * The existing bounded replacement engine owns boundary splitting and rejects
+ * unsafe container crossings. This wrapper supplies one text-identical part
+ * per touched run, so harmless physical fragmentation is retained rather than
+ * flattened.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.3.2.28
+ * @see #998
+ */
+export function formatParagraphTextRange(paragraph, start, end, format) {
+    const text = getParagraphText(paragraph);
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end <= start || end > text.length) {
+        throw new SafeDocxError('INVALID_ARGUMENT', 'Formatting range must be a non-empty bounded visible-text interval.');
+    }
+    let physicalOffset = 0;
+    const physicalRuns = Array.from(paragraph.getElementsByTagNameNS(OOXML.W_NS, W.r))
+        .filter((run) => belongsToParagraph(run, paragraph));
+    for (const run of physicalRuns) {
+        const runLength = getRunVisibleLength(run);
+        const intersects = runLength > 0
+            ? physicalOffset < end && physicalOffset + runLength > start
+            : physicalOffset > start && physicalOffset < end;
+        if (intersects) {
+            const content = Array.from(run.childNodes).filter((child) => child.nodeType === 1 && !isW(child, W.rPr));
+            const unsupported = content
+                .filter((element) => element.namespaceURI !== OOXML.W_NS
+                || !FORMAT_RANGE_CONTENT_LOCALS.has(element.localName ?? ''));
+            const isDisposablePaginationCache = content.length > 0
+                && content.every((element) => element.localName === 'lastRenderedPageBreak');
+            if (unsupported.length > 0 || (runLength === 0 && !isDisposablePaginationCache)) {
+                const names = unsupported.length > 0
+                    ? [...new Set(unsupported.map((element) => element.localName))].sort().join(', ')
+                    : 'empty run';
+                throw new SafeDocxError('UNSUPPORTED_EDIT', `Formatting range intersects unsupported run content: ${names}.`);
+            }
+        }
+        physicalOffset += runLength;
+    }
+    const runs = getParagraphRuns(paragraph);
+    const parts = [];
+    let offset = 0;
+    for (const run of runs) {
+        const runStart = offset;
+        const runEnd = offset + run.text.length;
+        offset = runEnd;
+        const overlapStart = Math.max(start, runStart);
+        const overlapEnd = Math.min(end, runEnd);
+        if (overlapEnd <= overlapStart)
+            continue;
+        parts.push({
+            text: text.slice(overlapStart, overlapEnd),
+            templateRun: run.r,
+            preserveXmlSpace: Array.from(run.r.getElementsByTagNameNS(OOXML.W_NS, W.t))
+                .some((node) => node.getAttributeNS('http://www.w3.org/XML/1998/namespace', 'space') === 'preserve'),
+            addRunProps: {
+                ...(format.underline === undefined ? {} : { underline: format.underline === 'none' ? false : format.underline }),
+                ...(format.highlight === undefined ? {} : { highlight: format.highlight === 'none' ? false : format.highlight }),
+            },
+        });
+    }
+    if (parts.length === 0)
+        throw new SafeDocxError('INVALID_ARGUMENT', 'Formatting range does not intersect visible run text.');
+    replaceParagraphTextRange(paragraph, start, end, parts);
+}
 function getDirectChild(parent, localName) {
     for (const child of Array.from(parent.childNodes)) {
         if (child.nodeType !== 1)
@@ -377,6 +457,59 @@ function addParagraphMarkDeletion(p, ctx) {
         rPr.insertBefore(marker, rPr.firstChild);
     }
 }
+/**
+ * True when a blanking edit left nothing in the paragraph that renders or
+ * anchors: only w:pPr, proofing marks, and runs or hyperlinks whose content
+ * was removed. Range markers (bookmarks, comment anchors), embedded content,
+ * and every other child count as content.
+ *
+ * Under tracked changes the blanked text is still in the paragraph, inside
+ * the `w:del` the edit emitted, and accept-all removes it; so with
+ * `deletionsAreInert` a `w:del` (or `w:moveFrom`) counts as nothing, and a
+ * `w:ins` counts as whatever it wraps. The tracked and clean paths then ask
+ * the same question of the same paragraph (issue #1098).
+ */
+function isParagraphInertAfterBlanking(p, deletionsAreInert = false) {
+    const isInert = (el) => {
+        if (isW(el, W.pPr) || isW(el, 'proofErr'))
+            return true;
+        if (deletionsAreInert && (isW(el, W.del) || isW(el, W.moveFrom)))
+            return true;
+        if (isW(el, W.r)) {
+            return Array.from(el.childNodes).every((c) => c.nodeType !== 1 || isW(c, W.rPr));
+        }
+        if (isW(el, W.hyperlink) || (deletionsAreInert && isW(el, 'ins'))) {
+            return Array.from(el.childNodes).every((c) => c.nodeType !== 1 || isInert(c));
+        }
+        return false;
+    };
+    return Array.from(p.childNodes).every((c) => c.nodeType !== 1 || isInert(c));
+}
+/**
+ * Remove a paragraph that an untracked edit has blanked. Untracked mode has no
+ * paragraph-mark revision for a clean save to resolve, so the emptied `w:p`
+ * used to survive with its `w:numPr` and render as a bare list label
+ * (issue #740). Mirrors the outcome of accepting a paragraph-mark deletion,
+ * keeping the tool reference's exclusions: the paragraph stays when it
+ * carries section properties, when its parent needs it to remain structurally
+ * valid (a table cell's only paragraph, a trailing table), or when it still
+ * owns range markers or other non-text content.
+ *
+ * @see https://github.com/UseJunior/safe-docx/issues/740
+ */
+function removeBlankedParagraph(p) {
+    const parent = p.parentNode;
+    if (!parent)
+        return;
+    const pPr = getDirectChild(p, W.pPr);
+    if (pPr && getDirectChild(pPr, W.sectPr))
+        return;
+    if (!isParagraphInertAfterBlanking(p))
+        return;
+    if (!canSafelyRemoveEmptyParagraph(p))
+        return;
+    parent.removeChild(p);
+}
 // OOXML on/off toggle properties (ECMA-376 ST_OnOff). Absence of w:val means
 // "1", and the values "1"/"true"/"on" are equivalent (likewise for the falsy
 // triple). We normalize so semantically-identical inputs hash the same.
@@ -453,12 +586,15 @@ function ensureBoolProp(doc, rPr, localName, val) {
     }
 }
 function ensureUnderline(doc, rPr, val) {
-    let el = getFirstChild(rPr, OOXML.W_NS, W.u);
+    const underlines = Array.from(rPr.childNodes).filter((child) => child.nodeType === 1 && isW(child, W.u));
     if (val === false) {
-        if (el)
-            el.parentNode?.removeChild(el);
+        for (const underline of underlines)
+            underline.parentNode?.removeChild(underline);
         return;
     }
+    let el = underlines[0];
+    for (const duplicate of underlines.slice(1))
+        duplicate.parentNode?.removeChild(duplicate);
     if (!el) {
         el = doc.createElementNS(OOXML.W_NS, `w:${W.u}`);
         rPr.insertBefore(el, rPr.firstChild);
@@ -596,6 +732,16 @@ function getContainerBoundaryError(runs, startRunIdx, endRunIdx, start, end, ful
  * visible text, so no text match ever covers it and no text edit may delete
  * it. Tracked deletions around preserved content are emitted as in-place
  * segments so rejectChanges() restores the original content order exactly.
+ * A comment's reference mark is preserved the same way, and zero-length
+ * sibling markers inside the range (comment range start/end, a result-less
+ * `w:fldSimple`, bookmarks) stay live where they are, with the deletion split
+ * around them, so reject-all equals the original paragraph.
+ *
+ * Blanking the whole paragraph deletes its paragraph mark (tracked) or
+ * removes the paragraph (untracked) only when nothing that renders or
+ * anchors is left: embedded content, a bookmark or a comment range keeps the
+ * paragraph in both modes, so accept-all of the tracked edit equals the
+ * untracked edit and a bookmark never disappears.
  *
  * @conformance ECMA-376 edition 5, Part 1 § 17.13.5.14
  * @conformance ECMA-376 edition 5, Part 1 § 17.13.5.15
@@ -603,6 +749,8 @@ function getContainerBoundaryError(runs, startRunIdx, endRunIdx, start, end, ful
  * @see #652
  * @see #741
  * @see #739
+ * @see #1083
+ * @see #1098
  */
 export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
     // Replace visible text in [start, end) in paragraph by operating on w:t nodes.
@@ -663,33 +811,38 @@ export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
     }
     const parts = typeof replacement === 'string' ? [{ text: replacement }] : replacement;
     // Split boundary runs so we can remove whole runs cleanly.
+    //
+    // Zero-length content at a range boundary — a result-less field's markers,
+    // a note reference, a proofing mark — that shares a run with the matched
+    // text stays outside the range: the caller's match never covered it. So a
+    // boundary run is split even when the range starts at its first visible
+    // character or ends at its last one, whenever zero-length content sits at
+    // that edge, and a split puts content exactly at the offset on the side
+    // away from the range (issue #1096). Only content between the first and
+    // last matched characters is removed with the text (issue #1082).
     let rangeStartRunEl = startRun.r;
     let rangeEndRunEl = endRun.r;
+    const splitStart = (run) => splitRunAtVisibleOffset(run, startOffset, 'left').right;
+    const splitEnd = (run) => splitRunAtVisibleOffset(run, endOffset, 'right').left;
+    const needsStartSplit = startOffset > 0 || runStartsWithZeroLengthContent(startRun.r);
+    const needsEndSplit = endOffset < endRun.text.length || runEndsWithZeroLengthContent(endRun.r);
     if (startRunIdx === endRunIdx) {
         // Single-run replacement: split end first, then start.
-        const runLen = startRun.text.length;
-        if (endOffset < runLen) {
-            const { left } = splitRunAtVisibleOffset(rangeStartRunEl, endOffset);
-            rangeStartRunEl = left;
-            rangeEndRunEl = left;
+        if (needsEndSplit) {
+            rangeStartRunEl = splitEnd(rangeStartRunEl);
+            rangeEndRunEl = rangeStartRunEl;
         }
-        if (startOffset > 0) {
-            const { right } = splitRunAtVisibleOffset(rangeStartRunEl, startOffset);
-            rangeStartRunEl = right;
-            rangeEndRunEl = right;
+        if (needsStartSplit) {
+            rangeStartRunEl = splitStart(rangeStartRunEl);
+            rangeEndRunEl = rangeStartRunEl;
         }
     }
     else {
         // Multi-run replacement: split start then end.
-        if (startOffset > 0) {
-            const { right } = splitRunAtVisibleOffset(rangeStartRunEl, startOffset);
-            rangeStartRunEl = right;
-        }
-        const endLen = endRun.text.length;
-        if (endOffset < endLen) {
-            const { left } = splitRunAtVisibleOffset(rangeEndRunEl, endOffset);
-            rangeEndRunEl = left;
-        }
+        if (needsStartSplit)
+            rangeStartRunEl = splitStart(rangeStartRunEl);
+        if (needsEndSplit)
+            rangeEndRunEl = splitEnd(rangeEndRunEl);
     }
     const parent = rangeStartRunEl.parentNode;
     if (!parent)
@@ -717,11 +870,17 @@ export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
     // restore the removed text AFTER the preserved object, permanently
     // reordering content the user never touched. When no embedded content is
     // involved the historical single-deletion emission is kept unchanged.
+    //
+    // Zero-length markers that are siblings of the removed runs — comment range
+    // markers (w:commentRangeStart / w:commentRangeEnd), a result-less
+    // w:fldSimple, bookmarks — are never removed, but a single terminal w:del
+    // would still move the removed text past them, so reject-all would restore
+    // the text on the wrong side of each marker (issue #1083). They take the
+    // in-place segment emission too, and each one closes the open segment.
     let rangeContainsEmbeddedContent = false;
     for (let node = rangeStartRunEl; node; node = node.nextSibling) {
         if (node.nodeType === 1 &&
-            isW(node, W.r) &&
-            getEmbeddedContentElements(node).length > 0) {
+            (!isW(node, W.r) || getEmbeddedContentElements(node).length > 0)) {
             rangeContainsEmbeddedContent = true;
         }
         if (node === rangeEndRunEl)
@@ -736,7 +895,7 @@ export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
             if (cur.nodeType === 1 && isW(cur, W.r)) {
                 const runEl = cur;
                 runEl.parentNode?.removeChild(runEl);
-                if (getRunVisibleLength(runEl) > 0) {
+                if (runCarriesDeletableContent(runEl)) {
                     removedRuns.push(runEl);
                 }
             }
@@ -754,7 +913,7 @@ export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
             const parentNode = runEl.parentNode;
             if (!parentNode)
                 return;
-            if (ctx && getRunVisibleLength(runEl) > 0) {
+            if (ctx && runCarriesDeletableContent(runEl)) {
                 if (!currentDeletion) {
                     currentDeletion = createRevisionContainer(doc, 'del', ctx);
                     parentNode.insertBefore(currentDeletion, runEl);
@@ -795,15 +954,22 @@ export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
         while (cur) {
             const nextNode = cur.nextSibling;
             const atRangeEnd = cur === rangeEndRunEl;
-            if (cur.nodeType === 1 && isW(cur, W.r)) {
+            if (cur.nodeType === 1 && !isW(cur, W.r)) {
+                // A sibling marker stays where it is; the next removed run opens a
+                // new w:del after it (issue #1083).
+                currentDeletion = null;
+            }
+            else if (cur.nodeType === 1) {
                 const runEl = cur;
                 const embeddedContent = getEmbeddedContentElements(runEl);
                 if (embeddedContent.length === 0) {
                     removeRunInPlace(runEl);
                 }
-                else if (getRunVisibleLength(runEl) === 0) {
+                else if (!runCarriesDeletableContent(runEl)) {
                     // Embedded-only run: the replaced text lives entirely in sibling
-                    // runs. Leave it in the paragraph as-is.
+                    // runs. Leave it in the paragraph as-is. A run that also holds a
+                    // w:sym is mixed, not embedded-only: the split below keeps the
+                    // embedded content live and deletes the symbol with the range.
                     preservedEmbeddedContent = true;
                     currentDeletion = null;
                 }
@@ -837,7 +1003,7 @@ export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
         if (ctx && hasExplicitFormattingMutation && rPrComparableSignature(newRPr) !== sourceRPrSignature) {
             ensureRPr(doc, newRun).appendChild(buildRPrChangeElement(getSnapshotRPr(doc, sourceRPr), ctx));
         }
-        appendTextToRun(doc, newRun, part.text);
+        appendTextToRun(doc, newRun, part.text, part.preserveXmlSpace);
         if (getRunVisibleLength(newRun) > 0) {
             replacementRuns.push(newRun);
         }
@@ -860,8 +1026,16 @@ export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
         // Only delete the paragraph mark when the edit leaves nothing live behind.
         // Preserved embedded content keeps the paragraph meaningful, and merging
         // it into the following paragraph on accept would move the image the user
-        // never touched (issue #739).
-        if (start === 0 && end === fullText.length && replacementRuns.length === 0 && !preservedEmbeddedContent) {
+        // never touched (issue #739). Range markers the paragraph still carries —
+        // a bookmark, a comment anchor — keep it the same way: accepting a
+        // deleted mark would merge the comment's markers into the next paragraph,
+        // or drop a bookmark whose whole content was deleted and with it a
+        // cross-reference target, while the untracked edit below keeps the
+        // paragraph with its markers. Tracked and clean must agree on whether the
+        // paragraph survives, so this asks the same question removeBlankedParagraph
+        // asks (issue #1098).
+        if (start === 0 && end === fullText.length && replacementRuns.length === 0 && !preservedEmbeddedContent &&
+            isParagraphInertAfterBlanking(p, true)) {
             addParagraphMarkDeletion(p, ctx);
         }
     }
@@ -871,5 +1045,11 @@ export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
         }
     }
     cleanupEmptyRuns(parent);
+    // Untracked counterpart of the paragraph-mark deletion above: with no
+    // revision for a clean save to resolve, the emptied paragraph is removed
+    // here so it cannot survive as a bare list label (issue #740).
+    if (!ctx && start === 0 && end === fullText.length && replacementRuns.length === 0 && !preservedEmbeddedContent) {
+        removeBlankedParagraph(p);
+    }
 }
 //# sourceMappingURL=text.js.map