@docx4j/core-ts 0.2.1 → 0.3.0

package/dist/model/content/TrackedChange.mjs

@@ -1,9 +1,11 @@
 import { textOf } from '@docx4j/generated-objects-ts/builders/wml';
 import { Docx4JException } from '../../opc/exceptions.mjs';
-import { typeNameOf, runItemsOf, revisionKindOf, linkParents, segmentsOf, textOfView, cellsOf, childrenOf } from './tree.mjs';
+import { typeNameOf, runItemsOf, revisionKindOf, linkParents, segmentsOf, textOfView, cellsOf, rowsOf, childrenOf, W_NS } from './tree.mjs';
 import { Range } from './Range.mjs';
 import { rPrFromElements } from '@docx4j/generated-objects-ts/builders/wml';
-import { dateOf, toRestoredText, restoreRPr, restorePPr, pruneParagraphProperties } from './tracking.mjs';
+import { revisionDateOf, toRestoredText, toDeletedText, restoreRPr, restorePPr, pruneParagraphProperties } from './tracking.mjs';
+import { tableRecordsOf, hasTableRecords, tableChangeText, rowText as tableRowText, acceptTable, rejectTable } from './tableRevisions.mjs';
+import { deepCopy } from '@docx4j/generated-objects-ts';
 /**
  * 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
@@ -23,15 +25,21 @@ export class TrackedChange {
             case 'run': return t.revision === 'ins' || t.revision === 'moveTo' ? 'Added' : 'Deleted';
             case 'mark': return t.mark === 'ins' ? 'Added' : 'Deleted';
             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';
             default: return 'Formatted';
         }
     }
     get author() {
         return this.target.value.author;
     }
-    /** `w:date`, when the markup carries one. */
+    /**
+     * When the change was made: `w16du:dateUtc` if the markup has it, else `w:date` read as Word writes
+     * it, local wall-clock time (`revisionDateOf`, CR-002 section 29); a group's is its first piece's,
+     * as Office JS reports it.
+     */
     get date() {
-        return dateOf(this.target.value.date);
+        return revisionDateOf(this.target.value);
     }
     /** The annotation id (`w:id`; an extension). */
     get id() {
@@ -39,13 +47,28 @@ export class TrackedChange {
     }
     /** The markup this change is over (an extension): the `w:ins` element, the `w:rPrChange`, ... */
     get element() {
-        return this.target.kind === 'run' ? this.target.element : this.target.kind === 'row' ? this.target.tr : this.target.value;
+        const t = this.target;
+        switch (t.kind) {
+            case 'run': return t.element;
+            case 'row': return t.tr;
+            case 'group': return t.pieces[0].element;
+            case 'tableProperties': return t.tbl;
+            case 'cell': return t.tc;
+            case 'sectionProperties': return t.sectPr;
+            default: return t.value;
+        }
     }
-    /** The text the change covers; '' for a paragraph mark, whose range is the paragraph. */
+    /** The text the change covers; `\r` for a paragraph mark, as Office JS gives it (check 22). */
     get text() {
         var _a, _b;
         const t = this.target;
         switch (t.kind) {
+            case 'mark': return '\r';
+            case 'markProperties': return '\r';
+            case 'group': return t.pieces.map((piece) => piece.text).join('');
+            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 'runProperties': return textOf(t.run);
             case 'paragraphProperties': return (_b = (_a = this.paragraph) === null || _a === void 0 ? void 0 : _a.text) !== null && _b !== void 0 ? _b : '';
@@ -65,6 +88,13 @@ export class TrackedChange {
             const [start, end] = spanOf(p, t.element);
             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)
+                return t.pieces[0].getRange();
+            return new Range(p, Math.min(...here.map((r) => r.start)), Math.max(...here.map((r) => r.end)));
+        }
         if (t.kind === 'runProperties') {
             const segs = p.segments().filter((s) => s.run === t.run);
             if (segs.length === 0)
@@ -73,12 +103,17 @@ export class TrackedChange {
         }
         return p.getRange('Whole');
     }
-    /** Keeps the change: a `w:ins` is unwrapped, a `w:del` removed, a deleted mark joins the paragraphs. */
+    /**
+     * 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).
+     */
     accept() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f;
         const t = this.target;
         switch (t.kind) {
             case 'run':
+                if ((t.revision === 'moveFrom' || t.revision === 'moveTo') && (resolveMove(this, 'accept') || resolveRangelessHalf(this, 'accept')))
+                    return;
                 if (t.revision === 'ins' || t.revision === 'moveTo')
                     unwrap(t);
                 else
@@ -104,19 +139,47 @@ export class TrackedChange {
                 // w:trPr/w:ins; an accepted deletion takes the row and everything in it away
                 if (t.row === 'ins') {
                     (_c = t.tr.value.trPr) === null || _c === void 0 ? true : delete _c.ins;
+                    pruneRowProperties(t.tr.value);
                     applyInner(t.inner, 'accept');
                 }
                 else
                     remove(t.owner, t.tr);
                 return;
+            case 'group':
+                resolvePieces(t.pieces, 'accept');
+                return;
+            case 'tableProperties':
+                acceptTable(t.tbl.value);
+                return;
+            case 'cell':
+                // an inserted cell stays, a deleted one goes (check 27)
+                if (t.cell === 'ins')
+                    (_d = t.tc.value.tcPr) === null || _d === void 0 ? true : delete _d.cellIns;
+                else
+                    removeCell(t.tc, t.owner);
+                return;
+            case 'markProperties': {
+                const p = this.requireParagraph().p;
+                (_f = (_e = p.pPr) === null || _e === void 0 ? void 0 : _e.rPr) === null || _f === void 0 ? true : delete _f.rPrChange;
+                pruneParagraphProperties(p);
+                return;
+            }
+            case 'sectionProperties':
+                delete t.sectPr.sectPrChange;
+                return;
         }
     }
-    /** Puts back what was there: a `w:ins` is removed, a `w:del` restored, a `w:rPrChange` re-applied. */
+    /**
+     * 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).
+     */
     reject() {
-        var _a;
+        var _a, _b;
         const t = this.target;
         switch (t.kind) {
             case 'run':
+                if ((t.revision === 'moveFrom' || t.revision === 'moveTo') && (resolveMove(this, 'reject') || resolveRangelessHalf(this, 'reject')))
+                    return;
                 if (t.revision === 'ins' || t.revision === 'moveTo')
                     remove(t.owner, t.element);
                 else
@@ -132,8 +195,10 @@ export class TrackedChange {
                 restoreRPr(t.run, rPrFromElements(t.value.rPr));
                 return;
             case 'paragraphProperties': {
-                const p = this.requireParagraph().p;
-                restorePPr(p, t.value.pPr);
+                const paragraph = this.requireParagraph();
+                restorePPr(paragraph.p, t.value.pPr);
+                dropLevelIndent(paragraph);
+                writeRecordedLevel(paragraph.p);
                 return;
             }
             case 'row':
@@ -141,11 +206,30 @@ export class TrackedChange {
                 // the w:del unwrapped, the deleted marks dropped); a rejected insertion takes it away
                 if (t.row === 'del') {
                     (_a = t.tr.value.trPr) === null || _a === void 0 ? true : delete _a.del;
+                    pruneRowProperties(t.tr.value);
                     applyInner(t.inner, 'reject');
                 }
                 else
                     remove(t.owner, t.tr);
                 return;
+            case 'group':
+                resolvePieces(t.pieces, 'reject');
+                return;
+            case 'tableProperties':
+                rejectTable(t.tbl.value);
+                return;
+            case 'cell':
+                if (t.cell === 'del')
+                    (_b = t.tc.value.tcPr) === null || _b === void 0 ? true : delete _b.cellDel;
+                else
+                    removeCell(t.tc, t.owner);
+                return;
+            case 'markProperties':
+                restoreMarkProperties(this.requireParagraph().p, t.value);
+                return;
+            case 'sectionProperties':
+                restoreSection(t.sectPr, t.value);
+                return;
         }
     }
     requireParagraph() {
@@ -182,6 +266,70 @@ function applyInner(inner, what) {
     for (let i = inner.length - 1; i >= 0; i--)
         inner[i][what]();
 }
+/**
+ * Word records a list paragraph's indent in `w:pPrChange` even where the list level gives it, and on
+ * reject writes no indent back: it restored "The first numbered item." to its numbered list with no
+ * `w:ind`, where the change recorded `left=720 hanging=360`, the level's own (`test/README.md` check
+ * 18, `reject-all.docx`, section 9), and check 25's level-0 items with none where it recorded only
+ * `hanging=360`, part of the level's `left=720 hanging=360` (`25b-bullets-reject.docx`; CR-002
+ * section 29). So a restored `w:ind` whose every attribute is the level's is dropped, leaving the level
+ * to give it; one with an attribute of its own - a genuinely direct indent - is restored. The numbering
+ * part must have been read (`await pkg.getBody()` or `getPropertyResolver()` reads it); when it has
+ * not, the recorded indent is restored as it was.
+ */
+function dropLevelIndent(paragraph) {
+    var _a;
+    const pPr = paragraph.p.pPr;
+    const numPr = pPr === null || pPr === void 0 ? void 0 : pPr.numPr;
+    const ind = pPr === null || pPr === void 0 ? void 0 : pPr.ind;
+    if (!pPr || !numPr || !ind)
+        return;
+    const part = (_a = paragraph.parentBody.package_) === null || _a === void 0 ? void 0 : _a.numberingDefinitionsPart;
+    let level;
+    try {
+        level = part === null || part === void 0 ? void 0 : part.getInd(numPr);
+    }
+    catch {
+        return; // not read: nothing to compare with
+    }
+    if (!level || !indentWithin(ind, level))
+        return;
+    delete pPr.ind;
+    pruneParagraphProperties(paragraph.p);
+}
+/**
+ * A restored `w:numPr` that names a list but no level is at level 0, and Word writes the 0: it
+ * restored the level recorded, not the current one, when the two differed (check 25's
+ * `25e-bullet-demote.docx`, recorded `numId 1` alone and current `ilvl 1`, rejected to `ilvl 0,
+ * numId 1`), and wrote `w:ilvl="0"` every time the record had none (check 18's section 9, 25b, 25f;
+ * CR-002 section 29).
+ */
+function writeRecordedLevel(p) {
+    var _a;
+    const numPr = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.numPr;
+    if (!(numPr === null || numPr === void 0 ? void 0 : numPr.numId) || Number(numPr.numId.val) === 0 || numPr.ilvl)
+        return;
+    numPr.ilvl = { TYPE_NAME: 'org_docx4j_wml.PPrBase.NumPr.Ilvl', val: 0 };
+    linkParents(numPr.ilvl, numPr);
+}
+/** True when every attribute `ind` sets, `level` sets to the same value. */
+function indentWithin(ind, level) {
+    const attributes = Object.entries(ind).filter(([key, value]) => key !== 'TYPE_NAME' && key !== 'PARENT' && value !== undefined);
+    return attributes.length > 0 && attributes.every(([key, value]) => String(level[key]) === String(value));
+}
+/**
+ * A group's pieces resolved: its runs last first, then its marks last first, so that a paragraph join
+ * 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) {
+    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--)
+        runs[i][what]();
+    for (let i = marks.length - 1; i >= 0; i--)
+        marks[i][what]();
+}
 function remove(owner, element) {
     const i = owner.indexOf(element);
     if (i >= 0)
@@ -260,8 +408,28 @@ export function joinWithNext(paragraph, fallbackToPrevious = false) {
     p.pPr = nextP.pPr;
     if (p.pPr)
         linkParents(p.pPr, p);
+    // The mark that survives is the next paragraph's, and so is the paragraph's identity: Word keeps the
+    // second paragraph's w14:paraId when a mark goes (check 18's accept-all and reject-all, check 22's
+    // 22-accept-whole; found by the editor's C5). Its w14:textId and session ids come with it; Word
+    // writes a new textId, the text having changed, which Word will do again when it next saves.
+    for (const key of PARAGRAPH_ATTRIBUTES) {
+        const value = nextP[key];
+        if (value === undefined)
+            delete p[key];
+        else
+            p[key] = value;
+    }
     container.splice(i + 1, 1);
 }
+/** A `w:p`'s own attributes, which go with its mark. */
+const PARAGRAPH_ATTRIBUTES = ['paraId', 'textId', 'rsidDel', 'rsidP', 'rsidR', 'rsidRDefault', 'rsidRPr', 'noSpellErr'];
+/** A row's `w:trPr` with nothing left in it goes, as Word writes none (check 18's accept-all and reject-all). */
+function pruneRowProperties(tr) {
+    var _a;
+    const trPr = tr.trPr;
+    if (trPr && !trPr.ins && !trPr.del && !trPr.trPrChange && !((_a = trPr.cnfStyleOrDivIdOrGridBefore) === null || _a === void 0 ? void 0 : _a.length))
+        delete tr.trPr;
+}
 /** 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();
@@ -298,45 +466,430 @@ function acceptedOffsetOf(p, target) {
     visit(runItemsOf(p));
     return found >= 0 ? found : pos;
 }
+const RANGE_MARKERS = {
+    moveFromRangeStart: { kind: 'start', side: 'from' }, moveFromRangeEnd: { kind: 'end', side: 'from' },
+    moveToRangeStart: { kind: 'start', side: 'to' }, moveToRangeEnd: { kind: 'end', side: 'to' },
+};
+/**
+ * Accepts or rejects the whole move a run-level half belongs to, as Word's Review tab does from
+ * either half (`test/README.md` check 18, Word 16.0.20326.20158; Office JS cannot list a move at
+ * all there, check 17). Word pairs the halves by the `w:name` on their range starts
+ * (`w:moveFromRangeStart`, `w:moveToRangeStart`); `w:moveFrom` and `w:moveTo` carry none, so a half
+ * belongs to the move whose range of its side is open where it stands. Accepting keeps the
+ * destination and removes the source, paragraph mark and all; rejecting the other way round; the
+ * four range markers go either way. Returns false for a half in no named range - markup without
+ * range markers, or a half already resolved - which the caller then treats on its own, as before.
+ */
+function resolveMove(change, action) {
+    var _a, _b, _c;
+    const t = change.target;
+    if (t.kind !== 'run' || !change.paragraph)
+        return false;
+    const story = storyOf(change.paragraph.p);
+    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)
+        return false;
+    const name = half.names[0];
+    const ids = new Set(pieces.filter((piece) => piece.kind === 'start' && piece.name === name).map((piece) => piece.id));
+    const mine = pieces.filter((piece) => (piece.kind === 'start' && piece.name === name) || (piece.kind === 'end' && ids.has(piece.id))
+        || ((piece.kind === 'half' || piece.kind === 'mark' || piece.kind === 'inner') && piece.names.includes(name)));
+    // A destination whose source is gone is kept whichever way it is resolved: Word rejected such a
+    // move and left its text, plain, where it stood (test/README.md check 20 case 12).
+    const orphan = !mine.some((piece) => piece.side === 'from');
+    const kept = action === 'accept' || orphan ? 'to' : 'from';
+    const broken = orphan || !mine.some((piece) => piece.side === 'to');
+    // the markers first: a range end between two paragraphs would stop the paragraph join below
+    for (const piece of mine)
+        if (piece.kind === 'start' || piece.kind === 'end')
+            remove(piece.owner, piece.element);
+    // Rejected, a move takes with it everything typed into its destination: Word's default when moved
+    // text was edited (the Tracked Moves Conflict Dialog's "keep original location text", check 20
+    // cases 01 and 04). Text typed before the range starts is outside the move and stays (case 03).
+    // What accepting does to text typed into the source was not measured, so it is left alone.
+    if (kept === 'from') {
+        for (const piece of mine)
+            if (piece.kind === 'inner' && piece.side === 'to')
+                remove(piece.owner, piece.element);
+    }
+    for (const piece of mine) {
+        if (piece.kind !== 'half')
+            continue;
+        const target = { kind: 'run', revision: piece.side === 'from' ? 'moveFrom' : 'moveTo', element: piece.element, owner: piece.owner, value: piece.element.value };
+        if (piece.side === kept) {
+            if (piece.side === 'from')
+                restoreDeleted(target);
+            else
+                unwrap(target);
+        }
+        else
+            remove(piece.owner, piece.element);
+    }
+    // the paragraph marks last, last first, so that a join never disturbs one still to do
+    const marks = mine.filter((piece) => piece.kind === 'mark');
+    for (let i = marks.length - 1; i >= 0; i--) {
+        const mark = marks[i];
+        const p = mark.paragraph.value;
+        if (mark.side === kept) {
+            const rPr = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.rPr;
+            if (rPr)
+                delete rPr[mark.side === 'from' ? 'moveFrom' : 'moveTo'];
+            pruneParagraphProperties(p);
+        }
+        else if (((_b = p.content) !== null && _b !== void 0 ? _b : []).length === 0) {
+            remove(mark.container, mark.paragraph); // the moved paragraph, emptied: gone, as in Word
+        }
+        else {
+            const rPr = (_c = p.pPr) === null || _c === void 0 ? void 0 : _c.rPr;
+            if (rPr)
+                delete rPr[mark.side === 'from' ? 'moveFrom' : 'moveTo'];
+            joinWithNext({ container: mark.container, element: mark.paragraph, p }, mark.side === 'to');
+        }
+    }
+    if (broken)
+        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) {
+    let story;
+    for (let o = p; o !== undefined; o = o.PARENT) {
+        const content = o.content;
+        if (Array.isArray(content) && o.TYPE_NAME !== '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) {
+    const out = [];
+    const open = { from: new Map(), to: new Map() };
+    const visit = (items, runLevel = false) => {
+        var _a, _b, _c, _d, _e, _f;
+        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;
+            if (marker && value) {
+                const id = Number(value.id);
+                if (marker.kind === 'start') {
+                    open[marker.side].set(id, (_c = value.name) !== null && _c !== void 0 ? _c : '');
+                    out.push({ kind: 'start', side: marker.side, id, name: (_d = value.name) !== null && _d !== void 0 ? _d : '', element: el, owner: items });
+                }
+                else {
+                    open[marker.side].delete(id);
+                    out.push({ kind: 'end', side: marker.side, id, element: el, owner: items });
+                }
+                continue;
+            }
+            const revision = revisionKindOf(el);
+            if (revision === 'moveFrom' || revision === 'moveTo') {
+                const side = revision === 'moveFrom' ? 'from' : 'to';
+                out.push({ kind: 'half', side, element: el, owner: items, names: [...open[side].values()] });
+            }
+            else if (runLevel) {
+                for (const side of ['from', 'to']) {
+                    if (open[side].size > 0)
+                        out.push({ kind: 'inner', side, element: el, owner: items, names: [...open[side].values()] });
+                }
+            }
+            const v = el.value;
+            if (typeof v !== 'object' || v === null)
+                continue;
+            const children = (_e = childrenOf(v)) !== null && _e !== void 0 ? _e : 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;
+                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()] });
+                    }
+                }
+            }
+        }
+    };
+    visit(story);
+    return out;
+}
+/**
+ * A move half in no named range - its range markers gone - resolved as Word resolved one (check 20
+ * cases 13 and 14, where Word showed it as an insertion or a deletion): a `w:moveTo` as an insertion,
+ * a `w:moveFrom` as a deletion, its paragraph mark with it, so that a paragraph whose text and mark
+ * both go goes whole. Then the rest of the broken pair is dissolved (`dissolveBrokenMoves`).
+ */
+function resolveRangelessHalf(change, action) {
+    var _a, _b, _c;
+    const t = change.target;
+    const paragraph = change.paragraph;
+    if (t.kind !== 'run' || (t.revision !== 'moveTo' && t.revision !== 'moveFrom') || !paragraph)
+        return false;
+    const story = storyOf(paragraph.p);
+    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)
+        return false;
+    const side = half.side;
+    const key = side === 'from' ? 'moveFrom' : 'moveTo';
+    const keep = (side === 'to') === (action === 'accept'); // an insertion accepted, a deletion rejected
+    if (!keep)
+        remove(t.owner, t.element);
+    else if (side === 'to')
+        unwrap(t);
+    else
+        restoreDeleted(t);
+    const mark = pieces.find((piece) => piece.kind === 'mark' && piece.side === side && piece.paragraph === paragraph.element && piece.names.length === 0);
+    const p = paragraph.p;
+    if (mark && ((_b = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.rPr) === null || _b === void 0 ? void 0 : _b[key])) {
+        if (keep) {
+            delete p.pPr.rPr[key];
+            pruneParagraphProperties(p);
+        }
+        else if (((_c = p.content) !== null && _c !== void 0 ? _c : []).length === 0) {
+            remove(paragraph.container, paragraph.element);
+        }
+        else {
+            delete p.pPr.rPr[key];
+            joinWithNext(paragraph, side === 'to');
+        }
+    }
+    dissolveBrokenMoves(story);
+    return true;
+}
+/**
+ * Every move half and moved paragraph mark in the story that cannot be paired - in no named range,
+ * or in one whose `w:name` no range of the other side carries - turned into the plain `w:ins` or
+ * `w:del` it stands for, pending, its range markers kept. That is how Word saved each broken pair
+ * in check 20 (re-run, cases 12 to 14, saved unchanged) and what it left of the other side once one
+ * was accepted or rejected. It runs after a broken move is resolved, and only then, so a document's
+ * other moves are left as they are; but a broken pair's halves cannot be told from another's, so
+ * this takes them all.
+ */
+function dissolveBrokenMoves(story) {
+    var _a;
+    const pieces = movePiecesOf(story);
+    const named = { from: new Set(), to: new Set() };
+    for (const piece of pieces)
+        if (piece.kind === 'start')
+            named[piece.side].add(piece.name);
+    const unpaired = (side, names) => {
+        const other = named[side === 'from' ? 'to' : 'from'];
+        return names.every((name) => !other.has(name)); // true for no names too
+    };
+    for (const piece of pieces) {
+        if (piece.kind === 'half' && unpaired(piece.side, piece.names))
+            toPlainRevision(piece.element, piece.owner, piece.side === 'from' ? 'del' : 'ins');
+        if (piece.kind === 'mark' && unpaired(piece.side, piece.names)) {
+            const rPr = (_a = piece.paragraph.value.pPr) === null || _a === void 0 ? void 0 : _a.rPr;
+            if (piece.side === 'from' && (rPr === null || rPr === void 0 ? void 0 : rPr.moveFrom)) {
+                rPr.del = rPr.moveFrom;
+                delete rPr.moveFrom;
+            }
+            if (piece.side === 'to' && (rPr === null || rPr === void 0 ? void 0 : rPr.moveTo)) {
+                rPr.ins = rPr.moveTo;
+                delete rPr.moveTo;
+            }
+        }
+    }
+}
+/**
+ * A `w:moveFrom` turned into the plain `w:del` of the same runs, their text become deleted text, or a
+ * `w:moveTo` into the plain `w:ins`.
+ */
+function toPlainRevision(element, owner, kind) {
+    var _a;
+    const value = element.value;
+    const items = (_a = runItemsOf(element.value)) !== null && _a !== void 0 ? _a : [];
+    if (kind === 'del')
+        for (const item of items)
+            if (typeNameOf(item) === 'org_docx4j_wml.R')
+                toDeletedText(item.value);
+    const plain = {
+        name: { namespaceURI: W_NS, localPart: kind },
+        value: { TYPE_NAME: kind === 'del' ? 'org_docx4j_wml.RunDel' : 'org_docx4j_wml.RunIns', id: value.id, author: value.author, date: value.date, customXmlOrSmartTagOrSdt: items },
+    };
+    const i = owner.indexOf(element);
+    if (i < 0)
+        return;
+    owner.splice(i, 1, plain);
+    linkParents(items, plain.value);
+    linkParents(plain, value.PARENT);
+}
 // --- collecting ----------------------------------------------------------------------------
