@usejunior/docx-core 0.19.1 → 0.20.1

package/dist/primitives/text.d.ts

@@ -3,7 +3,17 @@ export type TextRun = {
     r: Element;
     text: string;
     isFieldResult: boolean;
+    fieldResultId?: number | null;
+    fieldInstruction?: string | null;
 };
+/**
+ * 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 declare function getParagraphRuns(p: Element): TextRun[];
 export declare function getParagraphText(p: Element): string;
 export declare function visibleLengthForEl(el: Element): number;
@@ -27,5 +37,24 @@ export type ReplacementPart = {
     addRunProps?: AddRunProps;
     clearHighlight?: boolean;
 };
+/**
+ * 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.
+ *
+ * @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
+ */
 export declare function replaceParagraphTextRange(p: Element, start: number, end: number, replacement: string | ReplacementPart[], ctx?: RevisionContext): void;
 //# sourceMappingURL=text.d.ts.map

package/dist/primitives/text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/primitives/text.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,MAAM,OAAO,GAAG;IACpB,CAAC,EAAE,OAAO,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,EAAE,CAsDtD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAInD;AAoGD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,CAMtD;AAED,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,EAAE,CAWhE;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAgEvG;AA0BD,MAAM,MAAM,WAAW,GAAG;IAGxB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7B,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AA2KF,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,OAAO,EACV,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,GAAG,eAAe,EAAE,EACvC,GAAG,CAAC,EAAE,eAAe,GACpB,IAAI,CAsJN"}
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/primitives/text.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,eAAe,EACrB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,MAAM,OAAO,GAAG;IACpB,CAAC,EAAE,OAAO,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,EAAE,CAqGtD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAInD;AA6GD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,CAMtD;AAED,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,EAAE,CAWhE;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAgEvG;AAkDD,MAAM,MAAM,WAAW,GAAG;IAGxB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7B,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAyRF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,OAAO,EACV,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,GAAG,eAAe,EAAE,EACvC,GAAG,CAAC,EAAE,eAAe,GACpB,IAAI,CAkSN"}

package/dist/primitives/text.js

@@ -2,22 +2,45 @@ import { OOXML, W } from './namespaces.js';
 import { SafeDocxError } from './errors.js';
 import { getAttributeSafe, getFirstChild } from './xml-helpers.js';
 import { buildRPrChangeElement, createRevisionContainer, prepareElementForDeletion, } from './track-changes-emitter.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 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));
-    let state = FieldState.OUTSIDE_FIELD;
+    const fieldStack = [];
+    const fieldInstructions = new Map();
+    let nextFieldId = 1;
     for (const r of rElems) {
         let runText = '';
-        let sawResult = state === FieldState.IN_FIELD_RESULT;
+        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)) {
@@ -28,34 +51,54 @@ export function getParagraphRuns(p) {
                 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;
+                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;
             }
-            if (state === FieldState.IN_FIELD_CODE) {
+            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 (state === FieldState.IN_FIELD_RESULT)
-                sawResult = true;
             if (el.localName === W.t) {
-                runText += el.textContent ?? '';
+                appendVisibleText(el.textContent ?? '');
             }
             else if (el.localName === W.tab) {
-                runText += '\t';
+                appendVisibleText('\t');
             }
             else if (el.localName === W.br) {
-                runText += '\n';
+                appendVisibleText('\n');
             }
         }
-        if (runText)
-            runs.push({ r, text: runText, isFieldResult: sawResult });
+        if (runText) {
+            runs.push({
+                r,
+                text: runText,
+                isFieldResult: sawResult,
+                fieldResultId: runFieldResultId ?? null,
+            });
+        }
     }
-    return runs;
+    return runs.map((run) => ({
+        ...run,
+        fieldInstruction: run.fieldResultId === null
+            ? null
+            : (fieldInstructions.get(run.fieldResultId) ?? null),
+    }));
 }
 export function getParagraphText(p) {
     return getParagraphRuns(p)
@@ -71,16 +114,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');
@@ -261,6 +312,25 @@ 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).
+const EMBEDDED_CONTENT_LOCALS = new Set([
+    W.drawing,
+    W.pict,
+    W.object,
+    W.contentPart,
+]);
+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 ?? ''));
+}
 function getDirectChild(parent, localName) {
     for (const child of Array.from(parent.childNodes)) {
         if (child.nodeType !== 1)
@@ -271,6 +341,42 @@ 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);
+    }
+}
 // 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.
@@ -428,6 +534,76 @@ 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.
+ *
+ * @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
+ */
 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 +623,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.
@@ -502,24 +695,134 @@ export function replaceParagraphTextRange(p, start, end, replacement, ctx) {
     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.
+    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 (getRunVisibleLength(runEl) > 0) {
+                    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 && getRunVisibleLength(runEl) > 0) {
+                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)) {
+                const runEl = cur;
+                const embeddedContent = getEmbeddedContentElements(runEl);
+                if (embeddedContent.length === 0) {
+                    removeRunInPlace(runEl);
+                }
+                else if (getRunVisibleLength(runEl) === 0) {
+                    // Embedded-only run: the replaced text lives entirely in sibling
+                    // runs. Leave it in the paragraph as-is.
+                    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 = [];
@@ -554,6 +857,13 @@ 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).
+        if (start === 0 && end === fullText.length && replacementRuns.length === 0 && !preservedEmbeddedContent) {
+            addParagraphMarkDeletion(p, ctx);
+        }
     }
     else {
         for (const replacementRun of replacementRuns) {