@docx4j/core-ts 0.5.0 → 0.6.0

package/dist/model/content/TrackedChange.mjs

@@ -1,8 +1,9 @@
 import { textOf } from '@docx4j/generated-objects-ts/builders/wml';
 import { Docx4JException } from '../../opc/exceptions.mjs';
-import { typeNameOf, runItemsOf, revisionKindOf, linkParents, segmentsOf, textOfView, cellsOf, rowsOf, childrenOf, W_NS, itemTextOf } from './tree.mjs';
+import { typeNameOf, runItemsOf, revisionKindOf, linkParents, segmentsOf, textOfView, cellsOf, rowsOf, childrenOf, W_NS, itemTextOf, selectedBranchOf, branchesOf, BRANCH_TYPES, ALTERNATE_CONTENT } from './tree.mjs';
 import { removeMarkers } from './comments.mjs';
 import { Range } from './Range.mjs';
+import { storyLayout, storyOf as storyOfParagraph } from './story.mjs';
 import { rPrFromElements } from '@docx4j/generated-objects-ts/builders/wml';
 import { revisionDateOf, toRestoredText, toDeletedText, restoreRPr, restorePPr, pruneParagraphProperties, HOLDER_TYPES, holderItemsOf } from './tracking.mjs';
 import { tableRecordsOf, hasTableRecords, tableChangeText, rowText as tableRowText, acceptTable, rejectTable } from './tableRevisions.mjs';
