@docx4j/core-ts 0.4.0 → 0.6.0

package/dist/model/content/TrackedChange.mjs

@@ -1,23 +1,29 @@
 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';
 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, 
     /** The paragraph the change is in; undefined for a row revision. */
-    paragraph) {
+    paragraph, 
+    /** The body a change without a paragraph (a row, a cell) is in, for the notes it may take away. */
+    body) {
         this.target = target;
         this.paragraph = paragraph;
+        this.body = body;
     }
     /** Office JS `Word.ChangeTrackingState`. */
     get type() {
@@ -28,7 +34,10 @@ 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';
             default: return 'Formatted';
         }
     }
@@ -47,8 +56,55 @@ 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;
         const t = this.target;
         switch (t.kind) {
             case 'run': return t.element;
@@ -58,12 +114,15 @@ export class TrackedChange {
             case 'cell': return t.tc;
             case 'sectionProperties': return t.sectPr;
             case 'holder': return t.holder;
+            case 'field': return t.span[0];
+            case 'mathRun': return t.item;
+            case 'mathStructure': return (_a = t.structure) !== null && _a !== void 0 ? _a : t.ctrlPr;
             default: return t.value;
         }
     }
     /** The text the change covers; `\r` for a paragraph mark, as Office JS gives it (check 22). */
     get text() {
-        var _a, _b;
+        var _a, _b, _c;
         const t = this.target;
         switch (t.kind) {
             case 'mark': return '\r';
@@ -72,17 +131,22 @@ 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', 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
             case 'row': return rowText(t.tr.value, t.row === 'del' ? 'original' : 'accepted');
+            // an equation's text: its m:t, as docx4j gives it; a structure's own marker covers no text
+            case 'mathRun': return ((_c = t.value.rest) !== null && _c !== void 0 ? _c : []).map((item) => { var _a; return (_a = mathTextOf(item)) !== null && _a !== void 0 ? _a : ''; }).join('');
             default: return '';
         }
     }
     /** 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;
@@ -92,11 +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') && ((_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] = 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);
@@ -104,13 +212,43 @@ export class TrackedChange {
                 return p.getRange('Start');
             return new Range(p, segs[0].start, segs[segs.length - 1].end);
         }
+        // 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 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');
     }
     /**
      * 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() {
+        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;
         const t = this.target;
         switch (t.kind) {
@@ -159,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;
@@ -171,16 +309,85 @@ 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) {
+                    if (revisionKindOf(el) === 'ins')
+                        unwrap({ kind: 'run', revision: 'ins', element: el, owner: currentOwner(t.owner, el), value: el.value });
+                }
+                return;
+            case 'mathRun':
+                resolveMathRun(t, t.revision === 'ins');
+                return;
+            case 'mathStructure':
+                resolveMathStructure(t, t.revision === 'ins');
                 return;
         }
     }
     /**
      * 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() {
+        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;
         const t = this.target;
         switch (t.kind) {
@@ -229,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);
@@ -238,13 +445,35 @@ 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);
+                return;
+            case 'mathRun':
+                resolveMathRun(t, t.revision === 'del');
+                return;
+            case 'mathStructure':
+                resolveMathStructure(t, t.revision === 'del');
                 return;
         }
     }
+    /** The body the change is in. */
+    get body_() {
+        var _a, _b;
+        return (_b = (_a = this.paragraph) === null || _a === void 0 ? void 0 : _a.parentBody) !== null && _b !== void 0 ? _b : this.body;
+    }
+    /** The package the change is in, which keeps the notes whose references it took away. */
+    get package_() {
+        var _a;
+        return (_a = this.body_) === null || _a === void 0 ? void 0 : _a.package_;
+    }
     requireParagraph() {
         if (!this.paragraph)
             throw new Docx4JException('This tracked change has no paragraph');
@@ -268,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;
                     }
                 }
