@docx4j/core-ts 0.4.0 → 0.5.0

package/dist/model/content/TrackedChange.mjs

@@ -7,6 +7,7 @@ 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
@@ -15,9 +16,12 @@ import { deepCopy } from '@docx4j/generated-objects-ts';
 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() {
@@ -29,6 +33,9 @@ export class TrackedChange {
             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 'field': return 'Added';
+            case 'mathRun':
+            case 'mathStructure': return t.revision === 'ins' ? 'Added' : 'Deleted';
             default: return 'Formatted';
         }
     }
@@ -49,6 +56,7 @@ export class TrackedChange {
     }
     /** 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 +66,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';
@@ -74,10 +85,14 @@ export class TrackedChange {
             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);
+            // the field's result: its instruction is no text, as Office JS reports it (check 30: "1")
+            case 'field': return segmentsOf({ content: t.span }, { view: 'accepted' }).map((s) => s.text).join('');
             case '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 '';
         }
     }
@@ -93,17 +108,26 @@ export class TrackedChange {
         }
         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());
+            const here = t.pieces.filter((piece) => { var _a; return (piece.target.kind === 'run' || piece.target.kind === 'runProperties' || piece.target.kind === 'field') && ((_a = piece.paragraph) === null || _a === void 0 ? void 0 : _a.element) === p.element; }).map((piece) => piece.getRange());
             if (here.length === 0)
                 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 === 'field') {
+            const start = acceptedOffsetOf(p.p, t.span[0]);
+            return new Range(p, start, start + this.text.length);
+        }
         if (t.kind === 'runProperties') {
             const segs = p.segments().filter((s) => s.run === t.run);
             if (segs.length === 0)
                 return p.getRange('Start');
             return new Range(p, segs[0].start, segs[segs.length - 1].end);
         }
+        // an equation's text is not in the paragraph's: collapsed where the equation stands
+        if ((t.kind === 'mathRun' || t.kind === 'mathStructure') && t.equation) {
+            const at = acceptedOffsetOf(p.p, t.equation);
+            return new Range(p, at, at);
+        }
         return p.getRange('Whole');
     }
     /**
@@ -111,6 +135,9 @@ export class TrackedChange {
      * Either half of a move keeps the whole move, as Word's Review tab does (CR-002 section 29).
      */
     accept() {
+        resolving(this.package_, this.body_, () => this.acceptHere());
+    }
+    acceptHere() {
         var _a, _b, _c, _d, _e, _f;
         const t = this.target;
         switch (t.kind) {
@@ -174,6 +201,18 @@ export class TrackedChange {
                 // the element stays, the markers go (check 30: accept all leaves the control, no marker)
                 removeHolderMarkers(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;
         }
     }
     /**
@@ -181,6 +220,9 @@ export class TrackedChange {
      * Either half of a move rejects the whole move, as Word's Review tab does (CR-002 section 29).
      */
     reject() {
+        resolving(this.package_, this.body_, () => this.rejectHere());
+    }
+    rejectHere() {
         var _a, _b;
         const t = this.target;
         switch (t.kind) {
@@ -243,8 +285,27 @@ export class TrackedChange {
                 // control, and an existing control, which has no markers, stays)
                 unwrapHolder(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');
@@ -375,8 +436,287 @@ 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.
+ * 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;
+    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);
+        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 };
+    try {
+        resolve();
+        const done = resolution;
+        if (done.root && done.before)
+            dropBookmarksBroken(done.root, done.before);
+        if (done.part && ((_c = done.relationships) === null || _c === void 0 ? void 0 : _c.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;
+    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 (resolution.part && (element || properties)) {
+        const into = ((_b = resolution.relationships) !== null && _b !== void 0 ? _b : (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);
+}
+/** 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 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`. */
+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 four insertion markers taken away; the element stays. */
 function removeHolderMarkers(t) {
@@ -425,6 +765,87 @@ export function holderInsertionAt(items, i, paragraph) {
         return undefined;
     return new TrackedChange({ kind: 'holder', holder, owner: items, outer: [start, outerEnd], inner: [innerEnd, innerStart], value: start.value }, paragraph);
 }
+/**
+ * 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,
  * so one whose rows were all inserted was inserted, and one whose rows were all deleted was deleted.
@@ -471,6 +892,7 @@ function removeRevision(t, paragraph) {
         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; }))
             outside.add(id);
     }
+    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;
@@ -563,6 +985,7 @@ function dropMark(paragraph, which) {
  */
 export function joinWithNext(paragraph, fallbackToPrevious = false) {
     var _a, _b, _c, _d, _e;
+    discarding();
     const container = currentOwner(paragraph.container, paragraph.element);
     const i = container.indexOf(paragraph.element);
     const next = i >= 0 ? container[i + 1] : undefined;
@@ -575,6 +998,7 @@ export function joinWithNext(paragraph, fallbackToPrevious = false) {
             for (const item of (_b = p.content) !== null && _b !== void 0 ? _b : [])
                 items.push(item);
             linkParents(items, into);
+            discarding(undefined, p.pPr);
             container.splice(i, 1);
             return;
         }
@@ -591,6 +1015,7 @@ export function joinWithNext(paragraph, fallbackToPrevious = false) {
     for (const item of (_e = nextP.content) !== null && _e !== void 0 ? _e : [])
         content.push(item);
     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);
@@ -652,6 +1077,131 @@ function acceptedOffsetOf(p, target) {
     visit(runItemsOf(p));
     return found >= 0 ? found : pos;
 }
+// --- 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 : []);
+        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'; })) {
+        remove(t.runOwner, t.run);
+    }
+}
+/**
+ * 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;
+    if (!keep && t.structure && t.owner) {
+        remove(t.owner, t.structure);
+        return;
+    }
+    const ctrlPr = t.ctrlPr;
+    if (!ctrlPr.rPr && t.value.rPr) {
+        ctrlPr.rPr = rPrFromElements((_a = t.value.rPr.egrPrBase) !== null && _a !== void 0 ? _a : []);
+        linkParents(ctrlPr.rPr, ctrlPr);
+    }
+    if (t.revision === 'ins')
+        delete ctrlPr.ins;
+    else
+        delete ctrlPr.del;
+}
+/** 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));
+            }
+            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);
+            }
+        }
+        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' },
     moveToRangeStart: { kind: 'start', side: 'to' }, moveToRangeEnd: { kind: 'end', side: 'to' },
@@ -997,6 +1547,18 @@ function tokensOfRunLevel(paragraph, items, out) {
             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
@@ -1055,8 +1617,10 @@ function groupable(change) {
         return t.revision;
     if (t.kind === 'runProperties' || t.kind === 'markProperties')
         return 'format';
-    if (t.kind === 'holder')
+    if (t.kind === 'holder' || 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)
@@ -1106,13 +1670,13 @@ export function groupTouching(tokens) {
  * 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 --------------------------------------------
@@ -1122,12 +1686,12 @@ export function tablePropertiesChangeOf(tbl) {
     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) {
+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'. */
@@ -1153,6 +1717,7 @@ function removeCell(tc, owner) {
     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];
+    discarding(tc);
     owner.splice(i, 1);
     if (!neighbour)
         return;