-/** The tracked changes of one paragraph, in document order. */
+/**
+ * The tracked changes of one paragraph, in document order, touching pieces grouped as Office JS
+ * groups them (`groupTouching`). Office JS lists the changes that start in the paragraph (check 22):
+ * pieces that carry on a change from the paragraph before - its inserted or deleted mark - are left
+ * to that paragraph, and a change running on into the next is cut at this paragraph's end.
+ */
 export function trackedChangesOfParagraph(paragraph) {
-    var _a, _b, _c;
+    const tokens = trackedChangeTokensOfParagraph(paragraph);
+    const before = markBefore(paragraph);
+    if (before) {
+        for (let i = 0; i < tokens.length;) {
+            const token = tokens[i];
+            if (token === BREAK)
+                break;
+            const kind = groupable(token);
+            if (kind === undefined) {
+                i++;
+                continue;
+            }
+            if (kind !== before.kind || token.author !== before.author)
+                break;
+            tokens.splice(i, 1);
+        }
+    }
+    return groupTouching(tokens);
+}
+/** The last revision on the mark of the paragraph before this one in its container, if any. */
+function markBefore(paragraph) {
+    var _a;
+    const i = paragraph.container.indexOf(paragraph.element);
+    const previous = i > 0 ? paragraph.container[i - 1] : undefined;
+    if (!previous || typeNameOf(previous) !== 'org_docx4j_wml.P')
+        return undefined;
+    const rPr = (_a = previous.value.pPr) === null || _a === void 0 ? void 0 : _a.rPr;
+    if (rPr === null || rPr === void 0 ? void 0 : rPr.del)
+        return { kind: 'del', author: rPr.del.author };
+    if (rPr === null || rPr === void 0 ? void 0 : rPr.ins)
+        return { kind: 'ins', author: rPr.ins.author };
+    if (rPr === null || rPr === void 0 ? void 0 : rPr.rPrChange)
+        return { kind: 'format', author: rPr.rPrChange.author };
+    return undefined;
+}
+/** Between two tracked changes: something unrevised - text, a paragraph mark, a table - that keeps them apart. */
+export const BREAK = 'break';
+/**
+ * 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) {
+    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));
-    const rPr = (_b = p.pPr) === null || _b === void 0 ? void 0 : _b.rPr;
+    tokensOfRunLevel(paragraph, ((_b = p.content) !== null && _b !== void 0 ? _b : []), out);
+    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)
+        out.push(new TrackedChange({ kind: 'markProperties', value: rPr.rPrChange }, paragraph));
     if (rPr === null || rPr === void 0 ? void 0 : rPr.ins)
         out.push(new TrackedChange({ kind: 'mark', mark: 'ins', value: rPr.ins }, paragraph));
     if (rPr === null || rPr === void 0 ? void 0 : rPr.del)
         out.push(new TrackedChange({ kind: 'mark', mark: 'del', value: rPr.del }, paragraph));
-    collectRunLevel(paragraph, ((_c = p.content) !== null && _c !== void 0 ? _c : []), out);
+    if (!(rPr === null || rPr === void 0 ? void 0 : rPr.ins) && !(rPr === null || rPr === void 0 ? void 0 : rPr.del) && !(rPr === null || rPr === void 0 ? void 0 : rPr.rPrChange))
+        out.push(BREAK);
+    const sectPr = (_d = p.pPr) === null || _d === void 0 ? void 0 : _d.sectPr;
+    if (sectPr === null || sectPr === void 0 ? void 0 : sectPr.sectPrChange) {
+        out.push(new TrackedChange({ kind: 'sectionProperties', sectPr, value: sectPr.sectPrChange, text: `${sectionText(paragraph.container, paragraph.container.indexOf(paragraph.element) + 1)}\f` }, paragraph));
+    }
     return out;
 }
-function collectRunLevel(paragraph, items, out) {
+/**
+ * The text of the section that ends at `end` (exclusive) in a container: its paragraphs' text, a `\r`
+ * between them, back to the previous section break.
+ */
+function sectionText(items, end) {
     var _a;
+    let from = end - 1;
+    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');
+}
+function tokensOfRunLevel(paragraph, items, out) {
+    var _a, _b;
     for (const el of items) {
         const kind = revisionKindOf(el);
         if (kind !== undefined) {
+            // moved text is content Office JS cannot list (checks 16, 17), and is kept apart
+            const move = kind === 'moveFrom' || kind === 'moveTo';
+            if (move)
+                out.push(BREAK);
             out.push(new TrackedChange({ kind: 'run', revision: kind, element: el, owner: items, value: el.value }, paragraph));
+            if (move)
+                out.push(BREAK);
             const nested = runItemsOf(el.value);
-            if (nested)
-                collectRunLevel(paragraph, nested, out);
+            if (nested) {
+                // a revision inside a revision (a deletion of inserted text) was not measured: listed apart
+                const inner = [];
+                tokensOfRunLevel(paragraph, nested, inner);
+                if (inner.some((token) => token !== BREAK && token.target.kind === 'run'))
+                    out.push(BREAK, ...inner, BREAK);
+                else
+                    out.push(...inner.filter((token) => token !== BREAK));
+            }
             continue;
         }
         if (typeNameOf(el) === 'org_docx4j_wml.R') {
+            // a run whose formatting changed is a piece of its own; one that did not keeps pieces apart
             const run = el.value;
             if ((_a = run.rPr) === null || _a === void 0 ? void 0 : _a.rPrChange)
                 out.push(new TrackedChange({ kind: 'runProperties', run, value: run.rPr.rPrChange }, paragraph));
+            else if (((_b = run.content) !== null && _b !== void 0 ? _b : []).length > 0)
+                out.push(BREAK);
             continue;
         }
         const nested = runItemsOf(el.value);
         if (nested)
-            collectRunLevel(paragraph, nested, out);
+            tokensOfRunLevel(paragraph, nested, out);
     }
 }