@@ -288,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) {
@@ -351,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--)
@@ -360,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;
@@ -375,10 +604,331 @@ function currentOwner(owner, element) {
 function remove(owner, element) {
     const list = currentOwner(owner, element);
     const i = list.indexOf(element);
-    if (i >= 0)
-        list.splice(i, 1);
+    if (i < 0)
+        return;
+    discarding(element);
+    list.splice(i, 1);
+}
+let resolution;
+/**
+ * Runs `resolve`, then takes away what went with the content it removed:
+ * - **Notes**: Word took a footnote from the notes part when its reference went with the content
+ *   around it, accepting a deletion and rejecting an insertion alike (the editor's `review-for-word`
+ *   saves, Word 15 and Word 2010); the entries go when the package is saved
+ *   (`WordprocessingMLPackage.pendingNoteRemovals`).
+ * - **Bookmarks**: Word removed a bookmark whole when its end went with a deletion it accepted, and
+ *   when the insertion it was put around went with a reject (docx4j CR-043's probe, C11 and C11b, Word
+ *   16.0.20326). docx4j's rule from the two (its CR-043 section 3.2) is followed here: a bookmark with a
+ *   marker in removed content goes whole, its other marker too, even with content left beside it; so
+ *   does one with content between its markers that is left with none, a deletion it was around accepted
+ *   among them (U15); and one that was empty before, as `_GoBack` is, stays. Those three are not measured.
+ * - **Relationships and parts**: Word's saves kept no part the resolved content alone referenced. A
+ *   picture deleted and accepted, or inserted and rejected, took its image part (docx4j CR-043's probe,
+ *   C05 and C04), and a section break deleted and accepted took the headers and footers of the section
+ *   it ended (C06: six of each became three). docx4j's rule (its CR-043 section 3.2, D7) is followed: a
+ *   relationship of the change's part that the removed content referenced, through any `r:` attribute,
+ *   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, _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 {
+            resolve();
+        }
+        finally {
+            outer.notes = previous;
+        }
+        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 && ((_f = done.relationships) === null || _f === void 0 ? void 0 : _f.size))
+            dropRelationshipsUnused(done.part, done.relationships);
+    }
+    finally {
+        resolution = undefined;
+    }
+}
+/** The tree a body's bookmarks are read in: its part's, so a marker in another cell or paragraph is found. */
+function storyRootOf(body) {
+    var _a;
+    if (!body)
+        return undefined;
+    return ((_a = body.part) === null || _a === void 0 ? void 0 : _a.isUnmarshalled) ? body.part.contents : body.container;
+}
+/**
+ * Called before content is removed (or a paragraph mark joins two): records its notes, the relationships
+ * it references, and the bookmarks as they stand. `properties` is a paragraph's `w:pPr` that a join drops,
+ * whose `w:sectPr` references its section's headers and footers.
+ */
+function discarding(element, properties) {
+    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 = ((_c = resolution.relationships) !== null && _c !== void 0 ? _c : (resolution.relationships = new Set()));
+        if (element)
+            relationshipIdsIn(element, into);
+        if (properties)
+            relationshipIdsIn(properties, into);
+    }
+}
+const MATH_NS = 'http://schemas.openxmlformats.org/officeDocument/2006/math';
+/** Run content that is something in the text: a character, a drawing, a field character, a note's reference. */
+const FILLS = new Set(['tab', 'br', 'cr', 'noBreakHyphen', 'softHyphen', 'sym', 'ptab', 'drawing', 'pict', 'object',
+    'fldChar', 'footnoteReference', 'endnoteReference', 'commentReference', 'footnoteRef', 'endnoteRef', 'annotationRef',
+    'separator', 'continuationSeparator', 'pgNum', 'dayShort', 'monthShort', 'yearShort', 'dayLong', 'monthLong', 'yearLong',
+    'contentPart', 'ruby']);
+/** Of those, the ones that can hold a story of their own (a text box), and so bookmarks: walked into. */
+const HOLDS_CONTENT = new Set(['drawing', 'pict', 'object', 'ruby', 'contentPart']);
+const TEXTS = new Set(['t', 'delText', 'instrText', 'delInstrText']);
+/** Properties, which hold no bookmark and no content: not walked. */
+const PROPERTIES = new Set(['PARENT', 'TYPE_NAME', 'name', 'otherAttributes', 'pPr', 'rPr', 'tblPr', 'tblPrEx', 'tblGrid', 'trPr', 'tcPr', 'sectPr', 'sdtPr', 'sdtEndPr']);
+/**
+ * Every bookmark in a tree, by id, in document order. Deleted and inserted content both count as
+ * content, and so does a paragraph's mark, so a bookmark over a paragraph boundary is not empty.
+ */
+function bookmarksIn(root) {
+    const marks = new Map();
+    let open = [];
+    const fill = () => { for (const state of open)
+        state.filled = true; open = []; };
+    const visit = (o) => {
+        var _a, _b, _c, _d;
+        if (typeof o !== 'object' || o === null)
+            return;
+        if (Array.isArray(o)) {
+            for (const item of o)
+                visit(item);
+            return;
+        }
+        const el = o;
+        const local = (_a = el.name) === null || _a === void 0 ? void 0 : _a.localPart;
+        if (local === 'bookmarkStart' || local === 'bookmarkEnd') {
+            const id = String((_b = el.value) === null || _b === void 0 ? void 0 : _b.id);
+            let state = marks.get(id);
+            if (!state)
+                marks.set(id, state = { start: false, end: false, filled: false });
+            if (local === 'bookmarkStart') {
+                state.start = true;
+                open.push(state);
+            }
+            else {
+                state.end = true;
+                open = open.filter((other) => other !== state);
+            }
+            return;
+        }
+        if (local !== undefined && (el.name.namespaceURI === W_NS || el.name.namespaceURI === MATH_NS)) {
+            if (TEXTS.has(local)) {
+                if (String((_d = (_c = el.value) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : '') !== '')
+                    fill();
+                return;
+            }
+            if (FILLS.has(local)) {
+                fill();
+                if (!HOLDS_CONTENT.has(local))
+                    return;
+            }
+        }
+        for (const key in o)
+            if (!PROPERTIES.has(key))
+                visit(o[key]);
+        if (o.TYPE_NAME === 'org_docx4j_wml.P')
+            fill();
+    };
+    visit(root);
+    return marks;
+}
+/**
+ * The bookmarks whole before and broken now - a marker gone, or emptied - taken away, both markers.
+ * One broken already, or gone whole with the content it was in, is left as it is.
+ */
+function dropBookmarksBroken(root, before) {
+    if (before.size === 0)
+        return;
+    const after = bookmarksIn(root);
+    const drop = new Set();
+    for (const [id, was] of before) {
+        if (!was.start || !was.end)
+            continue;
+        const now = after.get(id);
+        if (!now)
+            continue;
+        if (!now.start || !now.end || (was.filled && !now.filled))
+            drop.add(id);
+    }
+    if (drop.size === 0)
+        return;
+    const visit = (o) => {
+        var _a, _b;
+        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 local = (_a = el === null || el === void 0 ? void 0 : el.name) === null || _a === void 0 ? void 0 : _a.localPart;
+                if ((local === 'bookmarkStart' || local === 'bookmarkEnd') && drop.has(String((_b = el.value) === null || _b === void 0 ? void 0 : _b.id)))
+                    o.splice(i, 1);
+                else
+                    visit(el);
+            }
+            return;
+        }
+        for (const key in o)
+            if (!PROPERTIES.has(key))
+                visit(o[key]);
+    };
+    visit(root);
 }
