@docx4j/core-ts 0.3.0 → 0.3.1

package/dist/model/content/Paragraph.mjs

@@ -19,7 +19,7 @@ import { controlIdScope, sdtKindFor } from '../customxml/insert.mjs';
 import { InlinePicture, addImage, writableWidthEmu } from './InlinePicture.mjs';
 import { contentOf } from './ooxml.mjs';
 import { commentApi } from './comments.mjs';
-import { ChangeTracker, copyRPr, markDeleted, toDeletedText, highestAnnotationId, canonical, restorePPr } from './tracking.mjs';
+import { ChangeTracker, copyRPr, markDeleted, toDeletedText, highestAnnotationId, canonical, restorePPr, wrapInsertedRuns, markHolderInserted } from './tracking.mjs';
 import { trackedChangesOfParagraph } from './TrackedChange.mjs';
 import { isListItem, listOf, listOrNullObjectOf, listItemOf, listItemOrNullObjectOf, startNewList, attachToList, detachFromList, } from './List.mjs';
 const TWIPS_PER_POINT = 20;
@@ -152,10 +152,28 @@ export class Paragraph {
         const val = v === 'Left' ? 'left' : v === 'Centered' ? 'center' : v === 'Right' ? 'right' : v === 'Justified' ? 'both' : undefined;
         if (val === undefined)
             delete pPr.jc;
+        else if (this.inheritedAlignment() === v)
+            delete pPr.jc;
         else
             pPr.jc = { val };
         this.settleFormatting();
     }
+    /**
+     * The alignment the paragraph resolves to with no `w:jc` of its own: its style's, else the
+     * defaults'. Word's Ctrl+L on a centred paragraph whose style is left-aligned removes the `w:jc`
+     * rather than writing `w:jc="left"`, with tracking on (check 26) and off (the editor's
+     * `measure-word2010.docx` and `measure-word15.docx`, 2026-09-30; CR-002 section 38), so a value the
+     * paragraph already inherits is not written. Measured for left over a left-aligned style; taken to
+     * hold for any value. Undefined without a resolver, where the value is written as asked.
+     */
+    inheritedAlignment() {
+        var _a;
+        const resolver = (_a = this.parentBody.package_) === null || _a === void 0 ? void 0 : _a.propertyResolverOrUndefined;
+        if (!resolver)
+            return undefined;
+        const { jc: _jc, pPrChange: _change, PARENT: _parent, ...rest } = this.p.pPr;
+        return alignmentOf(resolver.getEffectivePPr(rest), true);
+    }
     /** Indents and spacing in points, as Office JS; the effective values (CR-001 Phase B step 2). */
     get leftIndent() { var _a, _b; return ((_b = (_a = this.effectivePPr.ind) === null || _a === void 0 ? void 0 : _a.left) !== null && _b !== void 0 ? _b : 0) / TWIPS_PER_POINT; }
     set leftIndent(pt) { this.ind().left = Math.round(pt * TWIPS_PER_POINT); this.settleFormatting(); }
@@ -408,6 +426,42 @@ export class Paragraph {
             return;
         }
         tracker.markParagraphDeleted(this.p);