+/**
+ * What a piece groups as: a `w:ins` or `w:del` around runs, or an inserted or deleted mark; a run's
+ * `w:rPrChange` (check 28: bold on an italic run and a plain one, one change). Moves and a
+ * paragraph's `w:pPrChange` do not group.
+ */
+function groupable(change) {
+    const t = change.target;
+    if (t.kind === 'mark')
+        return t.mark;
+    if (t.kind === 'run' && (t.revision === 'ins' || t.revision === 'del'))
+        return t.revision;
+    if (t.kind === 'runProperties' || t.kind === 'markProperties')
+        return 'format';
+    return undefined;
+}
+/**
+ * Tokens made into the changes Office JS lists: consecutive pieces of one kind (inserted, deleted, or
+ * a run's formatting) by one author, nothing unrevised between them, are one change (checks 22, 23
+ * and 28: text and marks alike, dates regardless, formatting whatever it recorded; another author, or
+ * one kind against another, starts a new one). A change that does not group - a paragraph's
+ * properties, a move - is listed where it stands and does not break a group. A group of one piece is
+ * that piece.
+ */
+export function groupTouching(tokens) {
+    const out = [];
+    let open;
+    for (const token of tokens) {
+        if (token === BREAK) {
+            open = undefined;
+            continue;
+        }
+        const kind = groupable(token);
+        if (kind === undefined) {
+            out.push(token);
+            continue;
+        }
+        const last = open === null || open === void 0 ? void 0 : open[open.length - 1];
+        if (open && last && groupable(last) === kind && last.author === token.author) {
+            open.push(token);
+            continue;
+        }
+        open = [token];
+        out.push(open);
+    }
+    return out.map((item) => {
+        if (!Array.isArray(item))
+            return item;
+        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);
+    });
+}
 /**
  * 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.
@@ -350,3 +903,143 @@ export function trackedChangesOfRow(tr, owner, inner = []) {
         out.push(new TrackedChange({ kind: 'row', row: 'del', tr, owner, value: trPr.del, inner }, undefined));
     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) {
+    const records = tableRecordsOf(tbl.value);
+    return records ? new TrackedChange({ kind: 'tableProperties', tbl, value: records.value }, undefined) : undefined;
+}
+/** A cell's own revision, `w:cellIns` or `w:cellDel`, or undefined. */
+export function cellChangeOf(tc, owner, tr) {
+    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);
+    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 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) {
+    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);
+}
+/**
+ * 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).
+ */
+function removeCell(tc, owner) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    var _h;
+    const i = owner.indexOf(tc);
+    if (i < 0)
+        return;
+    const cells = owner.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);
+    if (!neighbour)
+        return;
+    const removed = tc.value.tcPr;
+    const kept = ((_b = (_h = neighbour.value).tcPr) !== null && _b !== void 0 ? _b : (_h.tcPr = { TYPE_NAME: 'org_docx4j_wml.TcPr' }));
+    const span = (tcPr) => { var _a, _b; return Number((_b = (_a = tcPr === null || tcPr === void 0 ? void 0 : tcPr.gridSpan) === null || _a === void 0 ? void 0 : _a.val) !== null && _b !== void 0 ? _b : 1) || 1; };
+    kept.gridSpan = { ...((_c = kept.gridSpan) !== null && _c !== void 0 ? _c : {}), val: span(kept) + span(removed) };
+    if (((_d = kept.tcW) === null || _d === void 0 ? void 0 : _d.type) === 'dxa' && ((_e = removed === null || removed === void 0 ? void 0 : removed.tcW) === null || _e === void 0 ? void 0 : _e.type) === 'dxa') {
+        kept.tcW = { ...kept.tcW, w: Number((_f = kept.tcW.w) !== null && _f !== void 0 ? _f : 0) + Number((_g = removed.tcW.w) !== null && _g !== void 0 ? _g : 0) };
+    }
+    linkParents(kept, neighbour.value);
+}
+/** A mark's formatting put back as its `w:rPrChange` recorded it, its own revisions (inserted, deleted, moved) kept. */
+function restoreMarkProperties(p, change) {
+    var _a, _b, _c;
+    const rPr = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.rPr;
+    if (!rPr)
+        return;
+    const keep = ['ins', 'del', 'moveFrom', 'moveTo'];
+    const target = rPr;
+    for (const key of Object.keys(target))
+        if (key !== 'TYPE_NAME' && key !== 'PARENT' && !keep.includes(key))
+            delete target[key];
+    const original = rPrFromElements((_c = (_b = change.rPr) === null || _b === void 0 ? void 0 : _b.egrPrBase) !== null && _c !== void 0 ? _c : []);
+    for (const [key, value] of Object.entries(original))
+        if (key !== 'TYPE_NAME' && key !== 'PARENT')
+            target[key] = value;
+    if (p.pPr)
+        linkParents(rPr, p.pPr);
+    pruneParagraphProperties(p);
+}
+/**
+ * A section's properties put back as its `w:sectPrChange` recorded them. Word records only what
+ * changed, and rejecting laid those over the section, the rest left as it stood (check 18's saved
+ * file: the margins came back, the page size and columns stayed); a recorded `w:docGrid` of pitch 0
+ * stands for none, and Word wrote none (check 18, and check 27's section break).
+ */
+function restoreSection(sectPr, change) {
+    var _a, _b;
+    const target = sectPr;
+    for (const [key, value] of Object.entries((_a = change.sectPr) !== null && _a !== void 0 ? _a : {})) {
+        if (key !== 'TYPE_NAME' && key !== 'PARENT')
+            target[key] = deepCopy(value);
+    }
+    const grid = sectPr.docGrid;
+    if (grid && Number((_b = grid.linePitch) !== null && _b !== void 0 ? _b : 0) === 0 && grid.type === undefined && grid.charSpace === undefined)
+        delete sectPr.docGrid;
+    delete sectPr.sectPrChange;
+    linkParents(sectPr, sectPr.PARENT);
+}
+/**
+ * What `acceptAll` and `rejectAll` resolve that is never listed: a `w:cellMerge`, which Office JS
+ * cannot list (check 27: `getTrackedChanges` throws); a `w:numberingChange`, which Word no longer
+ * writes and drops when one is put in, and whose record is the old number's text, so that a reject
+ * too can only drop it; and a table's records that change nothing. A merge rejected gets the merge it
+ * recorded back (docx4j's reading; unmeasured).
+ */
+export function resolveUnlisted(items, what) {
+    const visit = (list) => {
+        var _a;
+        for (const el of list !== null && list !== void 0 ? list : []) {
+            const tn = typeNameOf(el);
+            if (tn === 'org_docx4j_wml.P') {
+                const numPr = (_a = el.value.pPr) === null || _a === void 0 ? void 0 : _a.numPr;
+                if (numPr === null || numPr === void 0 ? void 0 : numPr.numberingChange)
+                    delete numPr.numberingChange;
+                continue;
+            }
+            if (tn === 'org_docx4j_wml.Tbl') {
+                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)) {
+                        const tcPr = cell.element.value.tcPr;
+                        if (tcPr === null || tcPr === void 0 ? void 0 : tcPr.cellMerge)
+                            resolveCellMerge(tcPr, what);
+                        visit(childrenOf(cell.element.value));
+                    }
+                }
+                continue;
+            }
+            const v = el.value;
+            if (typeof v === 'object' && v !== null)
+                visit(childrenOf(v));
+        }
+    };
+    visit(items);
+}
+function resolveCellMerge(tcPr, what) {
+    const change = tcPr.cellMerge;
+    delete tcPr.cellMerge;
+    if (what === 'accept')
+        return;
+    const orig = change.vMergeOrig;
+    if (orig === 'rest')
+        tcPr.vMerge = { val: 'restart' };
+    else if (orig === 'cont')
+        tcPr.vMerge = {};
+    else
+        delete tcPr.vMerge;
+}