@@ -10,8 +11,9 @@ import { deepCopy } from '@docx4j/generated-objects-ts';
 import { relationshipIdsIn, dropRelationshipsUnused, queueRelationshipRemovals } from './relationships.mjs';
 /**
  * A subset of Office JS `Word.TrackedChange`: `type`, `author`, `date`, `text`, `accept()`,
- * `reject()` and `getRange()`, plus `element`, `id` and `target` as extensions. A view, like
- * `Paragraph` and `Range`: it holds the markup it is over, nothing is cached.
+ * `reject()` and `getRange()`, plus `element`, `id`, `target`, and docx4j's `kind`, `part` and
+ * `pieces` (CR-011) as extensions. A view, like `Paragraph` and `Range`: it holds the markup it is
+ * over, nothing is cached.
  */
 export class TrackedChange {
     constructor(target, 
@@ -32,7 +34,7 @@ export class TrackedChange {
             case 'row': return t.row === 'ins' ? 'Added' : 'Deleted';
             case 'group': return t.revision === 'ins' ? 'Added' : t.revision === 'del' ? 'Deleted' : 'Formatted';
             case 'cell': return t.cell === 'ins' ? 'Added' : 'Deleted';
-            case 'holder': return 'Added';
+            case 'holder': return t.revision === 'ins' ? 'Added' : 'Deleted';
             case 'field': return 'Added';
             case 'mathRun':
             case 'mathStructure': return t.revision === 'ins' ? 'Added' : 'Deleted';
@@ -54,6 +56,52 @@ export class TrackedChange {
     get id() {
         return this.target.value.id;
     }
+    /**
+     * docx4j's kind of change (an extension; its `TrackedChange.getKind()`, CR-011): `target.kind` in
+     * docx4j's names, an equation's runs as runs. A group's is its pieces' when they are all of one kind,
+     * else `INSERTION`, `DELETION` or `FORMATTING`.
+     */
+    get kind() {
+        const t = this.target;
+        switch (t.kind) {
+            case 'run': return t.revision === 'ins' ? 'RUN_INSERTION' : t.revision === 'del' ? 'RUN_DELETION' : 'MOVE';
+            case 'mark': return t.mark === 'ins' ? 'PARAGRAPH_MARK_INSERTION' : 'PARAGRAPH_MARK_DELETION';
+            case 'runProperties': return 'RUN_PROPERTIES';
+            case 'markProperties': return 'PARAGRAPH_MARK_PROPERTIES';
+            case 'paragraphProperties': return 'PARAGRAPH_PROPERTIES';
+            case 'row': return t.row === 'ins' ? 'ROW_INSERTION' : 'ROW_DELETION';
+            case 'field': return 'FIELD_INSERTION';
+            case 'holder': return t.revision === 'ins' ? 'CONTENT_CONTROL_INSERTION' : 'CONTENT_CONTROL_DELETION';
+            case 'mathRun': return t.revision === 'ins' ? 'RUN_INSERTION' : 'RUN_DELETION';
+            case 'mathStructure': return t.revision === 'ins' ? 'MATH_STRUCTURE_INSERTION' : 'MATH_STRUCTURE_DELETION';
+            case 'tableProperties': return 'TABLE_PROPERTIES';
+            case 'sectionProperties': return 'SECTION_PROPERTIES';
+            case 'cell': return t.cell === 'ins' ? 'CELL_INSERTION' : 'CELL_DELETION';
+            case 'group': {
+                const first = t.pieces[0].kind;
+                if (t.pieces.every((piece) => piece.kind === first))
+                    return first;
+                return t.revision === 'ins' ? 'INSERTION' : t.revision === 'del' ? 'DELETION' : 'FORMATTING';
+            }
+        }
+    }
+    /**
+     * The part the change's story is in (an extension; docx4j's `getPart()`, CR-011): the main document
+     * part, a header or footer part, the footnotes, endnotes or comments part. A text box's change gives
+     * the part the text box is in.
+     */
+    get part() {
+        var _a;
+        return (_a = this.body_) === null || _a === void 0 ? void 0 : _a.part;
+    }
+    /**
+     * The single changes this one groups, in document order (an extension; docx4j's `getPieces()`,
+     * CR-011); a change that is no group is its own one piece. A filter's conditions are met or not by
+     * each piece, and each can be accepted or rejected on its own.
+     */
+    get pieces() {
+        return this.target.kind === 'group' ? this.target.pieces : [this];
+    }
     /** The markup this change is over (an extension): the `w:ins` element, the `w:rPrChange`, ... */
     get element() {
         var _a;
@@ -83,10 +131,10 @@ export class TrackedChange {
             case 'tableProperties': return tableChangeText(t.tbl.value);
             case 'cell': return tableRowText(t.tr);
             case 'sectionProperties': return t.text;
-            case 'run': return segmentsOf(t.element.value, { view: t.revision === 'ins' || t.revision === 'moveTo' ? 'accepted' : 'original' }).map((s) => s.text).join('');
+            case 'run': return segmentsOf(t.element.value, { view: t.revision === 'ins' || t.revision === 'moveTo' ? 'accepted' : 'original', characters: 'textOf' }).map((s) => s.text).join('');
             case 'runProperties': return textOf(t.run);
             // the field's result: its instruction is no text, as Office JS reports it (check 30: "1")
-            case 'field': return segmentsOf({ content: t.span }, { view: 'accepted' }).map((s) => s.text).join('');
+            case 'field': return segmentsOf({ content: t.span }, { view: 'accepted', characters: 'textOf' }).map((s) => s.text).join('');
             case 'paragraphProperties': return (_b = (_a = this.paragraph) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : '';
             // a deleted row's content is `w:delText` inside `w:del`, which the accepted view skips:
             // its text is what the row said before, as for a run deletion
@@ -98,6 +146,7 @@ export class TrackedChange {
     }
     /** The range the change covers; a deletion is a collapsed range where it sits in the accepted text. */
     getRange() {
+        var _a;
         const p = this.paragraph;
         if (!p)
             return undefined;
@@ -107,15 +156,55 @@ export class TrackedChange {
             return new Range(p, start, end);
         }
         if (t.kind === 'group') {
-            // a range is one paragraph's: the group's text in the paragraph it starts in
-            const here = t.pieces.filter((piece) => { var _a; return (piece.target.kind === 'run' || piece.target.kind === 'runProperties' || piece.target.kind === 'field') && ((_a = piece.paragraph) === null || _a === void 0 ? void 0 : _a.element) === p.element; }).map((piece) => piece.getRange());
-            if (here.length === 0)
+            // the group from where its first piece starts to where its last ends, across paragraphs where its pieces are
+            // in several (CR-014 phase 1; check 52: an insertion through a paragraph's mark is one change whose range
+            // spans both paragraphs). A mark ends its own paragraph's range (check 53: an inserted paragraph's range is
+            // that paragraph, its mark included). A deletion is collapsed where it starts, its text no longer in the
+            // accepted view, as Word's default view reads it (check 53). Until then a group's range was its part in the
+            // paragraph it starts in.
+            const ranges = t.pieces.filter((piece) => piece.target.kind === 'run' || piece.target.kind === 'runProperties' || piece.target.kind === 'field')
+                .map((piece) => piece.getRange()).filter((r) => r !== undefined);
+            const marks = t.pieces.filter((piece) => piece.target.kind === 'mark' && piece.paragraph !== undefined).map((piece) => piece.paragraph);
+            if (ranges.length === 0 && marks.length === 0)
                 return t.pieces[0].getRange();
-            return new Range(p, Math.min(...here.map((r) => r.start)), Math.max(...here.map((r) => r.end)));
+            // within one paragraph, as most groups are: no story to lay out
+            if (marks.length === 0 && ranges.every((r) => r.paragraph.element === ranges[0].paragraph.element && !r.spansParagraphs)) {
+                return new Range(ranges[0].paragraph, Math.min(...ranges.map((r) => r.start)), Math.max(...ranges.map((r) => r.end)));
+            }
+            const layout = storyLayout(storyOfParagraph(p.p).items, (element, container) => p.viewOf(element, container).text);
+            const at = (paragraph, offset) => {
+                const i = layout.indexOf(paragraph.p);
+                return i < 0 ? Number.NaN : layout.paragraphs[i].start + offset;
+            };
+            // each piece's span in the story's text; a mark's is its paragraph's end, holding the mark
+            const spans = ranges.map((r) => ({ start: at(r.paragraph, r.start), end: at(r.endParagraph, r.end) }));
+            for (const paragraph of marks)
+                spans.push({ start: at(paragraph, paragraph.text.length), end: at(paragraph, paragraph.text.length), mark: paragraph });
+            if (spans.some((span) => Number.isNaN(span.start) || Number.isNaN(span.end))) {
+                const here = ranges.filter((r) => r.paragraph.element === p.element);
+                return here.length === 0 ? (_a = ranges[0]) !== null && _a !== void 0 ? _a : t.pieces[0].getRange()
+                    : new Range(p, Math.min(...here.map((r) => r.start)), Math.max(...here.map((r) => r.end)));
+            }
+            const from = Math.min(...spans.map((span) => span.start));
+            const first = layout.paragraphs.find((sp) => sp.start <= from && from <= sp.end);
+            const view = (sp) => (sp.element === p.element ? p : p.viewOf(sp.element, sp.container));
+            if (this.type === 'Deleted')
+                return new Range(view(first), from - first.start, from - first.start);
+            // the last end, a mark's after text ending at the same place
+            const last = spans.reduce((a, b) => (b.end > a.end || (b.end === a.end && b.mark !== undefined) ? b : a));
+            const lastParagraph = layout.paragraphs.find((sp) => sp.start <= last.end && last.end <= sp.end && (last.mark === undefined || sp.element === last.mark.element));
+            return new Range(view(first), from - first.start, last.end - lastParagraph.start, false, last.mark !== undefined, lastParagraph === first ? undefined : view(lastParagraph));
+        }
+        if (t.kind === 'mark') {
+            // a paragraph's mark alone: inserted, the mark (check 53: \r); deleted, collapsed at the paragraph's end,
+            // as Word's default view reads it. Until CR-014 phase 1 it was the paragraph's whole range
+            const length = p.text.length;
+            return new Range(p, length, length, false, t.mark === 'ins');
         }
         if (t.kind === 'field') {
-            const start = acceptedOffsetOf(p.p, t.span[0]);
-            return new Range(p, start, start + this.text.length);
+            const [start] = spanOf(p, t.span[0]);
+            const length = segmentsOf({ content: t.span }, { hidden: p.hiddenRuns() }).map((s) => s.text).join('').length;
+            return new Range(p, start, start + length);
         }
         if (t.kind === 'runProperties') {
             const segs = p.segments().filter((s) => s.run === t.run);
@@ -123,9 +212,13 @@ export class TrackedChange {
                 return p.getRange('Start');
             return new Range(p, segs[0].start, segs[segs.length - 1].end);
         }
-        // an equation's text is not in the paragraph's: collapsed where the equation stands
+        // the equation's text, Word's drawing of it, since CR-012 phase 4; collapsed where it stands when the
+        // view leaves it none
         if ((t.kind === 'mathRun' || t.kind === 'mathStructure') && t.equation) {
-            const at = acceptedOffsetOf(p.p, t.equation);
+            const equation = p.segments().find((seg) => seg.math && seg.item === t.equation);
+            if (equation)
+                return new Range(p, equation.start, equation.end);
+            const [at] = spanOf(p, t.equation);
             return new Range(p, at, at);
         }
         return p.getRange('Whole');
@@ -133,9 +226,27 @@ export class TrackedChange {
     /**
      * Keeps the change: a `w:ins` is unwrapped, a `w:del` removed, a deleted mark joins the paragraphs.
      * Either half of a move keeps the whole move, as Word's Review tab does (CR-002 section 29).
+     *
+     * Returns whether it acted: false, changing nothing, when the change has been resolved since it was
+     * listed (CR-002 section 53). An extension: Office JS's `accept()` returns nothing.
      */
     accept() {
-        resolving(this.package_, this.body_, () => this.acceptHere());
+        if (!this.isCurrent())
+            return false;
+        resolving(this.package_, this.body_, () => { this.acceptHere(); this.resolveTwins('accept'); });
+        return true;
+    }
+    /**
+     * The change's twins resolved the same way: the changes in the other branches of the kept
+     * `mc:AlternateContent` this one was listed from, paired with it by kind and position (`pairTwins`,
+     * docx4j's; CR-013 phase 3), each with its own twins. A group's twins are its pieces', which its
+     * pieces resolve. A twin resolved since it was listed is passed over.
+     */
+    resolveTwins(what) {
+        var _a;
+        for (const twin of (_a = twinsOf.get(this)) !== null && _a !== void 0 ? _a : [])
+            if (twin.isCurrent())
+                twin[what]();
     }
     acceptHere() {
         var _a, _b, _c, _d, _e, _f;
@@ -186,7 +297,7 @@ export class TrackedChange {
                 if (t.cell === 'ins')
                     (_d = t.tc.value.tcPr) === null || _d === void 0 ? true : delete _d.cellIns;
                 else
-                    removeCell(t.tc, t.owner);
+                    removeCell(t.tc, t.owner, t.tr);
                 return;
             case 'markProperties': {
                 const p = this.requireParagraph().p;
@@ -198,8 +309,12 @@ export class TrackedChange {
                 delete t.sectPr.sectPrChange;
                 return;
             case 'holder':
-                // the element stays, the markers go (check 30: accept all leaves the control, no marker)
-                removeHolderMarkers(t);
+                // an insertion: the element stays, the markers go (check 30: accept all leaves the control, no marker);
+                // a deletion: the element goes, its content with it (check 54 case 15: Word's Accept All took the control)
+                if (t.revision === 'ins')
+                    removeHolderMarkers(t);
+                else
+                    removeHolder(t);
                 return;
             case 'field':
                 for (const el of t.span) {
@@ -218,9 +333,59 @@ export class TrackedChange {
     /**
      * Puts back what was there: a `w:ins` is removed, a `w:del` restored, a `w:rPrChange` re-applied.
      * Either half of a move rejects the whole move, as Word's Review tab does (CR-002 section 29).
+     *
+     * Returns whether it acted, as `accept()` does.
      */
     reject() {
-        resolving(this.package_, this.body_, () => this.rejectHere());
+        if (!this.isCurrent())
+            return false;
+        resolving(this.package_, this.body_, () => { this.rejectHere(); this.resolveTwins('reject'); });
+        return true;
+    }
+    /**
+     * Whether the record this view was listed for, `target.value`, is still where it was listed. A view
+     * whose change has been resolved since, by itself or by another verb, does nothing; otherwise it
+     * would act on what stands there now (CR-002 section 53). The record is compared by identity. docx4j's
+     * views throw instead, once any change on the package has been resolved since they were listed; that
+     * would stop a loop resolving one listing last first, as `Body.acceptAll` does.
+     */
+    isCurrent() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const t = this.target;
+        const inList = (owner, element) => currentOwner(owner, element).includes(element);
+        switch (t.kind) {
+            case 'run':
+                return inList(t.owner, t.element);
+            case 'mathRun':
+                return ((_a = t.run.value.content) !== null && _a !== void 0 ? _a : []).includes(t.item);
+            case 'tableProperties':
+                return hasTableRecords(t.tbl.value); // resolved from the table's records as they stand
+            case 'group':
+                return t.pieces.some((piece) => piece.isCurrent()); // each piece decides for itself
+            case 'mark': {
+                const paragraph = this.paragraph;
+                return !!paragraph && ((_c = (_b = paragraph.p.pPr) === null || _b === void 0 ? void 0 : _b.rPr) === null || _c === void 0 ? void 0 : _c[t.mark]) === t.value && inList(paragraph.container, paragraph.element);
+            }
+            case 'runProperties':
+                return ((_d = t.run.rPr) === null || _d === void 0 ? void 0 : _d.rPrChange) === t.value;
+            case 'paragraphProperties':
+                return ((_f = (_e = this.paragraph) === null || _e === void 0 ? void 0 : _e.p.pPr) === null || _f === void 0 ? void 0 : _f.pPrChange) === t.value;
+            case 'markProperties':
+                return ((_j = (_h = (_g = this.paragraph) === null || _g === void 0 ? void 0 : _g.p.pPr) === null || _h === void 0 ? void 0 : _h.rPr) === null || _j === void 0 ? void 0 : _j.rPrChange) === t.value;
+            case 'sectionProperties':
+                return t.sectPr.sectPrChange === t.value;
+            case 'row':
+                return ((_k = t.tr.value.trPr) === null || _k === void 0 ? void 0 : _k[t.row]) === t.value && inList(t.owner, t.tr);
+            case 'cell':
+                return ((_l = t.tc.value.tcPr) === null || _l === void 0 ? void 0 : _l[t.cell === 'ins' ? 'cellIns' : 'cellDel']) === t.value && inList(t.owner, t.tc);
+            case 'holder':
+                return inList(t.owner, t.outer[0]);
+            case 'field':
+                return t.span.length > 0 && inList(t.owner, t.span[0]);
+            case 'mathStructure':
+                // an equation's lists are not the ones childrenOf gives its PARENT, so the structure's own
+                return t.ctrlPr[t.revision] === t.value && (!t.structure || !t.owner || currentOwner(t.owner, t.structure).includes(t.structure));
+        }
     }
     rejectHere() {
         var _a, _b;
@@ -271,7 +436,7 @@ export class TrackedChange {
                 if (t.cell === 'del')
                     (_b = t.tc.value.tcPr) === null || _b === void 0 ? true : delete _b.cellDel;
                 else
-                    removeCell(t.tc, t.owner);
+                    removeCell(t.tc, t.owner, t.tr);
                 return;
             case 'markProperties':
                 restoreMarkProperties(this.requireParagraph().p, t.value);
@@ -280,10 +445,13 @@ export class TrackedChange {
                 restoreSection(t.sectPr, t.value);
                 return;
             case 'holder':
-                // the element goes, its content stays where it stood: what is left of it after the pieces
-                // inside were rejected (nothing, for content inserted with it; check 30: reject all removes the
-                // control, and an existing control, which has no markers, stays)
-                unwrapHolder(t);
+                // an insertion: the element goes, its content stays where it stood: what is left of it after the
+                // pieces inside were rejected (nothing, for content inserted with it; check 30: reject all removes
+                // the control, and an existing control, which has no markers, stays); a deletion: the markers go
+                if (t.revision === 'ins')
+                    unwrapHolder(t);
+                else
+                    removeHolderMarkers(t);
                 return;
             case 'field':
                 removeField(t, this.paragraph);
@@ -329,19 +497,20 @@ function rowText(tr, view) {
         for (const el of (_a = childrenOf(tc)) !== null && _a !== void 0 ? _a : []) {
             const tn = typeNameOf(el);
             if (tn === 'org_docx4j_wml.P') {
-                out += (afterParagraph ? '\r' : '') + textOfView(el.value, { view });
+                out += (afterParagraph ? '\r' : '') + textOfView(el.value, { view, characters: 'textOf' });
                 afterParagraph = true;
             }
             else if (tn === 'org_docx4j_wml.Tbl') {
-                for (const row of rowsOf(el.value))
+                for (const row of rowsOf(el.value, 'read'))
                     out += rowText(row.element.value, view);
                 afterParagraph = false;
             }
             else if (typeof el.value === 'object' && el.value !== null) {
-                // a block control or custom XML element: what it holds, as if it were not there
-                for (const inner of (_b = childrenOf(el.value)) !== null && _b !== void 0 ? _b : []) {
+                // a block control or custom XML element, or a kept mc:AlternateContent's selected branch (CR-013
+                // phase 2): what it holds, as if it were not there
+                for (const inner of (_b = childrenOf(el.value, 'read')) !== null && _b !== void 0 ? _b : []) {
                     if (typeNameOf(inner) === 'org_docx4j_wml.P') {
-                        out += (afterParagraph ? '\r' : '') + textOfView(inner.value, { view });
+                        out += (afterParagraph ? '\r' : '') + textOfView(inner.value, { view, characters: 'textOf' });
                         afterParagraph = true;
                     }
                 }
@@ -349,7 +518,7 @@ function rowText(tr, view) {
         }
         return out;
     };
-    return cellsOf(tr).map((cell) => cellText(cell.element.value)).join('\t') + '\r\n';
+    return cellsOf(tr, 'read').map((cell) => cellText(cell.element.value)).join('\t') + '\r\n';
 }
 /** The changes inside a row, last first, so that a paragraph join never disturbs one still to do. */
 function applyInner(inner, what) {
@@ -412,7 +581,7 @@ function indentWithin(ind, level) {
  * never strands a piece still to do. Office JS and Word's Review tab resolve the group as one (checks
  * 22 and 23), and so, piece by piece, does this.
  */
-function resolvePieces(pieces, what) {
+export function resolvePieces(pieces, what) {
     const runs = pieces.filter((piece) => piece.target.kind !== 'mark');
     const marks = pieces.filter((piece) => piece.target.kind === 'mark');
     for (let i = runs.length - 1; i >= 0; i--)
@@ -421,14 +590,13 @@ function resolvePieces(pieces, what) {
         marks[i][what]();
 }
 /**
- * The list an element is in now: `owner` as the change was listed, else the list its `PARENT` keeps -
- * a piece listed inside a holder that was unwrapped since (its content moved out into the owner,
- * check 30) is still found.
+ * The list an element is in now: the list its `PARENT` keeps, else `owner` as the change was listed.
+ * A piece listed inside a holder that was unwrapped since (its content moved out into the owner, check
+ * 30) is still found, and so is a run whose paragraph was joined into the one before it: the joined
+ * paragraph's own list still holds it, but is no longer in the document (CR-002 section 53).
  */
 function currentOwner(owner, element) {
     var _a, _b;
-    if (owner.includes(element))
-        return owner;
     const parent = (_a = element.value) === null || _a === void 0 ? void 0 : _a.PARENT;
     const actual = parent ? (_b = runItemsOf(parent)) !== null && _b !== void 0 ? _b : childrenOf(parent) : undefined;
     return (actual === null || actual === void 0 ? void 0 : actual.includes(element)) ? actual : owner;
@@ -462,17 +630,21 @@ let resolution;
  *   goes when nothing left in the part references it; its part goes when no relationship in the package
  *   targets it any more, and what that part alone related to goes with it. The kinds beyond pictures,
  *   headers and footers (charts, OLE objects, `v:imagedata`) are docx4j's reading, not measured.
+ * - **Comments**: a comment `removeRevision` left with its range's start and end in different paragraphs
+ *   goes whole when the joins have brought them into one list with nothing with text between
+ *   (`settleSpanningComments`; CR-002 section 54).
  * A change resolved inside another's (a row's cells, a group's pieces, `acceptAll`'s changes) shares the
  * outer resolution, so the bookmarks are read twice for the lot, and not at all when nothing is removed.
  */
 export function resolving(pkg, body, resolve) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f;
     const notes = pkg === null || pkg === void 0 ? void 0 : pkg.pendingNoteRemovals;
     const root = storyRootOf(body);
     const outer = resolution;
     if (outer) {
         (_a = outer.root) !== null && _a !== void 0 ? _a : (outer.root = root);
         (_b = outer.part) !== null && _b !== void 0 ? _b : (outer.part = body === null || body === void 0 ? void 0 : body.part);
+        (_c = outer.body) !== null && _c !== void 0 ? _c : (outer.body = body);
         const previous = outer.notes;
         outer.notes = notes !== null && notes !== void 0 ? notes : previous;
         try {
@@ -484,12 +656,18 @@ export function resolving(pkg, body, resolve) {
         return;
     }
     resolution = { notes, root, part: body === null || body === void 0 ? void 0 : body.part };
+    if (body)
+        resolution.body = body;
     try {
         resolve();
         const done = resolution;
+        if ((_d = done.comments) === null || _d === void 0 ? void 0 : _d.size)
+            settleSpanningComments(done.comments);
+        if (((_e = done.commentCandidates) === null || _e === void 0 ? void 0 : _e.size) && done.root && done.body)
+            settleCommentAnchors(done.root, done.body, done.commentCandidates);
         if (done.root && done.before)
             dropBookmarksBroken(done.root, done.before);
-        if (done.part && ((_c = done.relationships) === null || _c === void 0 ? void 0 : _c.size))
+        if (done.part && ((_f = done.relationships) === null || _f === void 0 ? void 0 : _f.size))
             dropRelationshipsUnused(done.part, done.relationships);
     }
     finally {
@@ -509,15 +687,17 @@ function storyRootOf(body) {
  * whose `w:sectPr` references its section's headers and footers.
  */
 function discarding(element, properties) {
-    var _a, _b;
+    var _a, _b, _c;
     if (!resolution)
         return;
     if (resolution.root)
         (_a = resolution.before) !== null && _a !== void 0 ? _a : (resolution.before = bookmarksIn(resolution.root));
     if (element && resolution.notes)
         noteReferencesIn(element, resolution.notes);
+    if (element)
+        commentAnchorsIn(element, ((_b = resolution.commentCandidates) !== null && _b !== void 0 ? _b : (resolution.commentCandidates = new Set())));
     if (resolution.part && (element || properties)) {
-        const into = ((_b = resolution.relationships) !== null && _b !== void 0 ? _b : (resolution.relationships = new Set()));
+        const into = ((_c = resolution.relationships) !== null && _c !== void 0 ? _c : (resolution.relationships = new Set()));
         if (element)
             relationshipIdsIn(element, into);
         if (properties)
@@ -632,6 +812,17 @@ function dropBookmarksBroken(root, before) {
     };
     visit(root);
 }
+/**
+ * Queues the notes whose references `removed` holds to go when the package is saved, as a resolution's
+ * removals go: what a range deleted untracked takes with it (CR-014 phase 2; check 52 case 12, where Word took
+ * the footnote out of `footnotes.xml` with its reference). A note goes only where no reference to it stands
+ * by then (`flushPendingNoteRemovals`), so content queued and then kept costs nothing.
+ */
+export function queueNoteRemovals(pkg, removed) {
+    const notes = pkg === null || pkg === void 0 ? void 0 : pkg.pendingNoteRemovals;
+    if (notes)
+        noteReferencesIn(removed, notes);
+}
 /** Adds the ids of the `w:footnoteReference` and `w:endnoteReference` elements anywhere in a tree to `into`. */
 function noteReferencesIn(tree, into) {
     const visit = (o) => {
@@ -656,6 +847,20 @@ function noteReferencesIn(tree, into) {
     };
     visit(tree);
 }
+/**
+ * The notes `pending` holds that `flushPendingNoteRemovals` will take away: those whose reference no
+ * longer stands in the main document's tree. A listing of every story leaves them out, as docx4j's,
+ * which removes them when its resolution ends, does (CR-011).
+ */
+export function notesGoing(mainTree, pending) {
+    const standing = { footnote: new Set(), endnote: new Set() };
+    if (pending.footnote.size + pending.endnote.size > 0)
+        noteReferencesIn(mainTree, standing);
+    return {
+        footnote: new Set([...pending.footnote].filter((id) => !standing.footnote.has(id))),
+        endnote: new Set([...pending.endnote].filter((id) => !standing.endnote.has(id))),
+    };
+}
 /**
  * The notes `pending` holds taken out of the notes parts, each unless a reference to it still stands in
  * the main document (an accepted move keeps the reference its source had, say); then `pending` is
@@ -696,7 +901,7 @@ export async function flushPendingNoteRemovals(main, pending, host) {
     pending.endnote.clear();
 }
 /** Adds the ids of the `w:commentReference` elements anywhere in a tree to `into`. */
-function commentReferencesIn(tree, into) {
+export function commentReferencesIn(tree, into) {
     const visit = (o) => {
         var _a, _b;
         if (typeof o !== 'object' || o === null)
@@ -718,7 +923,12 @@ function commentReferencesIn(tree, into) {
     };
     visit(tree);
 }
-/** A holder's four insertion markers taken away; the element stays. */
+/** A holder's deletion accepted: the markers go, and the element with what it holds. */
+function removeHolder(t) {
+    removeHolderMarkers(t);
+    remove(t.owner, t.holder);
+}
+/** A holder's four insertion (or deletion) markers taken away; the element stays. */
 function removeHolderMarkers(t) {
     var _a;
     remove(t.owner, t.outer[0]);
@@ -744,26 +954,29 @@ function unwrapHolder(t) {
  * 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).
+ * one's end right after the element; or its deletion, the same form of `w:customXmlDelRangeStart` and
+ * `End` (check 54). Anything else is not one (a marker on its own is left alone).
  */
-export function holderInsertionAt(items, i, paragraph) {
-    var _a, _b, _c, _d, _e, _f;
+export function holderChangeAt(items, i, paragraph, body) {
+    var _a, _b, _c, _d, _e, _f, _g;
     const start = items[i];
-    if (((_a = start.name) === null || _a === void 0 ? void 0 : _a.localPart) !== 'customXmlInsRangeStart')
+    const revision = ((_a = start.name) === null || _a === void 0 ? void 0 : _a.localPart) === 'customXmlInsRangeStart' ? 'ins' : ((_b = start.name) === null || _b === void 0 ? void 0 : _b.localPart) === 'customXmlDelRangeStart' ? 'del' : undefined;
+    if (!revision)
         return undefined;
+    const [startName, endName] = revision === 'ins' ? ['customXmlInsRangeStart', 'customXmlInsRangeEnd'] : ['customXmlDelRangeStart', 'customXmlDelRangeEnd'];
     const holder = items[i + 1];
     const outerEnd = items[i + 2];
-    if (!holder || !outerEnd || !HOLDER_TYPES.has((_b = typeNameOf(holder)) !== null && _b !== void 0 ? _b : '') || ((_c = outerEnd.name) === null || _c === void 0 ? void 0 : _c.localPart) !== 'customXmlInsRangeEnd')
+    if (!holder || !outerEnd || !HOLDER_TYPES.has((_c = typeNameOf(holder)) !== null && _c !== void 0 ? _c : '') || ((_d = outerEnd.name) === null || _d === void 0 ? void 0 : _d.localPart) !== endName)
         return undefined;
-    const inner = (_d = childrenOf(holder.value)) !== null && _d !== void 0 ? _d : [];
+    const inner = (_e = childrenOf(holder.value)) !== null && _e !== void 0 ? _e : [];
     const innerEnd = inner[0];
     const innerStart = inner[inner.length - 1];
-    if (inner.length < 2 || !innerEnd || !innerStart || ((_e = innerEnd.name) === null || _e === void 0 ? void 0 : _e.localPart) !== 'customXmlInsRangeEnd' || ((_f = innerStart.name) === null || _f === void 0 ? void 0 : _f.localPart) !== 'customXmlInsRangeStart')
+    if (inner.length < 2 || !innerEnd || !innerStart || ((_f = innerEnd.name) === null || _f === void 0 ? void 0 : _f.localPart) !== endName || ((_g = innerStart.name) === null || _g === void 0 ? void 0 : _g.localPart) !== startName)
         return undefined;
     const idOf = (marker) => marker.value.id;
     if (idOf(innerEnd) !== idOf(start) || idOf(outerEnd) !== idOf(innerStart))
         return undefined;
-    return new TrackedChange({ kind: 'holder', holder, owner: items, outer: [start, outerEnd], inner: [innerEnd, innerStart], value: start.value }, paragraph);
+    return new TrackedChange({ kind: 'holder', revision, holder, owner: items, outer: [start, outerEnd], inner: [innerEnd, innerStart], value: start.value }, paragraph, body);
 }
 /**
  * An inserted field rejected (Word's form, check 30 `field-inserted`): the `w:ins` pieces and the plain
@@ -853,45 +1066,56 @@ export function insertedFieldAt(items, i, paragraph) {
  */
 function removeRow(t) {
     remove(t.owner, t.tr);
-    if (t.table && rowsOf(t.table.element.value).length === 0)
+    // a row in any branch of a kept row-level mc:AlternateContent keeps the table (CR-013 phase 2, docx4j's
+    // Lister.hasRows): counted over the selected branch alone, the table went with every branch's rows
+    if (t.table && rowsOf(t.table.element.value, 'every').length === 0)
         remove(t.table.container, t.table.element);
 }
 /**
  * A revision taken away with its runs - a rejected insertion, an accepted deletion - and the comments
- * on it, by where their markers were (CR-002 section 38 item 1):
- * - Word writes a comment's range start inside the `w:ins` of the text it is on; when that text goes,
- *   current Word removes the comment with it - markers, reference run and entry (check 32, run
- *   2026-10-02: rejecting the insertion, rejecting all, and accepting the deletion in the same shape,
- *   each left no comment). A comment whose start comes out of the revision with no text left in its
- *   range is removed here: the markers and the reference now, the entries in the comment parts when
- *   the comments are next read or the package saved (`pendingCommentRemovals`).
- * - A comment whose markers lie outside the revision (this package's own form before 0.3.1, and any
- *   file's) is kept when its text goes: Word 2010 and Word 15, rejecting all in the editor's
- *   `review-for-word.docx`, left its reference run alone, the range markers dropped and the entry kept
- *   (the editor's finding of 2026-10-02). The range markers go here, the reference and the entry stay.
- * A comment with text left in its range keeps its markers where the text was (not measured), and
- * current Word's answer for the outside form, and the older Words' for the inside one, are not measured.
+ * on it, as Word 365 resolves them (CR-002 section 54; docx4j CR-043 section 15, `Resolver.removeRevision`):
+ * a comment whose range start was inside the revision, or whose markers lie either side of it in its
+ * list, goes whole - markers, reference run and entry - once nothing with text is left in its range.
+ * - Word writes a comment's range start inside the `w:ins` of the text it is on; current Word removed
+ *   the comment with that text (check 32: rejecting the insertion, rejecting all, and accepting the
+ *   deletion in the same shape).
+ * - Every marker outside the revision (this package's own form before 0.3.1, a tracker's that wraps
+ *   only the text): Word 365's Reject All of the editor's `review-for-word.docx` and of docx4j-python's
+ *   artefact 8, and its Accept All of a deletion (docx4j's U21), removed the comment whole too. Word
+ *   2010 and Word 15 kept it, its range markers dropped, which was the rule here until section 54.
+ * - A range whose start and end are in different paragraphs is judged when the resolution ends, once
+ *   the paragraph marks taken away have joined what is left (`resolving`): Word 365's Reject All of two
+ *   inserted paragraphs commented whole removed the comment (docx4j's U23). A range still crossing a
+ *   paragraph mark stays (docx4j's U24, not measured).
+ * The markers and the reference go now, the entries in the comment parts when the comments are next
+ * read or the package saved (`pendingCommentRemovals`). A comment with text left in its range keeps its
+ * markers where the text was (not measured), and so does one whose range was empty before.
  */
 function removeRevision(t, paragraph) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const owner = currentOwner(t.owner, t.element);
     const i = owner.indexOf(t.element);
     if (i < 0)
         return;
     const kept = ((_a = runItemsOf(t.element.value)) !== null && _a !== void 0 ? _a : []).filter((item) => { var _a, _b; return ((_a = item.name) === null || _a === void 0 ? void 0 : _a.localPart) === 'commentRangeStart' || ((_b = item.name) === null || _b === void 0 ? void 0 : _b.localPart) === 'commentRangeEnd'; });
-    // the comments whose range held the revision: a start inside it (Word's form), or one before it
-    // with its end after it (the engine's own, the markers beside the runs)
-    const idOf = (el) => el.value.id;
-    const inside = new Set(kept.filter((m) => { var _a; return ((_a = m.name) === null || _a === void 0 ? void 0 : _a.localPart) === 'commentRangeStart'; }).map(idOf));
+    // the comments whose range held the revision: a start inside it (Word's form); a start before it
+    // with its end after it (the markers beside the runs) or in another paragraph; an end after it with
+    // its start in another paragraph
+    const inside = new Set(kept.filter((m) => { var _a; return ((_a = m.name) === null || _a === void 0 ? void 0 : _a.localPart) === 'commentRangeStart'; }).map(commentIdOf));
     const outside = new Set();
     for (let s = 0; s < i; s++) {
         const el = owner[s];
         if (((_b = el.name) === null || _b === void 0 ? void 0 : _b.localPart) !== 'commentRangeStart')
             continue;
-        const id = idOf(el);
-        if (owner.some((other, e) => { var _a; return e > i && ((_a = other.name) === null || _a === void 0 ? void 0 : _a.localPart) === 'commentRangeEnd' && idOf(other) === id; }))
+        const id = commentIdOf(el);
+        if (markerAt(owner, s + 1, owner.length, 'commentRangeEnd', id) < 0 || markerAt(owner, i + 1, owner.length, 'commentRangeEnd', id) >= 0)
             outside.add(id);
     }
+    for (let e = i + 1; e < owner.length; e++) {
+        const el = owner[e];
+        if (((_c = el.name) === null || _c === void 0 ? void 0 : _c.localPart) === 'commentRangeEnd' && markerAt(owner, 0, e, 'commentRangeStart', commentIdOf(el)) < 0)
+            outside.add(commentIdOf(el));
+    }
     discarding(t.element);
     owner.splice(i, 1, ...kept);
     linkParents(kept, t.element.value.PARENT);
@@ -899,23 +1123,147 @@ function removeRevision(t, paragraph) {
     if (!body)
         return;
     for (const id of [...inside, ...outside]) {
-        const start = owner.find((el) => { var _a; return ((_a = el.name) === null || _a === void 0 ? void 0 : _a.localPart) === 'commentRangeStart' && idOf(el) === id; });
-        if (!start || !rangeIsEmpty(owner, start, id))
-            continue;
-        if (inside.has(id)) {
-            removeMarkers(body.container, id);
-            const pkg = body.package_;
-            (_c = pkg === null || pkg === void 0 ? void 0 : pkg.pendingCommentRemovals) === null || _c === void 0 ? void 0 : _c.add(id);
+        const start = markerAt(owner, 0, owner.length, 'commentRangeStart', id);
+        if (start < 0 || markerAt(owner, start + 1, owner.length, 'commentRangeEnd', id) < 0) {
+            if (resolution)
+                ((_d = resolution.comments) !== null && _d !== void 0 ? _d : (resolution.comments = new Map())).set(id, body); // start and end in different paragraphs
         }
-        else {
-            // the range markers only: the reference run and the entry stay (Word 2010 and 15)
-            const end = owner.find((el) => { var _a; return ((_a = el.name) === null || _a === void 0 ? void 0 : _a.localPart) === 'commentRangeEnd' && idOf(el) === id; });
-            for (const marker of [end, start])
-                if (marker)
-                    owner.splice(owner.indexOf(marker), 1);
+        else if (rangeIsEmpty(owner, owner[start], id)) {
+            removeCommentWhole(body, id);
         }
     }
 }
+const commentIdOf = (el) => { var _a; return (_a = el.value) === null || _a === void 0 ? void 0 : _a.id; };
+/** The index in `list`, from `from` up to `to`, of a comment's range start or end (`local`), or -1. */
+function markerAt(list, from, to, local, id) {
+    var _a;
+    for (let i = from; i < to; i++)
+        if (((_a = list[i].name) === null || _a === void 0 ? void 0 : _a.localPart) === local && commentIdOf(list[i]) === id)
+            return i;
+    return -1;
+}
+/** A comment taken away: its markers and reference run now, its entries when the comments are next read or the package saved. */
+function removeCommentWhole(body, id) {
+    var _a;
+    removeMarkers(body.container, id);
+    const pkg = body.package_;
+    (_a = pkg === null || pkg === void 0 ? void 0 : pkg.pendingCommentRemovals) === null || _a === void 0 ? void 0 : _a.add(id);
+}
+/**
+ * The comments `removeRevision` left with their range's start and end in different lists, judged once
+ * the resolution's joins are made (docx4j's `Removals.removeCommentIfEmptied`): one goes whole when its
+ * start and end now stand in one list with nothing with text between them.
+ */
+function settleSpanningComments(comments) {
+    for (const [id, body] of comments) {
+        const list = listHolding(storyRootOf(body), (el) => { var _a; return ((_a = el.name) === null || _a === void 0 ? void 0 : _a.localPart) === 'commentRangeStart' && commentIdOf(el) === id; });
+        if (!list)
+            continue;
+        const start = markerAt(list, 0, list.length, 'commentRangeStart', id);
+        if (rangeIsEmpty(list, list[start], id))
+            removeCommentWhole(body, id);
+    }
+}
+/**
+ * The comments whose reference or range marker the resolution removed, judged once it ends, as docx4j's
+ * `Removals.flush` judges its candidates (its CR-043; core-ts check 32): one whose reference no longer stands
+ * anywhere in the story goes whole, since Word keeps no comment without one; one with its reference and half its
+ * range left loses that half. A tracked deletion holds a comment's reference where it took one (CR-014 section
+ * 12.6, Word's case 28), so accepting it takes the comment, as the untracked deletion does.
+ */
+function settleCommentAnchors(root, body, candidates) {
+    var _a;
+    const pending = (_a = body.package_) === null || _a === void 0 ? void 0 : _a.pendingCommentRemovals;
+    const references = new Set();
+    const starts = new Set();
+    const ends = new Set();
+    forEachCommentAnchor(root, (name, id) => (name === 'commentReference' ? references : name === 'commentRangeStart' ? starts : ends).add(id));
+    for (const id of candidates) {
+        if (pending === null || pending === void 0 ? void 0 : pending.has(id))
+            continue;
+        if (!references.has(id))
+            removeCommentWhole(body, id);
+        else if (starts.has(id) !== ends.has(id))
+            removeRangeMarkers(root, id);
+    }
+}
+/** Adds the ids of the comment references and range markers anywhere in a tree to `into`. */
+function commentAnchorsIn(tree, into) {
+    forEachCommentAnchor(tree, (_name, id) => into.add(id));
+}
+/** Calls `found` for each comment reference, range start and range end anywhere in a tree. */
+function forEachCommentAnchor(tree, found) {
+    const visit = (o) => {
+        var _a, _b;
+        if (typeof o !== 'object' || o === null)
+            return;
+        if (Array.isArray(o)) {
+            for (const item of o)
+                visit(item);
+            return;
+        }
+        const name = (_a = o.name) === null || _a === void 0 ? void 0 : _a.localPart;
+        if (name === 'commentReference' || name === 'commentRangeStart' || name === 'commentRangeEnd') {
+            const id = Number((_b = (o.value)) === null || _b === void 0 ? void 0 : _b.id);
+            if (Number.isInteger(id))
+                found(name, id);
+            return;
+        }
+        for (const [key, value] of Object.entries(o))
+            if (key !== 'PARENT')
+                visit(value);
+    };
+    visit(tree);
+}
+/** A comment's range markers taken out of a tree, its reference kept: what is left of half a range. */
+function removeRangeMarkers(tree, id) {
+    const visit = (o) => {
+        var _a;
+        if (typeof o !== 'object' || o === null)
+            return;
+        if (Array.isArray(o)) {
+            for (let i = o.length - 1; i >= 0; i--) {
+                const el = o[i];
+                const name = (_a = el === null || el === void 0 ? void 0 : el.name) === null || _a === void 0 ? void 0 : _a.localPart;
+                if ((name === 'commentRangeStart' || name === 'commentRangeEnd') && commentIdOf(el) === id)
+                    o.splice(i, 1);
+                else
+                    visit(el);
+            }
+            return;
+        }
+        for (const [key, value] of Object.entries(o))
+            if (key !== 'PARENT')
+                visit(value);
+    };
+    visit(tree);
+}
+/** The list under `root` (block, run and run-content lists, math's) holding an item `match` matches, or undefined. */
+function listHolding(root, match) {
+    let found;
+    const seen = new Set();
+    const visit = (o) => {
+        if (found || typeof o !== 'object' || o === null || seen.has(o))
+            return;
+        seen.add(o);
+        if (Array.isArray(o)) {
+            if (o.some((item) => typeof item === 'object' && item !== null && match(item))) {
+                found = o;
+                return;
+            }
+            for (const item of o)
+                visit(item);
+            return;
+        }
+        if (o.nodeType !== undefined)
+            return; // a DOM node
+        for (const key in o)
+            if (key !== 'PARENT')
+                visit(o[key]);
+    };
+    visit(root);
+    return found;
+}
 /** True when nothing with text stands between a comment's range start and its end in the same list. */
 function rangeIsEmpty(owner, start, id) {
     var _a;
@@ -946,11 +1294,13 @@ function hasText(el) {
 /** A `w:ins` or `w:moveTo` accepted: its runs take its place. */
 function unwrap(t) {
     var _a;
-    const i = t.owner.indexOf(t.element);
+    const owner = currentOwner(t.owner, t.element);
+    const i = owner.indexOf(t.element);
     if (i < 0)
         return;
-    const items = (_a = runItemsOf(t.element.value)) !== null && _a !== void 0 ? _a : [];
-    t.owner.splice(i, 1, ...items);
+    // the revision keeps nothing, so a view listed inside it no longer finds its element there (section 53)
+    const items = ((_a = runItemsOf(t.element.value)) !== null && _a !== void 0 ? _a : []).splice(0);
+    owner.splice(i, 1, ...items);
     const parent = t.value.PARENT;
     for (const item of items)
         linkParents(item, parent);
@@ -980,29 +1330,84 @@ function dropMark(paragraph, which) {
  *
  * `fallbackToPrevious` is for the second case at the end of a container, where this package's
  * inserted paragraph carries its own mark (section 13) and there is nothing after it to join
- * with: the paragraph then goes, its content joining the one before. With neither neighbour the
- * mark is simply dropped.
+ * with: the paragraph then goes, its content joining the one before. Otherwise, with no paragraph
+ * next, a join never crosses a container's edge, and Word 365's Accept All (check 54 and the text-left
+ * probe, docx4j CR-043 section 17) does one of four things: an emptied paragraph with a table or a
+ * block control next goes; text left with a table next joins the table's first cell's first paragraph,
+ * which keeps its properties; with a block control next it takes the control's first paragraph's
+ * properties, nothing joined; a control's last paragraph keeps a bare mark. Else the mark is only dropped.
  */
 export function joinWithNext(paragraph, fallbackToPrevious = false) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     discarding();
     const container = currentOwner(paragraph.container, paragraph.element);
     const i = container.indexOf(paragraph.element);
-    const next = i >= 0 ? container[i + 1] : undefined;
+    // range markers between the two (a bookmark's end, a move's range end) go into the joined paragraph
+    // where they stood, as docx4j's join (its CR-043, C10 and C10b) and Word's: found by CR-011's goldens
+    let j = i + 1;
+    while (i >= 0 && j < container.length && isRangeMarker(container[j]))
+        j++;
+    const next = i >= 0 ? container[j] : undefined;
     const p = paragraph.p;
     if (!next || typeNameOf(next) !== 'org_docx4j_wml.P') {
         const previous = fallbackToPrevious && i > 0 ? container[i - 1] : undefined;
         if (previous && typeNameOf(previous) === 'org_docx4j_wml.P') {
             const into = previous.value;
             const items = ((_a = into.content) !== null && _a !== void 0 ? _a : (into.content = []));
-            for (const item of (_b = p.content) !== null && _b !== void 0 ? _b : [])
-                items.push(item);
+            for (const item of ((_b = p.content) !== null && _b !== void 0 ? _b : []).splice(0))
+                items.push(item); // this paragraph keeps nothing
             linkParents(items, into);
             discarding(undefined, p.pPr);
             container.splice(i, 1);
             return;
         }
-        const rPr = (_c = p.pPr) === null || _c === void 0 ? void 0 : _c.rPr;
+        // Word 365's Accept All where no paragraph follows (check 54 and the text-left probe; docx4j CR-043 section 17,
+        // 29dbf5964 and e55a83b8e): a join never crosses a container's edge, and four shapes do something besides dropping
+        // the mark, in docx4j's order
+        const emptied = !((_c = p.content) !== null && _c !== void 0 ? _c : []).some((item) => !isRangeMarker(item));
+        const table = next !== undefined && typeNameOf(next) === 'org_docx4j_wml.Tbl';
+        const control = next !== undefined && HOLDER_TYPES.has((_d = typeNameOf(next)) !== null && _d !== void 0 ? _d : '');
+        if (i >= 0 && emptied && (table || control)) {
+            // check 54 case 9, the probe's case 3: an emptied paragraph with a table or a block control next goes, which
+            // then follows what came before
+            discarding(undefined, p.pPr);
+            container.splice(i, 1);
+            return;
+        }
+        if (i >= 0 && table) {
+            // the probe's case 1: text left with a table next joins the table's first cell's first paragraph, at its front,
+            // the range markers after it with it; that paragraph keeps its own properties
+            const first = firstCellParagraphOf(next.value);
+            if (first) {
+                const moved = [...((_e = p.content) !== null && _e !== void 0 ? _e : []).splice(0), ...container.slice(i + 1, j)];
+                ((_f = first.content) !== null && _f !== void 0 ? _f : (first.content = [])).splice(0, 0, ...moved);
+                linkParents(moved, first);
+                discarding(undefined, p.pPr);
+                container.splice(i, j - i);
+                return;
+            }
+        }
+        if (control) {
+            // check 54 case 19, the probe's case 5: text left with a block control next: nothing joins, but the paragraph
+            // takes the properties a join would have given it, the control's first paragraph's
+            const first = firstParagraphOf(childrenOf(next.value));
+            if (first) {
+                discarding(undefined, p.pPr);
+                p.pPr = first.pPr ? deepCopy(first.pPr) : undefined;
+                if (p.pPr)
+                    linkParents(p.pPr, p);
+                else
+                    delete p.pPr;
+                return;
+            }
+        }
+        if (i >= 0 && next === undefined && SDT_CONTENTS.has((_h = (_g = p.PARENT) === null || _g === void 0 ? void 0 : _g.TYPE_NAME) !== null && _h !== void 0 ? _h : '')) {
+            // check 54 case 13, the probe's case 2: a control's last paragraph keeps a bare mark, its text with it, if any
+            discarding(undefined, p.pPr);
+            delete p.pPr;
+            return;
+        }
+        const rPr = (_j = p.pPr) === null || _j === void 0 ? void 0 : _j.rPr;
         if (rPr) {
             delete rPr.ins;
             delete rPr.del;
@@ -1011,9 +1416,11 @@ export function joinWithNext(paragraph, fallbackToPrevious = false) {
         return;
     }
     const nextP = next.value;
-    const content = ((_d = p.content) !== null && _d !== void 0 ? _d : (p.content = []));
-    for (const item of (_e = nextP.content) !== null && _e !== void 0 ? _e : [])
+    const content = ((_k = p.content) !== null && _k !== void 0 ? _k : (p.content = []));
+    for (const item of container.slice(i + 1, j))
         content.push(item);
+    for (const item of ((_l = nextP.content) !== null && _l !== void 0 ? _l : []).splice(0))
+        content.push(item); // the next keeps nothing
     linkParents(content, p);
     discarding(undefined, p.pPr); // a section break's sectPr goes with it
     p.pPr = nextP.pPr;
@@ -1030,7 +1437,42 @@ export function joinWithNext(paragraph, fallbackToPrevious = false) {
         else
             p[key] = value;
     }
-    container.splice(i + 1, 1);
+    container.splice(i + 1, j - i);
+}
+/** A block-level control's content, which holds paragraphs. */
+const SDT_CONTENTS = new Set(['org_docx4j_wml.SdtContentBlock', 'org_docx4j_wml.CTSdtContentBlock']);
+/** The first paragraph of a table's first cell, where a paragraph joining into the table lands; docx4j's `firstCellParagraph`. */
+export function firstCellParagraphOf(tbl) {
+    var _a, _b;
+    for (const row of ((_a = tbl.content) !== null && _a !== void 0 ? _a : [])) {
+        if (typeNameOf(row) !== 'org_docx4j_wml.Tr')
+            continue;
+        for (const cell of ((_b = row.value.content) !== null && _b !== void 0 ? _b : [])) {
+            if (typeNameOf(cell) !== 'org_docx4j_wml.Tc')
+                continue;
+            return firstParagraphOf(cell.value.content);
+        }
+        return undefined;
+    }
+    return undefined;
+}
+/** The first paragraph among a holder's blocks, before any table; docx4j's `firstParagraph`. */
+function firstParagraphOf(items) {
+    for (const item of items !== null && items !== void 0 ? items : []) {
+        const tn = typeNameOf(item);
+        if (tn === 'org_docx4j_wml.P')
+            return item.value;
+        if (tn === 'org_docx4j_wml.Tbl')
+            return undefined;
+    }
+    return undefined;
+}
+/** A marker that stands between two paragraphs without keeping them apart: a range's start or end, a bookmark's, a permission's, a proofing mark. */
+function isRangeMarker(el) {
+    var _a, _b;
+    const name = (_b = (_a = el.name) === null || _a === void 0 ? void 0 : _a.localPart) !== null && _b !== void 0 ? _b : '';
+    return name.endsWith('RangeStart') || name.endsWith('RangeEnd') || name === 'bookmarkStart' || name === 'bookmarkEnd'
+        || name === 'permStart' || name === 'permEnd' || name === 'proofErr';
 }
 /** A `w:p`'s own attributes, which go with its mark. */
 const PARAGRAPH_ATTRIBUTES = ['paraId', 'textId', 'rsidDel', 'rsidP', 'rsidR', 'rsidRDefault', 'rsidRPr', 'noSpellErr'];
@@ -1043,39 +1485,15 @@ function pruneRowProperties(tr) {
 }
 /** The span of a run-level revision in the paragraph's accepted text; collapsed for a deletion. */
 function spanOf(paragraph, element) {
-    const segs = paragraph.segments();
+    // where the walk passes the element: a deletion stands there in the accepted text, before what follows it
+    let at;
+    const segs = paragraph.segments({ visit: (el, offset) => { if (el === element && at === undefined)
+            at = offset; } });
     const inside = segs.filter((s) => { var _a; return ((_a = s.revision) === null || _a === void 0 ? void 0 : _a.element) === element; });
     if (inside.length > 0)
         return [inside[0].start, inside[inside.length - 1].end];
-    const at = acceptedOffsetOf(paragraph.p, element);
-    return [at, at];
-}
-/** How much accepted text comes before `target` in the paragraph. */
-function acceptedOffsetOf(p, target) {
-    let pos = 0;
-    let found = -1;
-    const visit = (items) => {
-        if (!items || found >= 0)
-            return;
-        for (const el of items) {
-            if (found >= 0)
-                return;
-            if (el === target) {
-                found = pos;
-                return;
-            }
-            if (typeNameOf(el) === 'org_docx4j_wml.R') {
-                pos += segmentsOf({ content: [el] }).map((s) => s.text).join('').length;
-                continue;
-            }
-            const kind = revisionKindOf(el);
-            if (kind === 'del' || kind === 'moveFrom')
-                continue;
-            visit(runItemsOf(el.value));
-        }
-    };
-    visit(runItemsOf(p));
-    return found >= 0 ? found : pos;
+    const end = segs.length > 0 ? segs[segs.length - 1].end : 0;
+    return [at !== null && at !== void 0 ? at : end, at !== null && at !== void 0 ? at : end];
 }
 // --- math (CR-002 section 51) ------------------------------------------------------------------
 /** True for a value of the math model (`m:oMath`, `m:r`, `m:sSup`, ...). */
@@ -1102,7 +1520,7 @@ function resolveMathRun(t, keep) {
     if (i < 0)
         return;
     if (keep) {
-        const moved = ((_b = t.value.rest) !== null && _b !== void 0 ? _b : []);
+        const moved = ((_b = t.value.rest) !== null && _b !== void 0 ? _b : []).splice(0);
         content.splice(i, 1, ...moved);
         linkParents(moved, t.run.value);
         return;
@@ -1110,7 +1528,9 @@ function resolveMathRun(t, keep) {
     discarding(t.item);
     content.splice(i, 1);
     if (!content.some((item) => { var _a; return mathTextOf(item) !== undefined || ((_a = item.value) === null || _a === void 0 ? void 0 : _a.TYPE_NAME) === 'org_docx4j_wml.CTMathRunTrackChange'; })) {
+        const container = t.run.value.PARENT;
         remove(t.runOwner, t.run);
+        dropEmptiedEquation(container);
     }
 }
 /**
@@ -1119,14 +1539,16 @@ function resolveMathRun(t, keep) {
  * whole from its list. An argument's own marker has no structure, and is dropped either way.
  */
 function resolveMathStructure(t, keep) {
-    var _a;
+    var _a, _b;
     if (!keep && t.structure && t.owner) {
+        const container = (_a = t.structure.value) === null || _a === void 0 ? void 0 : _a.PARENT;
         remove(t.owner, t.structure);
+        dropEmptiedEquation(container);
         return;
     }
     const ctrlPr = t.ctrlPr;
     if (!ctrlPr.rPr && t.value.rPr) {
-        ctrlPr.rPr = rPrFromElements((_a = t.value.rPr.egrPrBase) !== null && _a !== void 0 ? _a : []);
+        ctrlPr.rPr = rPrFromElements((_b = t.value.rPr.egrPrBase) !== null && _b !== void 0 ? _b : []);
         linkParents(ctrlPr.rPr, ctrlPr);
     }
     if (t.revision === 'ins')
@@ -1134,6 +1556,37 @@ function resolveMathStructure(t, keep) {
     else
         delete ctrlPr.del;
 }
+/**
+ * An `m:oMath` that a resolution left with nothing in it goes, and an `m:oMathPara` left with none of its
+ * `m:oMath` goes with it, as Word's Accept All of an equation deleted whole has it (check 57, CR-002 section
+ * 62.2, F1; docx4j's `Resolver.mathRun` leaves them). A paragraph whose mark went with the equation is then
+ * empty, or joined to the next one empty-handed. An argument left empty stays: its structure keeps its places.
+ */
+function dropEmptiedEquation(container) {
+    var _a;
+    const equation = container;
+    if ((equation === null || equation === void 0 ? void 0 : equation.TYPE_NAME) !== 'org_docx4j_math.CTOMath' || ((_a = equation.egoMathElements) !== null && _a !== void 0 ? _a : []).length > 0)
+        return;
+    const holder = equation.PARENT;
+    if ((holder === null || holder === void 0 ? void 0 : holder.TYPE_NAME) === 'org_docx4j_math.CTOMathPara') {
+        const i = holder.oMath.indexOf(equation);
+        if (i >= 0)
+            holder.oMath.splice(i, 1);
+        if (holder.oMath.length === 0)
+            removeValue(holder);
+        return;
+    }
+    removeValue(equation);
+}
+/** A value's element taken from the list its `PARENT` keeps. */
+function removeValue(value) {
+    var _a;
+    const parent = value.PARENT;
+    const list = parent ? (_a = runItemsOf(parent)) !== null && _a !== void 0 ? _a : childrenOf(parent) : undefined;
+    const element = list === null || list === void 0 ? void 0 : list.find((e) => e === value || (e === null || e === void 0 ? void 0 : e.value) === value);
+    if (list && element)
+        remove(list, element);
+}
 /** The equation a math piece is in: the outermost level's element, the one in the paragraph. */
 function equationOf(stack) {
     var _a;
@@ -1221,7 +1674,7 @@ function resolveMove(change, action) {
     const t = change.target;
     if (t.kind !== 'run' || !change.paragraph)
         return false;
-    const story = storyOf(change.paragraph.p);
+    const story = storyOf(t.element.value);
     const pieces = movePiecesOf(story);
     const half = pieces.find((piece) => piece.kind === 'half' && piece.element === t.element);
     if (!half || half.kind !== 'half' || half.names.length === 0)
@@ -1286,22 +1739,36 @@ function resolveMove(change, action) {
         dissolveBrokenMoves(story);
     return true;
 }
-/** The story a paragraph is in: the outermost array of block content above it (a body, a header, a note). */
-function storyOf(p) {
+/**
+ * The story a paragraph is in, for its moves: the outermost array of block content above it (a body, a
+ * header, a note). A kept `mc:AlternateContent`'s selected branch is part of the story it stands in, as
+ * Word reads it; another branch is a story of its own, its list (docx4j's twin stories, its CR-051 phase
+ * 2; CR-013 phase 3), so a move is paired within the branch. `value` may be the paragraph or anything in
+ * it, a run-level branch's revision among them.
+ */
+export function storyOf(value) {
     let story;
-    for (let o = p; o !== undefined; o = o.PARENT) {
+    for (let o = value; o !== undefined; o = o.PARENT) {
+        const tn = o.TYPE_NAME;
+        if (tn !== undefined && BRANCH_TYPES.has(tn)) {
+            const ac = o.PARENT;
+            const items = o.any;
+            if (ac && items && selectedBranchOf(ac) !== items)
+                return items;
+            continue;
+        }
         const content = o.content;
-        if (Array.isArray(content) && o.TYPE_NAME !== 'org_docx4j_wml.P')
+        if (Array.isArray(content) && tn !== 'org_docx4j_wml.P')
             story = content;
     }
     return story !== null && story !== void 0 ? story : [];
 }
 /** Every piece of move markup in a story, in document order, each half and mark with the names of the ranges open over it. */
-function movePiecesOf(story) {
+export function movePiecesOf(story) {
     const out = [];
     const open = { from: new Map(), to: new Map() };
     const visit = (items, runLevel = false) => {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g;
         for (const el of items) {
             const marker = RANGE_MARKERS[(_b = (_a = el.name) === null || _a === void 0 ? void 0 : _a.localPart) !== null && _b !== void 0 ? _b : ''];
             const value = el.value;
@@ -1331,11 +1798,18 @@ function movePiecesOf(story) {
             const v = el.value;
             if (typeof v !== 'object' || v === null)
                 continue;
-            const children = (_e = childrenOf(v)) !== null && _e !== void 0 ? _e : runItemsOf(v);
+            // a kept mc:AlternateContent at block, row or cell level: its selected branch, part of this story
+            // (`storyOf`); among runs it is one object, as before (CR-010 phase 3)
+            if (typeNameOf(el) === ALTERNATE_CONTENT) {
+                if (!runLevel)
+                    visit((_e = selectedBranchOf(v)) !== null && _e !== void 0 ? _e : []);
+                continue;
+            }
+            const children = (_f = childrenOf(v)) !== null && _f !== void 0 ? _f : runItemsOf(v);
             if (children)
                 visit(children, typeNameOf(el) === 'org_docx4j_wml.P');
             if (typeNameOf(el) === 'org_docx4j_wml.P') {
-                const rPr = (_f = v.pPr) === null || _f === void 0 ? void 0 : _f.rPr;
+                const rPr = (_g = v.pPr) === null || _g === void 0 ? void 0 : _g.rPr;
                 for (const side of ['from', 'to']) {
                     if (rPr === null || rPr === void 0 ? void 0 : rPr[side === 'from' ? 'moveFrom' : 'moveTo']) {
                         out.push({ kind: 'mark', side, paragraph: el, container: items, names: [...open[side].values()] });
@@ -1359,7 +1833,7 @@ function resolveRangelessHalf(change, action) {
     const paragraph = change.paragraph;
     if (t.kind !== 'run' || (t.revision !== 'moveTo' && t.revision !== 'moveFrom') || !paragraph)
         return false;
-    const story = storyOf(paragraph.p);
+    const story = storyOf(t.element.value);
     const pieces = movePiecesOf(story);
     const half = pieces.find((piece) => piece.kind === 'half' && piece.element === t.element);
     if (!half || half.kind !== 'half' || half.names.length > 0)
@@ -1495,18 +1969,76 @@ function markBefore(paragraph) {
 }
 /** Between two tracked changes: something unrevised - text, a paragraph mark, a table - that keeps them apart. */
 export const BREAK = 'break';
+/** The public listing's (`Listing`). */
+export function listedListing() {
+    return { mode: 'listed', extra: [] };
+}
+/** The changes in the other branches each listed change resolves too (`TrackedChange.resolveTwins`). */
+const twinsOf = new WeakMap();
+/**
+ * A kept `mc:AlternateContent`'s changes: its selected branch's into `into`, as Word reads them, keeping
+ * nothing apart (CR-013 phase 2); each other branch's paired with them as twins or, resolve-all's,
+ * listed on their own after the story's (`Listing`). `visit` lists one branch's items, at the element's
+ * level (blocks, rows, cells or runs).
+ */
+export function alternateTokens(ac, visit, into, listing) {
+    const read = selectedBranchOf(ac);
+    const primary = [];
+    visit(read !== null && read !== void 0 ? read : [], primary);
+    into.push(...primary);
+    for (const branch of branchesOf(ac)) {
+        if (branch === read)
+            continue;
+        const tokens = [];
+        visit(branch, tokens);
+        if (listing.mode === 'every')
+            listing.extra.push(BREAK, ...tokens, BREAK);
+        else
+            pairTwins(primary, tokens);
+    }
+}
+/**
+ * Another branch's changes attached to the listed branch's as twins, piece by piece: the n-th single
+ * change of a kind with the n-th of that kind, never by id, as docx4j pairs a text box's `mc:Fallback`
+ * changes and a branch's (its `Lister.pairTwins`; Word gives twins different ids). docx4j pairs the
+ * listed changes, groups included; pieces are paired here, since this listing groups the selected
+ * branch's with what touches the element, so a piece resolved on its own resolves its twin too.
+ */
+export function pairTwins(primary, twins) {
+    var _a, _b;
+    const piecesOf = (tokens) => tokens.flatMap((token) => (token === BREAK ? [] : token.pieces));
+    const byKind = new Map();
+    for (const twin of piecesOf(twins)) {
+        let list = byKind.get(twin.kind);
+        if (!list)
+            byKind.set(twin.kind, list = []);
+        list.push(twin);
+    }
+    const seen = new Map();
+    for (const piece of piecesOf(primary)) {
+        const n = (_a = seen.get(piece.kind)) !== null && _a !== void 0 ? _a : 0;
+        seen.set(piece.kind, n + 1);
+        const twin = (_b = byKind.get(piece.kind)) === null || _b === void 0 ? void 0 : _b[n];
+        if (!twin)
+            continue;
+        let list = twinsOf.get(piece);
+        if (!list)
+            twinsOf.set(piece, list = []);
+        list.push(twin);
+    }
+}
 /**
  * A paragraph's single changes in document order, its mark last, with a `BREAK` wherever unrevised
  * content stands between two of them: `groupTouching` makes the groups from these.
  */
-export function trackedChangeTokensOfParagraph(paragraph) {
+export function trackedChangeTokensOfParagraph(paragraph, listing = listedListing()) {
     var _a, _b, _c, _d;
     const out = [];
     const p = paragraph.p;
     const pPrChange = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.pPrChange;
     if (pPrChange)
         out.push(new TrackedChange({ kind: 'paragraphProperties', value: pPrChange }, paragraph));
-    tokensOfRunLevel(paragraph, ((_b = p.content) !== null && _b !== void 0 ? _b : []), out);
+    tokensOfRunLevel(paragraph, ((_b = p.content) !== null && _b !== void 0 ? _b : []), out, listing);
     const rPr = (_c = p.pPr) === null || _c === void 0 ? void 0 : _c.rPr;
     // a mark whose formatting changed is a piece, grouping with its runs' (check 27: "Before.\r")
     if (rPr === null || rPr === void 0 ? void 0 : rPr.rPrChange)
@@ -1533,17 +2065,17 @@ function sectionText(items, end) {
     while (from > 0 && !(typeNameOf(items[from - 1]) === 'org_docx4j_wml.P' && ((_a = items[from - 1].value.pPr) === null || _a === void 0 ? void 0 : _a.sectPr)))
         from--;
     return items.slice(Math.max(from, 0), end).filter((el) => typeNameOf(el) === 'org_docx4j_wml.P')
-        .map((el) => textOfView(el.value, { view: 'accepted' })).join('\r');
+        .map((el) => textOfView(el.value, { view: 'accepted', characters: 'textOf' })).join('\r');
 }
-function tokensOfRunLevel(paragraph, items, out) {
+function tokensOfRunLevel(paragraph, items, out, listing) {
     var _a, _b, _c;
     for (let i = 0; i < items.length; i++) {
         const el = items[i];
         // an inline control or custom XML element that is itself an insertion: a piece, then what is in it
-        const inserted = holderInsertionAt(items, i, paragraph);
+        const inserted = holderChangeAt(items, i, paragraph);
         if (inserted) {
             out.push(inserted);
-            tokensOfRunLevel(paragraph, (_a = childrenOf(items[i + 1].value)) !== null && _a !== void 0 ? _a : [], out);
+            tokensOfRunLevel(paragraph, (_a = childrenOf(items[i + 1].value)) !== null && _a !== void 0 ? _a : [], out, listing);
             i += 2;
             continue;
         }
@@ -1572,7 +2104,7 @@ function tokensOfRunLevel(paragraph, items, out) {
             if (nested) {
                 // a revision inside a revision (a deletion of inserted text) was not measured: listed apart
                 const inner = [];
-                tokensOfRunLevel(paragraph, nested, inner);
+                tokensOfRunLevel(paragraph, nested, inner, listing);
                 if (inner.some((token) => token !== BREAK && token.target.kind === 'run'))
                     out.push(BREAK, ...inner, BREAK);
                 else
@@ -1591,6 +2123,12 @@ function tokensOfRunLevel(paragraph, items, out) {
                 out.push(BREAK);
             continue;
         }
+        // a kept mc:AlternateContent among runs: its selected branch, as Word reads it, keeping nothing apart
+        // (CR-013 phase 2; docx4j CR-051 section 10.5 item 3), the other branches' changes its twins (phase 3)
+        if (typeNameOf(el) === ALTERNATE_CONTENT) {
+            alternateTokens(el.value, (branch, into) => tokensOfRunLevel(paragraph, branch, into, listing), out, listing);
+            continue;
+        }
         // a run holder that is not itself an insertion - a hyperlink, a field, a control or custom XML
         // element that was there - keeps the insertions inside it apart from those outside: Office JS
         // listed "before ", "link" and " after" as three changes over a w:ins in a w:hyperlink, and the same
@@ -1599,7 +2137,7 @@ function tokensOfRunLevel(paragraph, items, out) {
         const nested = runItemsOf(el.value);
         if (nested) {
             out.push(BREAK);
-            tokensOfRunLevel(paragraph, nested, out);
+            tokensOfRunLevel(paragraph, nested, out, listing);
             out.push(BREAK);
         }
     }
@@ -1617,7 +2155,9 @@ function groupable(change) {
         return t.revision;
     if (t.kind === 'runProperties' || t.kind === 'markProperties')
         return 'format';
-    if (t.kind === 'holder' || t.kind === 'field')
+    if (t.kind === 'holder')
+        return t.revision;
+    if (t.kind === 'field')
         return 'ins';
     if (t.kind === 'mathRun' || t.kind === 'mathStructure')
         return t.revision;
@@ -1663,7 +2203,7 @@ export function groupTouching(tokens) {
         const first = item[0];
         if (item.length === 1)
             return first;
-        return new TrackedChange({ kind: 'group', revision: groupable(first), pieces: item, value: first.target.value }, first.paragraph);
+        return new TrackedChange({ kind: 'group', revision: groupable(first), pieces: item, value: first.target.value }, first.paragraph, first.body);
     });
 }
 /**
@@ -1681,9 +2221,9 @@ export function trackedChangesOfRow(tr, owner, inner = [], table, body) {
 }
 // --- CR-002 section 35: tables, cells, marks and sections --------------------------------------------
 /** The change a table's property records make, one per table, or undefined when they make none. */
-export function tablePropertiesChangeOf(tbl) {
+export function tablePropertiesChangeOf(tbl, body) {
     const records = tableRecordsOf(tbl.value);
-    return records ? new TrackedChange({ kind: 'tableProperties', tbl, value: records.value }, undefined) : undefined;
+    return records ? new TrackedChange({ kind: 'tableProperties', tbl, value: records.value }, undefined, body) : undefined;
 }
 /** A cell's own revision, `w:cellIns` or `w:cellDel`, or undefined. */
 export function cellChangeOf(tc, owner, tr, body) {
@@ -1695,30 +2235,37 @@ export function cellChangeOf(tc, owner, tr, body) {
     return undefined;
 }
 /** The change to the body's last section (`w:body/w:sectPr/w:sectPrChange`), its text the section's paragraphs'. */
-export function bodySectionChangeOf(container) {
+export function bodySectionChangeOf(container, body) {
     var _a;
     const sectPr = container.sectPr;
     if (!(sectPr === null || sectPr === void 0 ? void 0 : sectPr.sectPrChange))
         return undefined;
     const items = (_a = container.content) !== null && _a !== void 0 ? _a : [];
-    return new TrackedChange({ kind: 'sectionProperties', sectPr, value: sectPr.sectPrChange, text: sectionText(items, items.length) }, undefined);
+    return new TrackedChange({ kind: 'sectionProperties', sectPr, value: sectPr.sectPrChange, text: sectionText(items, items.length) }, undefined, body);
 }
 /**
  * A cell taken out of its row, the cell before it (else after it) widened over its grid columns, as
  * Word did rejecting an inserted cell and accepting a deleted one (check 27: `w:gridSpan` 2 and the
- * two widths added).
+ * two widths added). The neighbour is the row's as a reader sees it, through cell-level controls and a
+ * kept `mc:AlternateContent`'s selected branch; a cell in another branch (a twin) has its own branch's
+ * cells for neighbours, and one alone there widens none, the row's neighbour having been widened once
+ * when the selected branch's cell went, every branch spanning the same columns (CR-013 phase 3, docx4j's
+ * `Tables.removeCell`, its 60bd4b9ad and 901a922a3).
  */
-function removeCell(tc, owner) {
+function removeCell(tc, owner, tr) {
     var _a, _b, _c, _d, _e, _f, _g;
     var _h;
-    const i = owner.indexOf(tc);
+    const list = currentOwner(owner, tc);
+    const i = list.indexOf(tc);
     if (i < 0)
         return;
-    const cells = owner.filter((el) => typeNameOf(el) === 'org_docx4j_wml.Tc');
+    let cells = cellsOf(tr, 'read').map((cell) => cell.element);
+    if (!cells.includes(tc))
+        cells = list.filter((el) => typeNameOf(el) === 'org_docx4j_wml.Tc');
     const at = cells.indexOf(tc);
     const neighbour = (_a = cells[at - 1]) !== null && _a !== void 0 ? _a : cells[at + 1];
     discarding(tc);
-    owner.splice(i, 1);
+    list.splice(i, 1);
     if (!neighbour)
         return;
     const removed = tc.value.tcPr;
@@ -1774,7 +2321,8 @@ function restoreSection(sectPr, change) {
  * 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). A `w:customXmlInsRangeStart` or `End` left without
- * the form `holderInsertionAt` lists marks nothing that can be found, and goes either way.
+ * the form `holderChangeAt` lists marks nothing that can be found, and goes either way. Every branch
+ * of a kept `mc:AlternateContent` at block, row and cell level is swept (CR-013 phase 3).
  */
 export function resolveUnlisted(items, what) {
     const visit = (list) => {
@@ -1783,7 +2331,7 @@ export function resolveUnlisted(items, what) {
             return;
         for (let i = list.length - 1; i >= 0; i--) {
             const name = (_a = list[i].name) === null || _a === void 0 ? void 0 : _a.localPart;
-            if (name === 'customXmlInsRangeStart' || name === 'customXmlInsRangeEnd')
+            if (HOLDER_MARKERS.has(name !== null && name !== void 0 ? name : ''))
                 list.splice(i, 1);
         }
         for (const el of list) {
@@ -1799,8 +2347,8 @@ export function resolveUnlisted(items, what) {
                 const tbl = el.value;
                 if (hasTableRecords(tbl) && !tableRecordsOf(tbl))
                     acceptTable(tbl);
-                for (const row of rowsOf(tbl)) {
-                    for (const cell of cellsOf(row.element.value)) {
+                for (const row of rowsOf(tbl, 'every')) {
+                    for (const cell of cellsOf(row.element.value, 'every')) {
                         const tcPr = cell.element.value.tcPr;
                         if (tcPr === null || tcPr === void 0 ? void 0 : tcPr.cellMerge)
                             resolveCellMerge(tcPr, what);
@@ -1810,25 +2358,38 @@ export function resolveUnlisted(items, what) {
                 continue;
             }
             const v = el.value;
-            if (typeof v === 'object' && v !== null)
+            if (typeof v !== 'object' || v === null)
+                continue;
+            // every branch of a kept mc:AlternateContent (CR-013 phase 3)
+            if (tn === ALTERNATE_CONTENT)
+                for (const branch of branchesOf(v))
+                    visit(branch);
+            else
                 visit(childrenOf(v));
         }
     };
     visit(items);
 }
-/** Stray `w:customXmlInsRangeStart` / `End` markers taken out of run-level content, through its holders and revisions. */
+/** A holder's insertion and deletion markers: one left without the form `holderChangeAt` lists goes either way. */
+const HOLDER_MARKERS = new Set(['customXmlInsRangeStart', 'customXmlInsRangeEnd', 'customXmlDelRangeStart', 'customXmlDelRangeEnd']);
+/** Stray `w:customXmlInsRangeStart` / `End` markers (or `Del`) taken out of run-level content, through its holders and revisions. */
 function sweepMarkers(items) {
     var _a;
     if (!items)
         return;
     for (let i = items.length - 1; i >= 0; i--) {
         const name = (_a = items[i].name) === null || _a === void 0 ? void 0 : _a.localPart;
-        if (name === 'customXmlInsRangeStart' || name === 'customXmlInsRangeEnd') {
+        if (HOLDER_MARKERS.has(name !== null && name !== void 0 ? name : '')) {
             items.splice(i, 1);
             continue;
         }
         const v = items[i].value;
-        if (typeof v === 'object' && v !== null)
+        if (typeof v !== 'object' || v === null)
+            continue;
+        if (typeNameOf(items[i]) === ALTERNATE_CONTENT)
+            for (const branch of branchesOf(v))
+                sweepMarkers(branch);
+        else
             sweepMarkers(runItemsOf(v));
     }
 }