@usejunior/docx-core 0.19.1 → 0.21.2

package/dist/primitives/text.js

@@ -1,61 +1,28 @@
 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
+ * rewrite.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.16.18
+ * @see #651
+ */
 export function getParagraphRuns(p) {
-    let FieldState;
-    (function (FieldState) {
-        FieldState[FieldState["OUTSIDE_FIELD"] = 0] = "OUTSIDE_FIELD";
-        FieldState[FieldState["IN_FIELD_CODE"] = 1] = "IN_FIELD_CODE";
-        FieldState[FieldState["IN_FIELD_RESULT"] = 2] = "IN_FIELD_RESULT";
-    })(FieldState || (FieldState = {}));
-    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));
-    let state = FieldState.OUTSIDE_FIELD;
-    for (const r of rElems) {
-        let runText = '';
-        let sawResult = state === FieldState.IN_FIELD_RESULT;
-        // 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')
-                    state = FieldState.IN_FIELD_CODE;
-                else if (typ === 'separate')
-                    state = FieldState.IN_FIELD_RESULT;
-                else if (typ === 'end')
-                    state = FieldState.OUTSIDE_FIELD;
-                continue;
-            }
-            if (state === FieldState.IN_FIELD_CODE) {
-                // Skip field code/instruction text.
-                continue;
-            }
-            if (state === FieldState.IN_FIELD_RESULT)
-                sawResult = true;
-            if (el.localName === W.t) {
-                runText += el.textContent ?? '';
-            }
-            else if (el.localName === W.tab) {
-                runText += '\t';
-            }
-            else if (el.localName === W.br) {
-                runText += '\n';
-            }
-        }
-        if (runText)
-            runs.push({ r, text: runText, isFieldResult: sawResult });
-    }
-    return runs;
+    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) {
     return getParagraphRuns(p)
@@ -71,16 +38,24 @@ function findOffsetInRuns(runs, start, end) {
     let endOffset = 0;
     for (let i = 0; i < runs.length; i++) {
         const len = runs[i].text.length;
-        if (startRunIdx === -1 && start >= pos && start <= pos + len) {
+        const nextPos = pos + len;
+        const startIsInRun = start === end
+            ? start <= nextPos
+            : start < nextPos;
+        if (startRunIdx === -1 && start >= pos && startIsInRun) {
             startRunIdx = i;
             startOffset = start - pos;
         }
-        if (endRunIdx === -1 && end >= pos && end <= pos + len) {
+        if (endRunIdx === -1 && end > pos && end <= nextPos) {
             endRunIdx = i;
             endOffset = end - pos;
             break;
         }
-        pos += len;
+        pos = nextPos;
+    }
+    if (start === end && startRunIdx !== -1) {
+        endRunIdx = startRunIdx;
+        endOffset = startOffset;
     }
     if (startRunIdx === -1 || endRunIdx === -1) {
         throw new Error('Offset mapping failed');
@@ -121,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 = '';
@@ -175,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');
@@ -193,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);
@@ -261,6 +242,175 @@ function cleanupEmptyRuns(parent) {
 function getRunVisibleLength(run) {
     return getDirectContentElements(run).reduce((sum, child) => sum + visibleLengthForEl(child), 0);
 }
+/** 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 &&
+        EMBEDDED_CONTENT_LOCALS.has(node.localName ?? ''));
+}
+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)
@@ -271,6 +421,95 @@ function getDirectChild(parent, localName) {
     }
     return null;
 }
+/**
+ * Mark the paragraph mark as deleted when a tracked edit removes the
+ * paragraph's entire visible payload. The marker belongs in w:pPr/w:rPr;
+ * accepting it removes the paragraph break while the run-level w:del removes
+ * the old contents.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.13.5.15
+ * @see https://github.com/UseJunior/safe-docx/issues/741
+ */
+function addParagraphMarkDeletion(p, ctx) {
+    const doc = p.ownerDocument;
+    if (!doc)
+        throw new Error('Paragraph has no ownerDocument');
+    let pPr = getDirectChild(p, W.pPr);
+    if (!pPr) {
+        pPr = doc.createElementNS(OOXML.W_NS, `w:${W.pPr}`);
+        p.insertBefore(pPr, p.firstChild);
+    }
+    let rPr = getDirectChild(pPr, W.rPr);
+    if (!rPr) {
+        rPr = doc.createElementNS(OOXML.W_NS, `w:${W.rPr}`);
+        const sectPr = getDirectChild(pPr, 'sectPr');
+        const pPrChange = getDirectChild(pPr, 'pPrChange');
+        pPr.insertBefore(rPr, sectPr ?? pPrChange);
+    }
+    if (getDirectChild(rPr, 'del'))
+        return;
+    const marker = createRevisionContainer(doc, 'del', ctx);
+    const insertionMarker = getDirectChild(rPr, 'ins');
+    if (insertionMarker) {
+        rPr.insertBefore(marker, insertionMarker.nextSibling);
+    }
+    else {
+        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.
@@ -347,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);
@@ -428,6 +670,88 @@ function applyRunProps(doc, run, add, clearHighlight) {
     if (add.fontName !== undefined)
         ensureFont(doc, rPr, add.fontName);
 }
+function describeRunContainer(node) {
+    if (node.nodeType !== 1)
+        return node.nodeName;
+    const el = node;
+    if (el.namespaceURI === OOXML.W_NS)
+        return `w:${el.localName}`;
+    return el.tagName;
+}
+function previewContainerText(text, start, end) {
+    const value = text.slice(start, end);
+    return value.length <= 120 ? value : `${value.slice(0, 117)}...`;
+}
+function getContainerBoundaryError(runs, startRunIdx, endRunIdx, start, end, fullText) {
+    const segments = [];
+    let runStart = 0;
+    for (let i = 0; i < runs.length; i++) {
+        const run = runs[i];
+        const runEnd = runStart + run.text.length;
+        if (i >= startRunIdx && i <= endRunIdx) {
+            const overlapStart = Math.max(start, runStart);
+            const overlapEnd = Math.min(end, runEnd);
+            if (overlapEnd > overlapStart) {
+                const parent = run.r.parentNode;
+                if (!parent)
+                    throw new Error('Run has no parent');
+                const previous = segments.at(-1);
+                if (previous?.parent === parent && previous.end === overlapStart) {
+                    previous.end = overlapEnd;
+                }
+                else {
+                    segments.push({ parent, start: overlapStart, end: overlapEnd });
+                }
+            }
+        }
+        runStart = runEnd;
+    }
+    if (segments.length <= 1)
+        return null;
+    const first = segments[0];
+    const second = segments[1];
+    const largest = segments.reduce((best, segment) => segment.end - segment.start > best.end - best.start ? segment : best);
+    const boundaryOffset = first.end;
+    const firstContainer = describeRunContainer(first.parent);
+    const secondContainer = describeRunContainer(second.parent);
+    const largestContainer = describeRunContainer(largest.parent);
+    const preview = previewContainerText(fullText, largest.start, largest.end);
+    return new SafeDocxError('UNSAFE_CONTAINER_BOUNDARY', `Edit range [${start}, ${end}) crosses a container boundary at offset ${boundaryOffset} ` +
+        `(${firstContainer} → ${secondContainer}). Largest contained sub-span: ` +
+        `[${largest.start}, ${largest.end}) in ${largestContainer}, ${JSON.stringify(preview)}.`, `Retry with old_string limited to one container, such as the text in range ` +
+        `[${largest.start}, ${largest.end}), or make separate edits on each side of offset ${boundaryOffset}.`);
+}
+/**
+ * Replace a visible paragraph range while keeping tracked runs inside their
+ * existing run container. In particular, edits wholly inside `w:hyperlink`
+ * remain nested there, while cross-container ranges are refused before the
+ * DOM is changed.
+ *
+ * Embedded content (`w:drawing`, `w:pict`, `w:object`, `w:contentPart`)
+ * inside the replaced range is preserved as live runs: it contributes no
+ * 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
+ * @conformance ECMA-376 edition 5, Part 1 § 17.16.22
+ * @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.
     // Strategy:
@@ -447,12 +771,29 @@ export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
     const { startRunIdx, startOffset, endRunIdx, endOffset } = findOffsetInRuns(runs, start, end);
     const startRun = runs[startRunIdx];
     const endRun = runs[endRunIdx];
-    // For now we only support field edits that stay within a single visible run.
-    if (startRunIdx !== endRunIdx) {
-        for (let i = startRunIdx; i <= endRunIdx; i++) {
-            if (runs[i]?.isFieldResult) {
-                throw new SafeDocxError('UNSUPPORTED_EDIT', 'Edit spans multiple runs and intersects a field result. This is currently unsupported in Safe-Docx TS.', 'Narrow old_string so the edit does not cross a field, or edit the field result text in a smaller span.');
-            }
+    const containerBoundaryError = getContainerBoundaryError(runs, startRunIdx, endRunIdx, start, end, fullText);
+    if (containerBoundaryError)
+        throw containerBoundaryError;
+    // A cached result may span many runs, but every touched run must belong to
+    // the same complex field. Moving ordinary text, a field marker, or another
+    // field's result across a fldChar boundary would change document semantics.
+    const spanRuns = runs.slice(startRunIdx, endRunIdx + 1);
+    const fieldRuns = spanRuns.filter((run) => run.isFieldResult);
+    if (fieldRuns.length > 0) {
+        const fieldIds = new Set(fieldRuns.map((run) => run.fieldResultId));
+        const containsInlineFieldMarker = fieldRuns.some((run) => getDirectContentElements(run.r).some((el) => isW(el, W.fldChar)));
+        const isOneCompleteResultSpan = fieldRuns.length === spanRuns.length &&
+            [...fieldIds].every((fieldId) => typeof fieldId === 'number') &&
+            fieldIds.size === 1 &&
+            !containsInlineFieldMarker;
+        if (!isOneCompleteResultSpan) {
+            const instructions = new Set(fieldRuns
+                .map((run) => run.fieldInstruction?.split(/\s+/u)[0])
+                .filter((instruction) => !!instruction));
+            const fieldLabel = instructions.size === 1
+                ? `${[...instructions][0]} field result`
+                : 'complex field result';
+            throw new SafeDocxError('UNSUPPORTED_EDIT', `Edit crosses the boundary of a ${fieldLabel}; cached-result edits must stay inside one field.`, 'Narrow old_string so the changed range is entirely inside one cached field result.');
         }
     }
     // Pick a template run from the span: the run with the largest overlap by visible character count.
@@ -470,56 +811,184 @@ 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)
         throw new Error('Run has no parent');
     if (rangeEndRunEl.parentNode !== parent) {
-        throw new SafeDocxError('UNSAFE_CONTAINER_BOUNDARY', 'Edit crosses container boundaries (e.g. hyperlinks/SDTs).', 'Narrow old_string so the match is contained within a single container, or avoid editing inside hyperlinks.');
+        throw new Error('Container boundary changed while splitting replacement runs');
     }
     const insertBeforeNode = rangeEndRunEl.nextSibling;
     // Remove runs in [rangeStartRunEl, rangeEndRunEl] inclusive (only w:r elements).
+    //
+    // Embedded content (w:drawing / w:pict / w:object / w:contentPart) has zero
+    // visible text length, so the text match the caller approved never covered
+    // it. It must survive the replacement as live content (issue #739): an
+    // embedded-only run stays in place untouched, and embedded content
+    // co-resident with replaced text is split into its own run at the same
+    // relative position before the text is removed. Without this, an
+    // embedded-only run would be detached here but never recorded
+    // (getRunVisibleLength returns 0 for it), so neither the tracked nor the
+    // clean branch could re-emit it.
+    //
+    // When embedded content is preserved, tracked deletions are emitted as
+    // IN-PLACE SEGMENTS — one w:del per contiguous stretch of removed text,
+    // inserted at that stretch's original position — instead of one terminal
+    // w:del after the range. A single terminal w:del would make rejectChanges()
+    // 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)) {
+            rangeContainsEmbeddedContent = true;
+        }
+        if (node === rangeEndRunEl)
+            break;
+    }
     const removedRuns = [];
-    let cur = rangeStartRunEl;
-    while (cur) {
-        const nextNode = cur.nextSibling;
-        if (cur.nodeType === 1 && isW(cur, W.r)) {
-            const runEl = cur;
-            runEl.parentNode?.removeChild(runEl);
-            if (getRunVisibleLength(runEl) > 0) {
-                removedRuns.push(runEl);
+    let preservedEmbeddedContent = false;
+    if (!rangeContainsEmbeddedContent) {
+        let cur = rangeStartRunEl;
+        while (cur) {
+            const nextNode = cur.nextSibling;
+            if (cur.nodeType === 1 && isW(cur, W.r)) {
+                const runEl = cur;
+                runEl.parentNode?.removeChild(runEl);
+                if (runCarriesDeletableContent(runEl)) {
+                    removedRuns.push(runEl);
+                }
             }
+            if (cur === rangeEndRunEl)
+                break;
+            cur = nextNode;
+        }
+    }
+    else {
+        // The open deletion segment; reset to null whenever preserved embedded
+        // content interrupts the removed stretch so the next removed run starts
+        // a new w:del at its own position.
+        let currentDeletion = null;
+        const removeRunInPlace = (runEl) => {
+            const parentNode = runEl.parentNode;
+            if (!parentNode)
+                return;
+            if (ctx && runCarriesDeletableContent(runEl)) {
+                if (!currentDeletion) {
+                    currentDeletion = createRevisionContainer(doc, 'del', ctx);
+                    parentNode.insertBefore(currentDeletion, runEl);
+                }
+                parentNode.removeChild(runEl);
+                currentDeletion.appendChild(prepareElementForDeletion(runEl));
+            }
+            else {
+                parentNode.removeChild(runEl);
+            }
+        };
+        // Split a run holding both text and embedded content into consecutive
+        // homogeneous runs (formatting cloned), inserted at the run's position in
+        // original child order, so both the preserved content and the removed
+        // text keep their exact relative positions.
+        const splitMixedRun = (runEl) => {
+            const parentNode = runEl.parentNode;
+            if (!parentNode)
+                throw new Error('Run has no parent');
+            const pieces = [];
+            let currentPiece = null;
+            for (const child of Array.from(runEl.childNodes)) {
+                if (child.nodeType === 1 && isW(child, W.rPr))
+                    continue;
+                const embedded = isEmbeddedContentElement(child);
+                if (!currentPiece || currentPiece.embedded !== embedded) {
+                    currentPiece = { el: cloneRunFormattingOnly(doc, runEl), embedded };
+                    pieces.push(currentPiece);
+                }
+                currentPiece.el.appendChild(child);
+            }
+            for (const piece of pieces)
+                parentNode.insertBefore(piece.el, runEl);
+            parentNode.removeChild(runEl);
+            return pieces;
+        };
+        let cur = rangeStartRunEl;
+        while (cur) {
+            const nextNode = cur.nextSibling;
+            const atRangeEnd = cur === rangeEndRunEl;
+            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 (!runCarriesDeletableContent(runEl)) {
+                    // Embedded-only run: the replaced text lives entirely in sibling
+                    // 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;
+                }
+                else {
+                    for (const piece of splitMixedRun(runEl)) {
+                        if (piece.embedded) {
+                            preservedEmbeddedContent = true;
+                            currentDeletion = null;
+                        }
+                        else {
+                            removeRunInPlace(piece.el);
+                        }
+                    }
+                }
+            }
+            if (atRangeEnd)
+                break;
+            cur = nextNode;
         }
-        if (cur === rangeEndRunEl)
-            break;
-        cur = nextNode;
     }
     // Build replacement runs using the same formatting/template logic as the legacy path.
     const replacementRuns = [];
@@ -534,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);
         }
@@ -554,6 +1023,21 @@ export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
             }
             parent.insertBefore(insertion, insertBeforeNode);
         }
+        // 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). 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);
+        }
     }
     else {
         for (const replacementRun of replacementRuns) {
@@ -561,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