-/** A holder's four insertion markers taken away; the element stays. */
+/**
+ * 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) => {
+        var _a, _b;
+        if (typeof o !== 'object' || o === null)
+            return;
+        if (Array.isArray(o)) {
+            for (const item of o)
+                visit(item);
+            return;
+        }
+        const local = (_a = o.name) === null || _a === void 0 ? void 0 : _a.localPart;
+        if (local === 'footnoteReference' || local === 'endnoteReference') {
+            const id = Number((_b = (o.value)) === null || _b === void 0 ? void 0 : _b.id);
+            if (Number.isInteger(id))
+                into[local === 'footnoteReference' ? 'footnote' : 'endnote'].add(id);
+            return;
+        }
+        for (const [key, value] of Object.entries(o))
+            if (key !== 'PARENT')
+                visit(value);
+    };
+    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
+ * empty. A note's entry goes, Word's separators never: their ids are never referenced. The notes parts
+ * are read only when something is pending, so a save with none leaves them untouched. Word's own save
+ * also renumbers the notes left (the editor's `review-for-word` saves); their ids stay here.
+ *
+ * What a removed note held goes on with it, as docx4j's `Removals.flush` takes it (CR-002 section 50,
+ * docx4j's reading, not measured): the relationships its content referenced (a picture's image) are
+ * queued on `host` for the notes part, to go when nothing else uses them, and a comment whose reference
+ * was in it is queued for removal, its anchor being gone.
+ */
+export async function flushPendingNoteRemovals(main, pending, host) {
+    if (pending.footnote.size === 0 && pending.endnote.size === 0)
+        return;
+    const standing = { footnote: new Set(), endnote: new Set() };
+    noteReferencesIn(await main.getContents(), standing);
+    const prune = (part, notes, ids, kept) => {
+        if (!notes)
+            return;
+        const released = new Set();
+        for (let i = notes.length - 1; i >= 0; i--) {
+            const note = notes[i];
+            if ((note.type === undefined || note.type === 'normal') && ids.has(Number(note.id)) && !kept.has(Number(note.id))) {
+                relationshipIdsIn(note.content, released);
+                if (host === null || host === void 0 ? void 0 : host.pendingCommentRemovals)
+                    commentReferencesIn(note.content, host.pendingCommentRemovals);
+                notes.splice(i, 1);
+            }
+        }
+        queueRelationshipRemovals(host === null || host === void 0 ? void 0 : host.pendingRelationshipRemovals, part, released);
+    };
+    if (pending.footnote.size > 0 && main.footnotesPart)
+        prune(main.footnotesPart, (await main.footnotesPart.getContents()).footnote, pending.footnote, standing.footnote);
+    if (pending.endnote.size > 0 && main.endnotesPart)
+        prune(main.endnotesPart, (await main.endnotesPart.getContents()).endnote, pending.endnote, standing.endnote);
+    pending.footnote.clear();
+    pending.endnote.clear();
+}
+/** Adds the ids of the `w:commentReference` elements anywhere in a tree to `into`. */
+export function commentReferencesIn(tree, into) {
+    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;
+        }
+        if (((_a = o.name) === null || _a === void 0 ? void 0 : _a.localPart) === 'commentReference') {
+            const id = Number((_b = (o.value)) === null || _b === void 0 ? void 0 : _b.id);
+            if (Number.isInteger(id))
+                into.add(id);
+            return;
+        }
+        for (const [key, value] of Object.entries(o))
+            if (key !== 'PARENT')
+                visit(value);
+    };
+    visit(tree);
+}
+/** 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]);
@@ -404,26 +954,110 @@ 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
+ * runs between them go, last first so that a comment's range is judged once the field's text is gone;
+ * a bookmark, a comment's range or a proofing mark between them stays where it stood.
+ */
+function removeField(t, paragraph) {
+    for (let i = t.span.length - 1; i >= 0; i--) {
+        const el = t.span[i];
+        if (revisionKindOf(el) === 'ins')
+            removeRevision({ kind: 'run', revision: 'ins', element: el, owner: currentOwner(t.owner, el), value: el.value }, paragraph);
+        else if (typeNameOf(el) === 'org_docx4j_wml.R')
+            remove(t.owner, el);
+    }
+}
+/**
+ * Word's form for a field inserted under tracking, when `items[i]` starts it: a `w:ins` that opens a
+ * field (a `w:fldChar` begin it does not end), then plain runs - the separator and the result - and
+ * markers, then a `w:ins` by the same author in which that field ends (check 30, `field-inserted`:
+ * begin and instruction in one, the end run in the other). Another revision, a run whose formatting
+ * changed, a run holder, or a field that ends in a plain run is not this form, and is listed as before.
+ * A field wholly inside one `w:ins` needs nothing of this: that `w:ins` already takes it whole.
+ */
+export function insertedFieldAt(items, i, paragraph) {
+    var _a;
+    const first = items[i];
+    if (revisionKindOf(first) !== 'ins')
+        return undefined;
+    const author = first.value.author;
+    let depth = 0;
+    // the fldChars of an element's runs in order: 'closed' when the field the span opened ends
+    const scan = (el) => {
+        var _a, _b, _c;
+        const runs = typeNameOf(el) === 'org_docx4j_wml.R' ? [el] : (_a = runItemsOf(el.value)) !== null && _a !== void 0 ? _a : [];
+        for (const run of runs) {
+            if (typeNameOf(run) !== 'org_docx4j_wml.R')
+                continue;
+            for (const item of (_b = run.value.content) !== null && _b !== void 0 ? _b : []) {
+                if (((_c = item.name) === null || _c === void 0 ? void 0 : _c.localPart) !== 'fldChar')
+                    continue;
+                const type = item.value.fldCharType;
+                if (type === 'begin')
+                    depth++;
+                else if (type === 'end') {
+                    depth--;
+                    if (depth < 0)
+                        return 'other';
+                    if (depth === 0)
+                        return 'closed';
+                }
+            }
+        }
+        return 'open';
+    };
+    if (scan(first) !== 'open' || depth === 0)
+        return undefined;
+    for (let j = i + 1; j < items.length; j++) {
+        const el = items[j];
+        const kind = revisionKindOf(el);
+        if (kind === 'ins') {
+            if (el.value.author !== author)
+                return undefined;
+            const state = scan(el);
+            if (state === 'other')
+                return undefined;
+            if (state === 'closed')
+                return new TrackedChange({ kind: 'field', span: items.slice(i, j + 1), owner: items, value: first.value }, paragraph);
+            continue;
+        }
+        if (kind !== undefined)
+            return undefined;
+        const v = el.value;
+        if (typeNameOf(el) === 'org_docx4j_wml.R') {
+            if (((_a = v.rPr) === null || _a === void 0 ? void 0 : _a.rPrChange) || scan(el) !== 'open')
+                return undefined;
+            continue;
+        }
+        if (typeof v === 'object' && v !== null && runItemsOf(v))
+            return undefined;
+    }
+    return undefined;
 }
 /**
  * A row taken away, and its table with it when it was the last: a table has no revision of its own,
@@ -432,68 +1066,204 @@ export function holderInsertionAt(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);
     const body = paragraph === null || paragraph === void 0 ? void 0 : paragraph.parentBody;
     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;
@@ -524,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);
@@ -558,27 +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;
@@ -587,10 +1416,13 @@ 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;
     if (p.pPr)
         linkParents(p.pPr, p);
@@ -605,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'];
@@ -618,39 +1485,175 @@ 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;
+    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`, ...). */
+function isMathValue(value) {
+    const tn = value === null || value === void 0 ? void 0 : value.TYPE_NAME;
+    return typeof tn === 'string' && tn.startsWith('org_docx4j_math.');
+}
+/** The text of an `m:t` (or a `w:t`) in an `m:r`; undefined for anything else. */
+function mathTextOf(item) {
+    var _a, _b, _c;
+    if (((_a = item === null || item === void 0 ? void 0 : item.name) === null || _a === void 0 ? void 0 : _a.localPart) !== 't')
+        return undefined;
+    return String((_c = (_b = item.value) === null || _b === void 0 ? void 0 : _b.value) !== null && _c !== void 0 ? _c : '');
+}
+/**
+ * A math run's revision resolved: `keep` (an insertion accepted, a deletion rejected) puts its content in
+ * its place in the `m:r`; otherwise it goes, and the `m:r` with it when no text is left in it (docx4j's
+ * reading of Word's Accept All and Reject All of `tracked-changes-equations.docx`).
+ */
+function resolveMathRun(t, keep) {
+    var _a, _b;
+    const content = ((_a = t.run.value.content) !== null && _a !== void 0 ? _a : []);
+    const i = content.indexOf(t.item);
+    if (i < 0)
+        return;
+    if (keep) {
+        const moved = ((_b = t.value.rest) !== null && _b !== void 0 ? _b : []).splice(0);
+        content.splice(i, 1, ...moved);
+        linkParents(moved, t.run.value);
+        return;
+    }
+    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);
+    }
+}
+/**
+ * A structure's insertion or deletion resolved: `keep` drops the marker, its recorded run properties
+ * becoming the control's when it has none, as Word's saves have them; otherwise the structure goes
+ * whole from its list. An argument's own marker has no structure, and is dropped either way.
+ */
+function resolveMathStructure(t, keep) {
+    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((_b = t.value.rPr.egrPrBase) !== null && _b !== void 0 ? _b : []);
+        linkParents(ctrlPr.rPr, ctrlPr);
+    }
+    if (t.revision === 'ins')
+        delete ctrlPr.ins;
+    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;
+    const top = (_a = stack[0]) === null || _a === void 0 ? void 0 : _a.item;
+    return top && typeof top === 'object' && 'name' in top ? { equation: top } : {};
+}
+/**
+ * An equation's single changes, in document order, docx4j's walk (its CR-043 `Lister.math`): a
+ * revision inside an `m:r`; a structure's, in its `m:ctrlPr`, which comes before the structure's
+ * arguments; and a run-level revision holding math. A math run with text and no revision keeps the
+ * pieces either side apart, as plain text does.
+ */
+function mathTokens(paragraph, value, item, owner, stack, out) {
+    var _a;
+    const tn = value.TYPE_NAME;
+    if (tn === 'org_docx4j_math.CTR') {
+        for (const c of ((_a = value.content) !== null && _a !== void 0 ? _a : [])) {
+            const cv = c === null || c === void 0 ? void 0 : c.value;
+            if ((cv === null || cv === void 0 ? void 0 : cv.TYPE_NAME) === 'org_docx4j_wml.CTMathRunTrackChange' && owner) {
+                out.push(new TrackedChange({ kind: 'mathRun', revision: c.name.localPart === 'del' ? 'del' : 'ins', item: c, run: item, runOwner: owner, value: cv, ...equationOf(stack) }, paragraph));
             }
-            if (typeNameOf(el) === 'org_docx4j_wml.R') {
-                pos += segmentsOf({ content: [el] }).map((s) => s.text).join('').length;
-                continue;
+            else if (mathTextOf(c) !== undefined)
+                out.push(BREAK);
+        }
+        return;
+    }
+    if (tn === 'org_docx4j_math.CTCtrlPr') {
+        const ctrlPr = value;
+        if (!ctrlPr.ins && !ctrlPr.del)
+            return;
+        // in m:sSupPr in m:sSup, the structure is two up; an argument's (m:e's) own marks none
+        const parent = stack[stack.length - 1];
+        const grand = parent && parent.value.TYPE_NAME !== 'org_docx4j_math.CTOMathArg' ? stack[stack.length - 2] : undefined;
+        const structure = { ...((grand === null || grand === void 0 ? void 0 : grand.owner) ? { structure: grand.item, owner: grand.owner } : {}), ...equationOf(stack) };
+        if (ctrlPr.ins)
+            out.push(new TrackedChange({ kind: 'mathStructure', revision: 'ins', ctrlPr, value: ctrlPr.ins, ...structure }, paragraph));
+        if (ctrlPr.del)
+            out.push(new TrackedChange({ kind: 'mathStructure', revision: 'del', ctrlPr, value: ctrlPr.del, ...structure }, paragraph));
+        return;
+    }
+    stack.push({ value, item, owner });
+    for (const key of Object.keys(value)) {
+        if (key === 'PARENT' || key === 'TYPE_NAME')
+            continue;
+        const field = value[key];
+        if (typeof field !== 'object' || field === null)
+            continue;
+        if (Array.isArray(field)) {
+            const list = field;
+            for (const c of list) {
+                if (typeof c !== 'object' || c === null)
+                    continue;
+                const kind = revisionKindOf(c);
+                if (kind !== undefined) {
+                    // a w:ins or w:del holding m:r: as runs (schema-legal; docx4j's U7, in no fixture)
+                    out.push(new TrackedChange({ kind: 'run', revision: kind, element: c, owner: list, value: c.value }, paragraph));
+                    continue;
+                }
+                const cv = c !== null && typeof c === 'object' && 'value' in c && 'name' in c ? c.value : c;
+                if (isMathValue(cv))
+                    mathTokens(paragraph, cv, c, list, stack, out);
             }
-            const kind = revisionKindOf(el);
-            if (kind === 'del' || kind === 'moveFrom')
-                continue;
-            visit(runItemsOf(el.value));
         }
-    };
-    visit(runItemsOf(p));
-    return found >= 0 ? found : pos;
+        else if (isMathValue(field))
+            mathTokens(paragraph, field, field, undefined, stack, out);
+    }
+    stack.pop();
 }
 const RANGE_MARKERS = {
     moveFromRangeStart: { kind: 'start', side: 'from' }, moveFromRangeEnd: { kind: 'end', side: 'from' },
@@ -671,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)
@@ -736,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;
@@ -781,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()] });
@@ -809,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)
@@ -945,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)
@@ -983,20 +2065,32 @@ 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;
         }