+        this.giveMarkPropertiesToNext(tracker);
+    }
+    /**
+     * A paragraph mark deleted under tracking gives the next paragraph this paragraph's properties,
+     * as a `w:pPrChange` on it recording its own: Word, at Delete at the end of a Heading 2 with a
+     * Normal paragraph after it, wrote the next paragraph `w:pStyle Heading2` with
+     * `<w:pPrChange><w:pPr/></w:pPrChange>`, and No Markup reads the joined line as a heading
+     * throughout (the editor's `measure-word15.docx`, 2026-09-30; CR-002 section 38). The Delete
+     * counterpart of check 29's Enter. Nothing where the two paragraphs' properties are the same
+     * (check 22's deleted marks). Accepting the mark then joins into a paragraph with these
+     * properties, and rejecting puts the next paragraph's back.
+     */
+    giveMarkPropertiesToNext(tracker) {
+        const i = this.index;
+        const next = i >= 0 ? this.container[i + 1] : undefined;
+        if (!next || typeNameOf(next) !== 'org_docx4j_wml.P')
+            return;
+        const base = (pPr) => {
+            const out = {};
+            for (const [key, value] of Object.entries(pPr !== null && pPr !== void 0 ? pPr : {})) {
+                if (key !== 'TYPE_NAME' && key !== 'PARENT' && key !== 'rPr' && key !== 'sectPr' && key !== 'pPrChange' && value !== undefined)
+                    out[key] = value;
+            }
+            return out;
+        };
+        const source = base(this.p.pPr);
+        const nextP = next.value;
+        if (canonical(source) === canonical(base(nextP.pPr)))
+            return;
+        const target = new Paragraph(next, this.container, this.parentBody).pPr();
+        tracker.recordPPrChange(target);
+        for (const key of Object.keys(base(target)))
+            delete target[key];
+        for (const [key, value] of Object.entries(source))
+            target[key] = deepCopy(value);
+        linkParents(target, nextP);
     }
     /**
      * The paragraph's content and its mark marked deleted, the paragraph element itself kept:
@@ -533,7 +587,7 @@ export class Paragraph {
      * is removed, a run left empty is removed. Text is inserted into the w:t at `start`,
      * else into a new run with the formatting of the nearest run.
      */
-    splice(start, end, text) {
+    splice(start, end, text, prefer = 'before') {
         var _a, _b, _c, _d, _e, _f;
         var _g;
         const length = this.text.length;
@@ -544,7 +598,7 @@ export class Paragraph {
             // a replacement is the w:del first and the w:ins after it, as Word writes one
             const deletions = end > start ? this.deleteText(tracker, start, end) : [];
             if (text.length > 0)
-                this.insertTracked(tracker, start, text, deletions[deletions.length - 1]);
+                this.insertTracked(tracker, start, text, deletions[deletions.length - 1], prefer);
             return new Range(this, start, start + text.length);
         }
         let segs = this.segments();
@@ -602,8 +656,12 @@ export class Paragraph {
             }
             const ending = segs.find((s) => s.editable && s.end === start);
             const starting = segs.find((s) => s.editable && s.start === start);
-            const target = (_d = (_c = (_b = (containing && !containing.revision ? containing : undefined)) !== null && _b !== void 0 ? _b : (ending && !ending.revision ? ending : undefined)) !== null && _c !== void 0 ? _c : (starting && !starting.revision ? starting : undefined)) !== null && _d !== void 0 ? _d : containing; // a revision that could not be split: extended, as before
-            const edge = target ? undefined : ending !== null && ending !== void 0 ? ending : starting;
+            // `prefer` says which run takes text put exactly between two: the one ending there (typed text,
+            // `Paragraph.insertText`) or the one starting there (`Range.insertText('Before')`, which Office
+            // JS puts inside the link the range is on: check 32)
+            const [near, far] = prefer === 'after' ? [starting, ending] : [ending, starting];
+            const target = (_d = (_c = (_b = (containing && !containing.revision ? containing : undefined)) !== null && _b !== void 0 ? _b : (near && !near.revision ? near : undefined)) !== null && _c !== void 0 ? _c : (far && !far.revision ? far : undefined)) !== null && _d !== void 0 ? _d : containing; // a revision that could not be split: extended, as before
+            const edge = target ? undefined : near !== null && near !== void 0 ? near : far;
             if (edge === null || edge === void 0 ? void 0 : edge.revision) {
                 const run = runOf([textItem(text)], copyRPr(edge.run.rPr));
                 this.insertBesideRevision(edge.revision, run, edge === ending ? 'after' : 'before');
@@ -618,11 +676,11 @@ export class Paragraph {
                 // no w:t to extend: a new run next to the segment at `start`, with that run's formatting
                 const before = [...segs].reverse().find((s) => s.end <= start);
                 const after = segs.find((s) => s.start >= start);
-                const neighbour = before !== null && before !== void 0 ? before : after;
+                const neighbour = prefer === 'after' ? after !== null && after !== void 0 ? after : before : before !== null && before !== void 0 ? before : after;
                 const firstRun = (_e = runsOf(this.p)[0]) === null || _e === void 0 ? void 0 : _e.value.rPr;
                 const rPr = (neighbour === null || neighbour === void 0 ? void 0 : neighbour.run.rPr) ? deepCopy(neighbour.run.rPr) : firstRun ? deepCopy(firstRun) : undefined;
                 const run = runOf([textItem(text)], rPr);
-                if (before)
+                if (neighbour === before && before)
                     before.runOwner.splice(before.runIndex + 1, 0, run);
                 else if (after)
                     after.runOwner.splice(after.runIndex, 0, run);
@@ -643,19 +701,33 @@ export class Paragraph {
      * run there when the offset falls inside one. PARENT is linked on what is inserted.
      */
     insertItemsAt(offset, items) {
-        var _a, _b, _c;
-        var _d;
+        var _a, _b, _c, _d;
+        var _e;
         if (items.length === 0)
             return;
+        const tracker = this.changeTracker;
+        if (tracker) {
+            // With tracking on, what goes in is an insertion: its runs in w:ins, in a link, a control or a
+            // field too, placed as typed text is - beside another's revision, or between its halves, never
+            // in it. Before, `insertOoxml` into a paragraph went in untracked (CR-002 section 37).
+            wrapInsertedRuns(tracker, items, this.p);
+            this.splitAt(offset);
+            const segs = this.segments();
+            const before = [...segs].reverse().find((s) => s.end <= offset);
+            const after = segs.find((s) => s.start >= offset);
+            tracker.assertEditable((_a = (before !== null && before !== void 0 ? before : after)) === null || _a === void 0 ? void 0 : _a.revision);
+            this.placeInsertion(offset, items, before, after, () => tracker.nextId());
+            return;
+        }
         this.splitAt(offset);
         const segs = this.segments();
         const after = segs.find((s) => s.start >= offset);
         const before = [...segs].reverse().find((s) => s.end <= offset);
         const neighbour = after !== null && after !== void 0 ? after : before;
-        const list = neighbour ? neighbour.runOwner : ((_a = (_d = this.p).content) !== null && _a !== void 0 ? _a : (_d.content = []));
+        const list = neighbour ? neighbour.runOwner : ((_b = (_e = this.p).content) !== null && _b !== void 0 ? _b : (_e.content = []));
         const at = neighbour ? (after ? neighbour.runIndex : neighbour.runIndex + 1) : (offset === 0 ? 0 : list.length);
         list.splice(at, 0, ...items);
-        const owner = (_c = (_b = neighbour === null || neighbour === void 0 ? void 0 : neighbour.run) === null || _b === void 0 ? void 0 : _b.PARENT) !== null && _c !== void 0 ? _c : this.p;
+        const owner = (_d = (_c = neighbour === null || neighbour === void 0 ? void 0 : neighbour.run) === null || _c === void 0 ? void 0 : _c.PARENT) !== null && _d !== void 0 ? _d : this.p;
         for (const item of items)
             linkParents(item, owner);
     }
@@ -754,6 +826,10 @@ export class Paragraph {
         const sdt = sdtOf([this.element], { kind: sdtKindFor(kind), id: nextSdtId(controlIdScope(this.parentBody)), form: 'block' });
         this.container.splice(at, 1, sdt);
         linkParents(sdt, (_a = this.p.PARENT) !== null && _a !== void 0 ? _a : this.parentBody.container);
+        // under tracking the control itself is the insertion, the paragraph what it was (check 30)
+        const tracker = this.changeTracker;
+        if (tracker)
+            markHolderInserted(tracker, sdt, this.container, () => { });
         return new ContentControl(sdt, this.container, this.parentBody);
     }
     removeEmptyRuns() {
@@ -787,7 +863,7 @@ export class Paragraph {
      * Returns the `w:del` elements it made, in document order.
      */
     deleteText(tracker, start, end) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e;
         const targets = this.isolate(start, end);
         for (const seg of targets)
             tracker.assertEditable(seg.revision);
@@ -833,7 +909,11 @@ export class Paragraph {
             const del = tracker.del(runs);
             owner.splice(at, 0, del);
             linkParents(del, ((_c = (_b = (_a = group[0].revision) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : group[0].run.value.PARENT) !== null && _c !== void 0 ? _c : this.p));
-            made.unshift({ owner, element: del, parent: ((_f = (_e = (_d = group[0].revision) === null || _d === void 0 ? void 0 : _d.value) !== null && _e !== void 0 ? _e : del.value.PARENT) !== null && _f !== void 0 ? _f : this.p) });
+            const revision = group[0].revision;
+            const anchor = { owner, element: del, parent: ((_e = (_d = revision === null || revision === void 0 ? void 0 : revision.value) !== null && _d !== void 0 ? _d : del.value.PARENT) !== null && _e !== void 0 ? _e : this.p) };
+            if (revision && revision.items === owner)
+                anchor.revision = revision;
+            made.unshift(anchor);
         }
         return made;
     }
@@ -846,17 +926,35 @@ export class Paragraph {
      * then does what it did before.
      */
     insertBetweenHalves(at, item, nextId) {
-        var _a;
         this.splitAt(at);
         const after = this.segments().find((s) => s.start >= at && s.revision);
         const holder = after === null || after === void 0 ? void 0 : after.revision;
         const index = holder && after ? holder.items.indexOf(after.runOwner[after.runIndex]) : -1;
         if (!holder || index <= 0)
             return false;
+        return this.splitHolderAround(holder, index, item, nextId);
+    }
+    /**
+     * Moves a revision's items from `index` on into a copy of it - its attributes, a new `w:id` - and
+     * puts `item` between the two; with nothing from `index` on, `item` just goes after the revision.
+     * False, with nothing changed, where the revision's items cannot be told apart from its attributes.
+     * Internal: `Range.insertContentControl` uses it to put a new control between the halves of the
+     * insertion it wraps part of (check 30).
+     */
+    splitHolderAround(holder, index, item, nextId) {
+        var _a;
         const value = holder.value;
         const itemsKey = Object.keys(value).find((key) => value[key] === holder.items);
         if (!itemsKey)
             return false;
+        const parent = (_a = holder.value.PARENT) !== null && _a !== void 0 ? _a : this.p;
+        const at = holder.owner.indexOf(holder.element) + 1;
+        const items = Array.isArray(item) ? item : [item];
+        if (index >= holder.items.length) {
+            holder.owner.splice(at, 0, ...items);
+            linkParents(items, parent);
+            return true;
+        }
         const copy = {};
         for (const [key, v] of Object.entries(value))
             if (key !== itemsKey)
@@ -864,11 +962,9 @@ export class Paragraph {
         copy.id = nextId();
         copy[itemsKey] = holder.items.splice(index);
         const second = { name: holder.element.name, value: copy };
-        const parent = (_a = holder.value.PARENT) !== null && _a !== void 0 ? _a : this.p;
-        const at2 = holder.owner.indexOf(holder.element) + 1;
-        holder.owner.splice(at2, 0, item, second);
+        holder.owner.splice(at, 0, ...items, second);
         linkParents(copy[itemsKey], copy);
-        linkParents([item, second], parent);
+        linkParents([...items, second], parent);
         return true;
     }
     /**
@@ -884,14 +980,16 @@ export class Paragraph {
             while (index > 0 && ((_b = (_a = holder.owner[index - 1]) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.localPart) === marker)
                 index--;
         }
-        holder.owner.splice(index, 0, item);
-        linkParents(item, (_c = holder.value.PARENT) !== null && _c !== void 0 ? _c : this.p);
+        const items = Array.isArray(item) ? item : [item];
+        holder.owner.splice(index, 0, ...items);
+        linkParents(items, (_c = holder.value.PARENT) !== null && _c !== void 0 ? _c : this.p);
     }
     /**
      * A fresh annotation id for markup this paragraph writes itself: the package's counter when there
      * is a package that keeps one, since a document has one id space; else one above every id in the
      * story.
      */
+    /** @internal `Comment` uses it to split an insertion at a comment's end. */
     nextAnnotationId() {
         const pkg = this.parentBody.package_;
         if (pkg && typeof pkg.markupRoots === 'function' && 'annotationIdFloor' in pkg) {
@@ -907,12 +1005,18 @@ export class Paragraph {
      * `w:ins` is extended rather than nested in another one, as Word does. `anchor` is the `w:del`
      * of a replacement, which the insertion must follow.
      */
-    insertTracked(tracker, at, text, anchor) {
-        var _a, _b, _c, _d, _e;
-        var _f;
+    insertTracked(tracker, at, text, anchor, prefer = 'before') {
+        var _a, _b, _c;
         if (anchor) {
             const rPr = copyRPr((_a = runsOf(anchor.element.value, { view: 'original' })[0]) === null || _a === void 0 ? void 0 : _a.value.rPr);
             const ins = tracker.ins([runOf([textItem(text)], rPr)]);
+            // A replacement inside another's revision - an insertion, moved text - leaves its w:del in
+            // that revision; the new text is not put in it too, but the revision split after the deletion
+            // and the text between the halves, as for anything typed in it (check 21; the editor's finding
+            // on 0.3.0, CR-002 section 37).
+            const holder = anchor.revision;
+            if (holder && this.splitHolderAround(holder, holder.items.indexOf(anchor.element) + 1, ins, () => tracker.nextId()))
+                return;
             anchor.owner.splice(anchor.owner.indexOf(anchor.element) + 1, 0, ins);
             linkParents(ins, anchor.parent);
             return;
@@ -921,7 +1025,8 @@ export class Paragraph {
         const segs = this.segments();
         const before = [...segs].reverse().find((s) => s.end <= at);
         const after = segs.find((s) => s.start >= at);
-        for (const [seg, side] of [[before, 'after'], [after, 'before']]) {
+        const sides = [[before, 'after'], [after, 'before']];
+        for (const [seg, side] of prefer === 'after' ? [...sides].reverse() : sides) {
             if (!seg || !tracker.ownInsertion(seg.revision))
                 continue;
             if (seg.editable) {
@@ -935,36 +1040,46 @@ export class Paragraph {
             }
             return;
         }
-        const neighbour = before !== null && before !== void 0 ? before : after;
+        const neighbour = prefer === 'after' ? after !== null && after !== void 0 ? after : before : before !== null && before !== void 0 ? before : after;
         tracker.assertEditable(neighbour === null || neighbour === void 0 ? void 0 : neighbour.revision);
         const rPr = copyRPr((_b = neighbour === null || neighbour === void 0 ? void 0 : neighbour.run.rPr) !== null && _b !== void 0 ? _b : (_c = runsOf(this.p)[0]) === null || _c === void 0 ? void 0 : _c.value.rPr);
         const ins = tracker.ins([runOf([textItem(text)], rPr)]);
+        this.placeInsertion(at, [ins], before, after, () => tracker.nextId(), prefer);
+    }
+    /**
+     * An insertion put at `at`, `before` and `after` being the segments either side of it once the runs
+     * are split there: never inside another's revision.
+     */
+    placeInsertion(at, items, before, after, nextId, prefer = 'before') {
+        var _a, _b;
+        var _c;
         // Typed inside another's revision - a w:ins, a w:moveTo - the revision is split and the typist's
         // w:ins goes between its halves, as Word writes it (test/README.md check 20 case 01, check 21's
         // first run); before, it went to the revision's edge, putting the text in the wrong place.
         if ((before === null || before === void 0 ? void 0 : before.revision) && (after === null || after === void 0 ? void 0 : after.revision) && before.revision.element === after.revision.element
-            && this.insertBetweenHalves(at, ins, () => tracker.nextId())) {
+            && this.insertBetweenHalves(at, items, nextId)) {
             return;
         }
         // at the start of a revision, beside it - and outside a move's range that opens there (case 03)
         if (!before && (after === null || after === void 0 ? void 0 : after.revision)) {
-            this.insertBesideRevision(after.revision, ins, 'before');
+            this.insertBesideRevision(after.revision, items, 'before');
             return;
         }
+        const neighbour = prefer === 'after' ? after !== null && after !== void 0 ? after : before : before !== null && before !== void 0 ? before : after;
         if (neighbour) {
             const owner = neighbour.revision ? neighbour.revision.owner : neighbour.runOwner;
             const item = neighbour.revision ? neighbour.revision.element : neighbour.runOwner[neighbour.runIndex];
             const parent = (neighbour.revision ? neighbour.revision.value : neighbour.run);
-            owner.splice(owner.indexOf(item) + (neighbour === before ? 1 : 0), 0, ins);
-            linkParents(ins, (_d = parent.PARENT) !== null && _d !== void 0 ? _d : this.p);
+            owner.splice(owner.indexOf(item) + (neighbour === before ? 1 : 0), 0, ...items);
+            linkParents(items, (_a = parent.PARENT) !== null && _a !== void 0 ? _a : this.p);
         }
         else {
-            const content = ((_e = (_f = this.p).content) !== null && _e !== void 0 ? _e : (_f.content = []));
+            const content = ((_b = (_c = this.p).content) !== null && _b !== void 0 ? _b : (_c.content = []));
             if (at === 0)
-                content.unshift(ins);
+                content.unshift(...items);
             else
-                content.push(ins);
-            linkParents(ins, this.p);
+                content.push(...items);
+            linkParents(items, this.p);
         }
     }
     /**

package/dist/model/content/Range.mjs

@@ -8,6 +8,7 @@ import { hyperlink as hyperlinkOf } from '@docx4j/generated-objects-ts/el/org_do
 import { Namespaces } from '../../parts/Namespaces.mjs';
 import { controlIdScope, sdtKindFor } from '../customxml/insert.mjs';
 import { contentOf } from './ooxml.mjs';
+import { markHolderInserted } from './tracking.mjs';
 import { searchPattern, findAll, matchesOf, expandReplacement } from './search.mjs';
 import { commentApi } from './comments.mjs';
 /**
@@ -93,8 +94,10 @@ export class Range {
         let r;
         if (location === 'Replace')
             r = this.paragraph.splice(this.start, this.end, text);
+        // text put before the range joins the run the range starts in - inside the link the range is on,
+        // as Office JS (check 32: insertText('Before') on a link's text went into the link, as 'After' did)
         else if (location === 'Before' || location === 'Start')
-            r = this.paragraph.splice(this.start, this.start, text);
+            r = this.paragraph.splice(this.start, this.start, text, 'after');
         else
             r = this.paragraph.splice(this.end, this.end, text);
         // this range keeps covering the same text: a replacement resizes it, text before it shifts it, text after it leaves it
@@ -206,7 +209,7 @@ export class Range {
      * span gets an empty control at its position. Returns the control.
      */
     insertContentControl(kind) {
-        var _a;
+        var _a, _b;
         const paragraph = this.paragraph;
         const body = paragraph.parentBody;
         // The control is built empty first: `sdt` refuses a kind that cannot be run-level (a repeating
@@ -232,9 +235,49 @@ export class Range {
                 items.push(element);
         }
         const at = owner.indexOf(items[0]);
+        const tracker = paragraph.changeTracker;
+        const revision = segments[0].revision;
+        if (tracker && revision) {
+            // The runs are in a revision: the control goes between its halves, not in it, and the runs go
+            // into the control in a revision of the same kind and attributes with a new id - Word's form for
+            // inserted text wrapped in a new control (check 30, inserted-text-wrapped: the w:ins inside the
+            // control, the control's own markers outside it).
+            const index = revision.items.indexOf(items[0]);
+            revision.items.splice(index, items.length);
+            const value = revision.value;
+            const itemsKey = Object.keys(value).find((key) => value[key] === revision.items);
+            const inner = {};
+            for (const [key, v] of Object.entries(value))
+                if (key !== itemsKey && key !== 'PARENT')
+                    inner[key] = v;
+            inner.id = tracker.nextId();
+            inner[itemsKey] = items;
+            const wrapped = { name: revision.element.name, value: inner };
+            linkParents(items, inner);
+            sdt.value.sdtContent.content = [wrapped];
+            linkParents(wrapped, sdt.value.sdtContent);
+            const holderOwner = revision.owner;
+            const parent = (_a = revision.value.PARENT) !== null && _a !== void 0 ? _a : paragraph.p;
+            if (revision.items.length === 0) {
+                holderOwner.splice(holderOwner.indexOf(revision.element), 1, sdt); // the whole revision wrapped
+                linkParents(sdt, parent);
+            }
+            else if (index === 0) {
+                holderOwner.splice(holderOwner.indexOf(revision.element), 0, sdt); // its start wrapped
+                linkParents(sdt, parent);
+            }
+            else if (!paragraph.splitHolderAround(revision, index, sdt, () => tracker.nextId())) {
+                throw new Docx4JException('This range is in a revision that cannot be split around a content control');
+            }
+            markHolderInserted(tracker, sdt, holderOwner, () => { });
+            return new ContentControl(sdt, holderOwner, body);
+        }
         sdt.value.sdtContent.content = items;
         owner.splice(at, items.length, sdt);
-        linkParents(sdt, (_a = segments[0].run.PARENT) !== null && _a !== void 0 ? _a : paragraph.p);
+        linkParents(sdt, (_b = segments[0].run.PARENT) !== null && _b !== void 0 ? _b : paragraph.p);
+        // under tracking the control itself is the insertion, the runs in it what they were (check 30)
+        if (tracker)
+            markHolderInserted(tracker, sdt, owner, () => { });
         return new ContentControl(sdt, owner, body);
     }
     /**

package/dist/model/content/Table.mjs

@@ -3,7 +3,7 @@ import { tr as rowOf } from '@docx4j/generated-objects-ts/builders/wml';
 import { Docx4JException } from '../../opc/exceptions.mjs';
 import { typeNameOf, childrenOf, linkParents, textOf, rowsOf, cellsOf } from './tree.mjs';
 import { builtInOf, idOfBuiltIn, styleNameOf, styleIdOf } from './styles.mjs';
-import { trackInsertedParagraph } from './tracking.mjs';
+import { trackInsertedBlocks } from './tracking.mjs';
 /** The default table width in twips (A4 with 2.54 cm margins), as the objects package's `tbl` builder uses. */
 const DEFAULT_WIDTH = 9026;
 const TWIPS_PER_POINT = 20;
@@ -418,12 +418,10 @@ function markRowsInserted(tracker, rows) {
     if (!tracker)
         return;
     for (const row of rows) {
-        tracker.markRowInserted(row.value);
-        for (const cell of cellsOf(row.value)) {
-            for (const block of (_a = childrenOf(cell.element.value)) !== null && _a !== void 0 ? _a : []) {
-                if (typeNameOf(block) === 'org_docx4j_wml.P')
-                    trackInsertedParagraph(tracker, block.value);
-            }
-        }
+        if (!((_a = row.value.trPr) === null || _a === void 0 ? void 0 : _a.ins))
+            tracker.markRowInserted(row.value);
+        // nested tables and block controls in a new row's cells too (CR-002 section 37)
+        for (const cell of cellsOf(row.value))
+            trackInsertedBlocks(tracker, childrenOf(cell.element.value));
     }
 }

package/dist/model/content/TrackedChange.d.mts

@@ -1,5 +1,5 @@
 import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
-import { type Element, type RevisionKind } from './tree.mjs';
+import { type Element, type Located, type RevisionKind } from './tree.mjs';
 import { Range } from './Range.mjs';
 import type { Paragraph } from './Paragraph.mjs';
 /** Office JS `Word.ChangeTrackingState` (`Unknown` is not produced here). */
@@ -35,7 +35,8 @@ export type TrackedChangeTarget =
  * `w:trPr/w:ins` or `w:trPr/w:del`: a table row. `inner` is the revision markup the row's own
  * cells carry (the `w:ins` or `w:del` around their runs and on their paragraph marks), which
  * `Body.getTrackedChanges` reports through the row rather than separately, as Office JS does:
- * one change per row. Accepting or rejecting the row applies them too.
+ * one change per row. Accepting or rejecting the row applies them too. `table` is the table the
+ * row is in, which goes with its last row.
  */
  | {
     kind: 'row';
@@ -44,6 +45,7 @@ export type TrackedChangeTarget =
     owner: Element[];
     value: wml.CTTrackChange;
     inner: TrackedChange[];
+    table?: Located<wml.Tbl>;
 }
 /**
  * Touching insertions, deletions or formatting changes by one author - `w:ins` or `w:del` around
@@ -92,6 +94,24 @@ export type TrackedChangeTarget =
     sectPr: wml.SectPr;
     value: wml.CTSectPrChange;
     text: string;
+}
+/**
+ * A content control or custom XML element that is itself an insertion: `w:customXmlInsRangeStart`
+ * and `w:customXmlInsRangeEnd` around it, the end first inside its content, and a second pair the
+ * other way round at its end - Word's form for a control put in under tracking (check 30, CR-002
+ * section 37 item 7), which groups with the insertions around and inside it. `holder` is the
+ * `w:sdt` or `w:customXml`, `owner` the list holding it, `outer` the pair in that list and `inner`
+ * the pair in its content. Rejecting takes the element away and leaves its content where it
+ * stood; accepting takes the markers away. Its text is its content's, which the pieces inside
+ * report.
+ */
+ | {
+    kind: 'holder';
+    holder: Element;
+    owner: Element[];
+    outer: [Element, Element];
+    inner: [Element, Element];
+    value: wml.CTTrackChange;
 };
 /**
  * A subset of Office JS `Word.TrackedChange`: `type`, `author`, `date`, `text`, `accept()`,
@@ -134,6 +154,13 @@ export declare class TrackedChange {
     reject(): void;
     private requireParagraph;
 }
+/**
+ * The insertion of a content control or custom XML element, when `items[i]` is a
+ * `w:customXmlInsRangeStart` and what follows is Word's form for one (check 30): the element, whose
+ * content starts with that marker's `w:customXmlInsRangeEnd` and ends with a second start, and that
+ * one's end right after the element. Anything else is not one (a marker on its own is left alone).
+ */
+export declare function holderInsertionAt(items: Element[], i: number, paragraph: Paragraph | undefined): TrackedChange | undefined;
 /**
  * docx4j AcceptTrackedChanges: the paragraph takes the next one's content and properties, so the
  * mark that survives is the next one's. Called when a deleted mark is accepted and when an
@@ -173,7 +200,7 @@ export declare function groupTouching(tokens: TrackedChangeToken[]): TrackedChan
  * The `w:trPr/w:ins` and `w:trPr/w:del` revisions of a table row. `inner` is the revision markup
  * of the row's own cells, which the row's change owns rather than reporting separately.
  */
-export declare function trackedChangesOfRow(tr: Element<wml.Tr>, owner: Element[], inner?: TrackedChange[]): TrackedChange[];
+export declare function trackedChangesOfRow(tr: Element<wml.Tr>, owner: Element[], inner?: TrackedChange[], table?: Located<wml.Tbl>): TrackedChange[];
 /** The change a table's property records make, one per table, or undefined when they make none. */
 export declare function tablePropertiesChangeOf(tbl: Element<wml.Tbl>): TrackedChange | undefined;
 /** A cell's own revision, `w:cellIns` or `w:cellDel`, or undefined. */
@@ -188,6 +215,7 @@ export declare function bodySectionChangeOf(container: {
  * cannot list (check 27: `getTrackedChanges` throws); a `w:numberingChange`, which Word no longer
  * writes and drops when one is put in, and whose record is the old number's text, so that a reject
  * too can only drop it; and a table's records that change nothing. A merge rejected gets the merge it
- * recorded back (docx4j's reading; unmeasured).
+ * recorded back (docx4j's reading; unmeasured). A `w:customXmlInsRangeStart` or `End` left without
+ * the form `holderInsertionAt` lists marks nothing that can be found, and goes either way.
  */
 export declare function resolveUnlisted(items: Element[], what: 'accept' | 'reject'): void;