+        // a field Word inserted, its separator and result plain between two insertions: one piece
+        const field = insertedFieldAt(items, i, paragraph);
+        if (field && field.target.kind === 'field') {
+            out.push(field);
+            i += field.target.span.length - 1;
+            continue;
+        }
+        // an equation: the revisions in its runs and on its structures (section 51)
+        if (isMathValue(el.value)) {
+            mathTokens(paragraph, el.value, el, items, [], out);
+            continue;
+        }
         const kind = revisionKindOf(el);
         if (kind !== undefined) {
             // moved text is content Office JS cannot list (checks 16, 17), and is kept apart
@@ -1010,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
@@ -1029,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
@@ -1037,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);
         }
     }
@@ -1056,7 +2156,11 @@ function groupable(change) {
     if (t.kind === 'runProperties' || t.kind === 'markProperties')
         return 'format';
     if (t.kind === 'holder')
+        return t.revision;
+    if (t.kind === 'field')
         return 'ins';
+    if (t.kind === 'mathRun' || t.kind === 'mathStructure')
+        return t.revision;
     // an inserted or deleted row groups with rows and text touching it: Office JS lists an inserted
     // table of three rows, with the inserted paragraphs before and after it, as one change, and rows
     // added to a table that was there as one change per touching run of them (check 31)
@@ -1099,61 +2203,69 @@ 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);
     });
 }
 /**
  * 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 function trackedChangesOfRow(tr, owner, inner = [], table) {
+export function trackedChangesOfRow(tr, owner, inner = [], table, body) {
     const trPr = tr.value.trPr;
     const out = [];
     if (trPr === null || trPr === void 0 ? void 0 : trPr.ins)
-        out.push(new TrackedChange({ kind: 'row', row: 'ins', tr, owner, value: trPr.ins, inner, table }, undefined));
+        out.push(new TrackedChange({ kind: 'row', row: 'ins', tr, owner, value: trPr.ins, inner, table }, undefined, body));
     if (trPr === null || trPr === void 0 ? void 0 : trPr.del)
-        out.push(new TrackedChange({ kind: 'row', row: 'del', tr, owner, value: trPr.del, inner, table }, undefined));
+        out.push(new TrackedChange({ kind: 'row', row: 'del', tr, owner, value: trPr.del, inner, table }, undefined, body));
     return out;
 }
 // --- 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) {
+export function cellChangeOf(tc, owner, tr, body) {
     const tcPr = tc.value.tcPr;
     if (tcPr === null || tcPr === void 0 ? void 0 : tcPr.cellIns)
-        return new TrackedChange({ kind: 'cell', cell: 'ins', tc, owner, tr, value: tcPr.cellIns }, undefined);
+        return new TrackedChange({ kind: 'cell', cell: 'ins', tc, owner, tr, value: tcPr.cellIns }, undefined, body);
     if (tcPr === null || tcPr === void 0 ? void 0 : tcPr.cellDel)
-        return new TrackedChange({ kind: 'cell', cell: 'del', tc, owner, tr, value: tcPr.cellDel }, undefined);
+        return new TrackedChange({ kind: 'cell', cell: 'del', tc, owner, tr, value: tcPr.cellDel }, undefined, 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];
-    owner.splice(i, 1);
+    discarding(tc);
+    list.splice(i, 1);
     if (!neighbour)
         return;
     const removed = tc.value.tcPr;
@@ -1209,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) => {
@@ -1218,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) {
@@ -1234,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);
@@ -1245,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));
     }
 }