@docx4j/core-ts 0.5.0 → 0.7.0

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

@@ -26,6 +26,11 @@ export interface TrackingHost {
     readonly author: Author;
     /** A fixed date for new revisions; `undefined` means now, read once per revision. */
     readonly trackedChangeDate?: Date | undefined;
+    /**
+     * The zone a stamp's `w:date` wall-clock fields are written in, and a `w:date` without `dateUtc` read in: the
+     * package's `dateTimeZone`, an IANA id; undefined is the runtime's zone (CR-018, the portfolio's date rule).
+     */
+    readonly dateTimeZone?: string | undefined;
     /** The trees to scan for the highest annotation id in use: the parts already unmarshalled. */
     markupRoots(): object[];
     /**
@@ -73,19 +78,43 @@ export declare function dateOf(cal: wml.XmlCalendar | undefined): Date | undefin
 /**
  * A revision's `w:date` as Word writes it: the local wall-clock time, with a `Z` that does not mean
  * UTC (CR-002 section 29, check 23: Office JS read `01:00:00Z` as 15:00 UTC the day before, at
- * UTC+10; Word's own files carry the true UTC beside it in `w16du:dateUtc`). "Local" is this
- * process's time zone, as it is the add-in's for Office JS.
+ * UTC+10; Word's own files carry the true UTC beside it in `w16du:dateUtc`). "Local" is `zone`, the
+ * package's `dateTimeZone` (CR-018), else this process's time zone, which is the add-in's for Office JS.
  */
-export declare function wordCalendarOf(date: Date): wml.XmlCalendar;
+export declare function wordCalendarOf(date: Date, zone?: string): wml.XmlCalendar;
 /**
  * A revision's date as Word means it: `w16du:dateUtc` when there is one, which is UTC; else
- * `w:date` read as local wall-clock time, its `Z` notwithstanding, as Office JS reads it (check 23).
+ * `w:date` read as local wall-clock time, its `Z` notwithstanding, as Office JS reads it (check 23),
+ * in `zone` (the package's `dateTimeZone`, CR-018), else the runtime's zone.
  * A `w:date` with a non-zero offset, which Word does not write, is read as it says.
  */
 export declare function revisionDateOf(value: {
     date?: wml.XmlCalendar;
     dateUtc?: wml.XmlCalendar;
-}): Date | undefined;
+}, zone?: string): Date | undefined;
+/** A stamp's fields as written: an `XmlCalendar`, or its lexical form as a reader may hold it. */
+type Stamp = wml.XmlCalendar | string | null | undefined;
+/**
+ * The author's local time of a revision's or comment's `w:date`: its date and time as stored, in ISO 8601's extended form
+ * with no designator (`2026-10-31T11:00:00`), any designator not read, a missing time 00:00:00, fractions of a second
+ * dropped; undefined for no date. Word writes the author's wall clock labelled `Z` (CR-002 section 29), and shows it as it
+ * is. docx4j `RevisionDates.localTime`.
+ */
+export declare function authorLocalTime(date: Stamp): string | undefined;
+/**
+ * The author's UTC offset in minutes: `w:date` less `dateUtc` (`w16du:dateUtc`, or a comment's `w16cex:dateUtc`), where both
+ * are present and differ by a whole number of quarter hours from -12:00 to +14:00, as a clock's offset does; else
+ * undefined, so a pair a producer wrote inconsistently gives no offset rather than a wrong one. `dateUtc` without a zone is
+ * UTC, and one with an offset is moved by it. docx4j `RevisionDates.offset`.
+ */
+export declare function authorOffsetMinutes(date: Stamp, dateUtc: Stamp): number | undefined;
+/**
+ * A revision's or comment's stamp as WD REQ-702 writes it: the author's local time (`authorLocalTime`), with the author's
+ * offset after it where it is known (`2026-10-31T11:00:00+11:00`; `+00:00` for UTC, never `Z`); `dateUtc` with `Z` where
+ * there is no `w:date`; undefined where there is neither. The `Z` Word stores on `w:date` is never written, and nothing is
+ * converted to another zone. docx4j `RevisionDates.text`.
+ */
+export declare function revisionDateText(date: Stamp, dateUtc: Stamp): string | undefined;
 /** Properties compared as values: keys sorted, `PARENT`, `TYPE_NAME` and absent values left out. */
 export declare function canonical(value: unknown): string;
 /** The part a tracker writes into, as far as the tracker needs it: its tree, once unmarshalled. */
@@ -143,7 +172,7 @@ export declare class ChangeTracker {
     nextId(): number;
     /**
      * The `w:id`, `w:author` and `w:date` a new revision carries, `w:date` in Word's local wall-clock
-     * convention (`wordCalendarOf`), and `w16du:dateUtc`, the true UTC, as Word writes them both. The
+     * convention (`wordCalendarOf`, in the host's `dateTimeZone`), and `w16du:dateUtc`, the true UTC, as Word writes them both. The
      * part's root is made to list `w16du` in `mc:Ignorable` first (`declareDateUtc`): a consumer that
      * does not know `w16du` must reject it unless it is declared ignorable. A tracker bound to no part -
      * the package's own - writes `w:date` alone (CR-002 section 29).
@@ -176,6 +205,14 @@ export declare class ChangeTracker {
     settleRPrChange(run: {
         rPr?: wml.RPr;
     }): void;
+    /**
+     * Records a paragraph mark's formatting as it is now in its `w:rPrChange`, once: what a tracked `font`
+     * write over a range holding the mark writes (check 52 case 56: `<w:rPrChange><w:rPr/></w:rPrChange>`
+     * for a mark that had no formatting). The mark's own revisions (inserted, deleted) are not its formatting.
+     */
+    recordMarkRPrChange(rPr: wml.ParaRPr): void;
+    /** `settleRPrChange` for a paragraph mark: its `w:rPrChange` goes where its formatting is back to what it recorded. */
+    settleMarkRPrChange(p: wml.P): void;
     /** Records the paragraph's properties as they are now in `w:pPrChange`, once. */
     recordPPrChange(pPr: wml.PPr): void;
     /** `w:pPr/w:rPr/w:ins`: the paragraph mark is an insertion. */
@@ -244,6 +281,13 @@ export declare function holderItemsOf(value: object): Element[] | undefined;
  * pairs, so that the ids run in document order as Word's do.
  */
 export declare function markHolderInserted(tracker: ChangeTracker, holder: Element, owner: Element[], inside: () => void): void;
+/**
+ * A content control or custom XML element deleted under tracking, as Word writes it (check 54 cases 15 and 17, a
+ * range across paragraphs holding a whole control): `markHolderInserted`'s form with `w:customXmlDelRangeStart` and
+ * `w:customXmlDelRangeEnd`, its content marked deleted between the two pairs (`inside`). Accepting takes the element
+ * away; rejecting, the markers (`TrackedChange`'s `holder` target).
+ */
+export declare function markHolderDeleted(tracker: ChangeTracker, holder: Element, owner: Element[], inside: () => void): void;
 /** The paragraph mark's run properties (`w:pPr/w:rPr`), created when absent. */
 export declare function paraRPrOf(p: wml.P): wml.ParaRPr;
 /** The row's properties (`w:trPr`), created when absent. */
@@ -254,6 +298,19 @@ export declare function pruneParagraphProperties(p: wml.P): void;
 export declare function markDeleted(p: wml.P): boolean;
 /** True when a paragraph's mark is marked inserted. */
 export declare function markInserted(p: wml.P): boolean;
+/**
+ * An equation (`m:oMath`, `m:oMathPara`) marked deleted where it stands, in Word's form (check 57 cases 7 to 10): each
+ * math run's content inside a `w:del` in its `m:r`, and each structure's `m:ctrlPr` holding a `w:del` around its run
+ * properties, as Word's tracked `delete()` writes them. An argument's own `m:ctrlPr` marks no structure, and is left as
+ * it is. An equation holding a revision of its own (`equationRevisionIn`) is the caller's to put in a `w:del` whole.
+ */
+export declare function markEquationDeleted(tracker: ChangeTracker, equation: object): void;
+/**
+ * A revision an equation holds of its own, or undefined: a math run's, a structure's or an argument's, or a `w:ins` or
+ * `w:del` among its runs. How Word deletes such an equation isn't measured, so a tracked deletion puts it whole in a
+ * `w:del`, the form this package wrote for every equation before (CR-002 section 62.2, D2).
+ */
+export declare function equationRevisionIn(equation: object): string | undefined;
 /** Turns a run's `w:t` into `w:delText` and `w:instrText` into `w:delInstrText`, in place. */
 export declare function toDeletedText(run: wml.R): void;
 /** The inverse, for `reject()` of a deletion. */

package/dist/model/content/tracking.mjs

@@ -1,9 +1,10 @@
 import { deepCopy, deepCopyAsSync } from '@docx4j/generated-objects-ts';
 import * as el from '@docx4j/generated-objects-ts/el/org_docx4j_wml';
-import { createCTTrackChange, createCTRPrChange, createCTRPrChangeRPr, createCTPPrChange, createCTMarkup, createDelText, createPPr, createParaRPr, createTrPr, } from '@docx4j/generated-objects-ts/factory/org_docx4j_wml';
+import { createCTTrackChange, createCTRPrChange, createCTRPrChangeRPr, createCTPPrChange, createCTMarkup, createDelText, createPPr, createParaRPr, createTrPr, createParaRPrChange, createCTParaRPrOriginal, } from '@docx4j/generated-objects-ts/factory/org_docx4j_wml';
 import { rPrToElements, rPrFromElements } from '@docx4j/generated-objects-ts/builders/wml';
 import { Docx4JException } from '../../opc/exceptions.mjs';
-import { W_NS, linkParents, walk, typeNameOf, revisionKindOf, childrenOf, rowsOf, cellsOf } from './tree.mjs';
+import { W_NS, linkParents, walk, typeNameOf, revisionKindOf, childrenOf, rowsOf, cellsOf, isAlternateContent, selectedBranchOf, branchesOf, ALTERNATE_CONTENT } from './tree.mjs';
+import { wallClockIn, instantOf } from '../dateZone.mjs';
 /**
  * `w:id` on these is the one annotation id space (ECMA-376 17.13.5.4): revisions, bookmarks,
  * comment range marks and permissions share it. `w:comment/@w:id` (docx4j `Comments.Comment`,
@@ -69,21 +70,20 @@ export function dateOf(cal) {
 /**
  * A revision's `w:date` as Word writes it: the local wall-clock time, with a `Z` that does not mean
  * UTC (CR-002 section 29, check 23: Office JS read `01:00:00Z` as 15:00 UTC the day before, at
- * UTC+10; Word's own files carry the true UTC beside it in `w16du:dateUtc`). "Local" is this
- * process's time zone, as it is the add-in's for Office JS.
+ * UTC+10; Word's own files carry the true UTC beside it in `w16du:dateUtc`). "Local" is `zone`, the
+ * package's `dateTimeZone` (CR-018), else this process's time zone, which is the add-in's for Office JS.
  */
-export function wordCalendarOf(date) {
-    return {
-        year: date.getFullYear(), month: date.getMonth() + 1, day: date.getDate(),
-        hour: date.getHours(), minute: date.getMinutes(), second: date.getSeconds(), timezone: 0,
-    };
+export function wordCalendarOf(date, zone) {
+    const clock = wallClockIn(date, zone);
+    return { year: clock.year, month: clock.month, day: clock.day, hour: clock.hour, minute: clock.minute, second: clock.second, timezone: 0 };
 }
 /**
  * A revision's date as Word means it: `w16du:dateUtc` when there is one, which is UTC; else
- * `w:date` read as local wall-clock time, its `Z` notwithstanding, as Office JS reads it (check 23).
+ * `w:date` read as local wall-clock time, its `Z` notwithstanding, as Office JS reads it (check 23),
+ * in `zone` (the package's `dateTimeZone`, CR-018), else the runtime's zone.
  * A `w:date` with a non-zero offset, which Word does not write, is read as it says.
  */
-export function revisionDateOf(value) {
+export function revisionDateOf(value, zone) {
     var _a, _b, _c, _d, _e, _f;
     if (((_a = value.dateUtc) === null || _a === void 0 ? void 0 : _a.year) !== undefined)
         return dateOf(value.dateUtc);
@@ -92,7 +92,88 @@ export function revisionDateOf(value) {
         return undefined;
     if (cal.timezone !== undefined && cal.timezone !== 0)
         return dateOf(cal);
-    return new Date(cal.year, ((_b = cal.month) !== null && _b !== void 0 ? _b : 1) - 1, (_c = cal.day) !== null && _c !== void 0 ? _c : 1, (_d = cal.hour) !== null && _d !== void 0 ? _d : 0, (_e = cal.minute) !== null && _e !== void 0 ? _e : 0, (_f = cal.second) !== null && _f !== void 0 ? _f : 0);
+    return instantOf({ year: cal.year, month: (_b = cal.month) !== null && _b !== void 0 ? _b : 1, day: (_c = cal.day) !== null && _c !== void 0 ? _c : 1, hour: (_d = cal.hour) !== null && _d !== void 0 ? _d : 0, minute: (_e = cal.minute) !== null && _e !== void 0 ? _e : 0, second: (_f = cal.second) !== null && _f !== void 0 ? _f : 0 }, zone);
+}
+const STAMP = /^(-?\d{4,})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?)?(Z|[+-]\d{2}:\d{2})?$/;
+/** A stamp's date and time as written, its fields read as a UTC clock's (milliseconds), and its zone in minutes; undefined for no year. */
+function clockOf(stamp) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (stamp === undefined || stamp === null)
+        return undefined;
+    if (typeof stamp === 'string') {
+        const m = STAMP.exec(stamp.trim());
+        if (!m)
+            return undefined;
+        const zone = m[7];
+        const timezone = zone === undefined ? undefined : zone === 'Z' ? 0
+            : (zone.startsWith('-') ? -1 : 1) * (Number(zone.slice(1, 3)) * 60 + Number(zone.slice(4, 6)));
+        return { ms: utcClock(Number(m[1]), Number(m[2]), Number(m[3]), Number((_a = m[4]) !== null && _a !== void 0 ? _a : 0), Number((_b = m[5]) !== null && _b !== void 0 ? _b : 0), Number((_c = m[6]) !== null && _c !== void 0 ? _c : 0)), timezone };
+    }
+    if (stamp.year === undefined)
+        return undefined;
+    return { ms: utcClock(stamp.year, (_d = stamp.month) !== null && _d !== void 0 ? _d : 1, (_e = stamp.day) !== null && _e !== void 0 ? _e : 1, (_f = stamp.hour) !== null && _f !== void 0 ? _f : 0, (_g = stamp.minute) !== null && _g !== void 0 ? _g : 0, (_h = stamp.second) !== null && _h !== void 0 ? _h : 0), timezone: stamp.timezone };
+}
+function utcClock(year, month, day, hour, minute, second) {
+    const d = new Date(Date.UTC(2000, month - 1, day, hour, minute, second));
+    d.setUTCFullYear(year);
+    return d.getTime();
+}
+/** The offsets clocks keep, in seconds: UTC-12:00 to UTC+14:00. */
+const MIN_OFFSET = -12 * 3600;
+const MAX_OFFSET = 14 * 3600;
+/**
+ * The author's local time of a revision's or comment's `w:date`: its date and time as stored, in ISO 8601's extended form
+ * with no designator (`2026-10-31T11:00:00`), any designator not read, a missing time 00:00:00, fractions of a second
+ * dropped; undefined for no date. Word writes the author's wall clock labelled `Z` (CR-002 section 29), and shows it as it
+ * is. docx4j `RevisionDates.localTime`.
+ */
+export function authorLocalTime(date) {
+    const clock = clockOf(date);
+    return clock === undefined ? undefined : clockText(clock.ms);
+}
+/**
+ * The author's UTC offset in minutes: `w:date` less `dateUtc` (`w16du:dateUtc`, or a comment's `w16cex:dateUtc`), where both
+ * are present and differ by a whole number of quarter hours from -12:00 to +14:00, as a clock's offset does; else
+ * undefined, so a pair a producer wrote inconsistently gives no offset rather than a wrong one. `dateUtc` without a zone is
+ * UTC, and one with an offset is moved by it. docx4j `RevisionDates.offset`.
+ */
+export function authorOffsetMinutes(date, dateUtc) {
+    var _a;
+    const local = clockOf(date);
+    const utc = clockOf(dateUtc);
+    if (local === undefined || utc === undefined)
+        return undefined;
+    const seconds = Math.round((local.ms - (utc.ms - ((_a = utc.timezone) !== null && _a !== void 0 ? _a : 0) * 60000)) / 1000);
+    if (seconds % 900 !== 0 || seconds < MIN_OFFSET || seconds > MAX_OFFSET)
+        return undefined;
+    return seconds / 60;
+}
+/**
+ * A revision's or comment's stamp as WD REQ-702 writes it: the author's local time (`authorLocalTime`), with the author's
+ * offset after it where it is known (`2026-10-31T11:00:00+11:00`; `+00:00` for UTC, never `Z`); `dateUtc` with `Z` where
+ * there is no `w:date`; undefined where there is neither. The `Z` Word stores on `w:date` is never written, and nothing is
+ * converted to another zone. docx4j `RevisionDates.text`.
+ */
+export function revisionDateText(date, dateUtc) {
+    var _a;
+    const local = clockOf(date);
+    if (local === undefined) {
+        const utc = clockOf(dateUtc);
+        return utc === undefined ? undefined : `${clockText(utc.ms - ((_a = utc.timezone) !== null && _a !== void 0 ? _a : 0) * 60000)}Z`;
+    }
+    const offset = authorOffsetMinutes(date, dateUtc);
+    if (offset === undefined)
+        return clockText(local.ms);
+    const abs = Math.abs(offset);
+    return `${clockText(local.ms)}${offset < 0 ? '-' : '+'}${String(Math.floor(abs / 60)).padStart(2, '0')}:${String(abs % 60).padStart(2, '0')}`;
+}
+/** A UTC clock's milliseconds as `uuuu-MM-ddTHH:mm:ss`. */
+function clockText(ms) {
+    const d = new Date(ms);
+    const p2 = (n) => String(n).padStart(2, '0');
+    const year = d.getUTCFullYear();
+    const y = year < 0 ? `-${String(-year).padStart(4, '0')}` : String(year).padStart(4, '0');
+    return `${y}-${p2(d.getUTCMonth() + 1)}-${p2(d.getUTCDate())}T${p2(d.getUTCHours())}:${p2(d.getUTCMinutes())}:${p2(d.getUTCSeconds())}`;
 }
 /** Properties compared as values: keys sorted, `PARENT`, `TYPE_NAME` and absent values left out. */
 export function canonical(value) {
@@ -194,7 +275,7 @@ export class ChangeTracker {
     }
     /**
      * The `w:id`, `w:author` and `w:date` a new revision carries, `w:date` in Word's local wall-clock
-     * convention (`wordCalendarOf`), and `w16du:dateUtc`, the true UTC, as Word writes them both. The
+     * convention (`wordCalendarOf`, in the host's `dateTimeZone`), and `w16du:dateUtc`, the true UTC, as Word writes them both. The
      * part's root is made to list `w16du` in `mc:Ignorable` first (`declareDateUtc`): a consumer that
      * does not know `w16du` must reject it unless it is declared ignorable. A tracker bound to no part -
      * the package's own - writes `w:date` alone (CR-002 section 29).
@@ -202,7 +283,7 @@ export class ChangeTracker {
     markup() {
         var _a;
         const when = (_a = this.host.trackedChangeDate) !== null && _a !== void 0 ? _a : nowToTheMinute();
-        const markup = { id: this.nextId(), author: this.author, date: wordCalendarOf(when) };
+        const markup = { id: this.nextId(), author: this.author, date: wordCalendarOf(when, this.host.dateTimeZone) };
         if (declareDateUtc(this.part))
             markup.dateUtc = calendarOf(when);
         return markup;
@@ -263,6 +344,31 @@ export class ChangeTracker {
         if (Object.keys(rPr).every((key) => key === 'TYPE_NAME'))
             delete run.rPr;
     }
+    /**
+     * Records a paragraph mark's formatting as it is now in its `w:rPrChange`, once: what a tracked `font`
+     * write over a range holding the mark writes (check 52 case 56: `<w:rPrChange><w:rPr/></w:rPrChange>`
+     * for a mark that had no formatting). The mark's own revisions (inserted, deleted) are not its formatting.
+     */
+    recordMarkRPrChange(rPr) {
+        if (rPr.rPrChange)
+            return;
+        const original = createCTParaRPrOriginal({ egrPrBase: rPrToElements(rPr) });
+        rPr.rPrChange = createParaRPrChange({ ...this.markup(), rPr: original });
+        linkParents(rPr.rPrChange, rPr);
+    }
+    /** `settleRPrChange` for a paragraph mark: its `w:rPrChange` goes where its formatting is back to what it recorded. */
+    settleMarkRPrChange(p) {
+        var _a, _b, _c;
+        const rPr = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.rPr;
+        const change = rPr === null || rPr === void 0 ? void 0 : rPr.rPrChange;
+        if (!rPr || !change)
+            return;
+        const { rPrChange: _recorded, ins: _ins, del: _del, moveFrom: _from, moveTo: _to, ...current } = rPr;
+        if (canonical(current) !== canonical(rPrFromElements((_c = (_b = change.rPr) === null || _b === void 0 ? void 0 : _b.egrPrBase) !== null && _c !== void 0 ? _c : [])))
+            return;
+        delete rPr.rPrChange;
+        pruneParagraphProperties(p);
+    }
     /** Records the paragraph's properties as they are now in `w:pPrChange`, once. */
     recordPPrChange(pPr) {
         if (pPr.pPrChange)
@@ -373,11 +479,12 @@ export function wrapInsertedRuns(tracker, items, parent) {
 /** A whole table inserted: every row is marked inserted and everything in its cells is an insertion (`trackInsertedBlocks`). */
 export function trackInsertedTable(tracker, tbl) {
     var _a;
-    for (const row of rowsOf(tbl)) {
+    // every branch of a kept row- or cell-level mc:AlternateContent (CR-013 phase 3)
+    for (const row of rowsOf(tbl, 'every')) {
         const tr = row.element.value;
         if (!((_a = tr.trPr) === null || _a === void 0 ? void 0 : _a.ins))
             tracker.markRowInserted(tr);
-        for (const cell of cellsOf(tr))
+        for (const cell of cellsOf(tr, 'every'))
             trackInsertedBlocks(tracker, childrenOf(cell.element.value));
     }
 }
@@ -398,6 +505,10 @@ export function trackInsertedBlock(tracker, block, owner) {
         return;
     else if (HOLDER_TYPES.has(tn !== null && tn !== void 0 ? tn : ''))
         markHolderInserted(tracker, block, owner, () => trackInsertedBlocks(tracker, childrenOf(block.value)));
+    // a kept block-level mc:AlternateContent: every branch's content (CR-013 phase 3)
+    else if (tn === ALTERNATE_CONTENT)
+        for (const branch of branchesOf(block.value))
+            trackInsertedBlocks(tracker, branch);
     else
         trackInsertedBlocks(tracker, childrenOf(block.value));
 }
@@ -443,6 +554,18 @@ export function holderItemsOf(value) {
  * pairs, so that the ids run in document order as Word's do.
  */
 export function markHolderInserted(tracker, holder, owner, inside) {
+    markHolder(tracker, holder, owner, inside, 'ins');
+}
+/**
+ * A content control or custom XML element deleted under tracking, as Word writes it (check 54 cases 15 and 17, a
+ * range across paragraphs holding a whole control): `markHolderInserted`'s form with `w:customXmlDelRangeStart` and
+ * `w:customXmlDelRangeEnd`, its content marked deleted between the two pairs (`inside`). Accepting takes the element
+ * away; rejecting, the markers (`TrackedChange`'s `holder` target).
+ */
+export function markHolderDeleted(tracker, holder, owner, inside) {
+    markHolder(tracker, holder, owner, inside, 'del');
+}
+function markHolder(tracker, holder, owner, inside, revision) {
     var _a;
     const at = owner.indexOf(holder);
     const items = holderItemsOf(holder.value);
@@ -450,16 +573,17 @@ export function markHolderInserted(tracker, holder, owner, inside) {
         inside();
         return;
     }
+    const [start, end] = revision === 'ins' ? [el.customXmlInsRangeStart, el.customXmlInsRangeEnd] : [el.customXmlDelRangeStart, el.customXmlDelRangeEnd];
     const value = holder.value;
     const first = tracker.markup();
-    const outerStart = el.customXmlInsRangeStart(createCTTrackChange(first));
-    const innerEnd = el.customXmlInsRangeEnd(createCTMarkup({ id: first.id }));
+    const outerStart = start(createCTTrackChange(first));
+    const innerEnd = end(createCTMarkup({ id: first.id }));
     owner.splice(at, 0, outerStart);
     items.unshift(innerEnd);
     inside();
     const second = tracker.markup();
-    const innerStart = el.customXmlInsRangeStart(createCTTrackChange(second));
-    const outerEnd = el.customXmlInsRangeEnd(createCTMarkup({ id: second.id }));
+    const innerStart = start(createCTTrackChange(second));
+    const outerEnd = end(createCTMarkup({ id: second.id }));
     items.push(innerStart);
     owner.splice(owner.indexOf(holder) + 1, 0, outerEnd);
     linkParents([outerStart, outerEnd], value.PARENT);
@@ -505,6 +629,87 @@ export function markInserted(p) {
     var _a, _b;
     return ((_b = (_a = p.pPr) === null || _a === void 0 ? void 0 : _a.rPr) === null || _b === void 0 ? void 0 : _b.ins) !== undefined;
 }
+// --- an equation deleted (CR-002 section 62.2, D2) ----------------------------------------
+/** Each equation structure's properties, whose `m:ctrlPr` marks the structure inserted or deleted (CR-002 section 51). */
+const MATH_STRUCTURES = Object.fromEntries(['Acc', 'Bar', 'BorderBox', 'Box', 'D', 'EqArr', 'F', 'Func', 'GroupChr', 'LimLow', 'LimUpp', 'M', 'Nary', 'Phant', 'Rad', 'SPre', 'SSub', 'SSubSup', 'SSup']
+    .map((n) => [`org_docx4j_math.CT${n}`, `${n[0].toLowerCase()}${n.slice(1)}Pr`]));
+/**
+ * An equation (`m:oMath`, `m:oMathPara`) marked deleted where it stands, in Word's form (check 57 cases 7 to 10): each
+ * math run's content inside a `w:del` in its `m:r`, and each structure's `m:ctrlPr` holding a `w:del` around its run
+ * properties, as Word's tracked `delete()` writes them. An argument's own `m:ctrlPr` marks no structure, and is left as
+ * it is. An equation holding a revision of its own (`equationRevisionIn`) is the caller's to put in a `w:del` whole.
+ */
+export function markEquationDeleted(tracker, equation) {
+    const visit = (value, depth) => {
+        var _a;
+        if (typeof value !== 'object' || value === null || depth > 64)
+            return;
+        if (Array.isArray(value)) {
+            for (const v of value)
+                visit(v, depth + 1);
+            return;
+        }
+        const named = value;
+        if (named.name !== undefined && 'value' in named) {
+            visit(named.value, depth + 1);
+            return;
+        }
+        const tn = (_a = value.TYPE_NAME) !== null && _a !== void 0 ? _a : '';
+        if (!tn.startsWith('org_docx4j_math.') || tn.endsWith('Pr'))
+            return;
+        if (tn === 'org_docx4j_math.CTR') {
+            deleteMathRun(tracker, value);
+            return;
+        }
+        const key = MATH_STRUCTURES[tn];
+        if (key !== undefined)
+            deleteMathStructure(tracker, value, tn, key);
+        for (const k of Object.keys(value))
+            if (k !== 'PARENT' && k !== 'TYPE_NAME' && k !== key)
+                visit(value[k], depth + 1);
+    };
+    visit(equation, 0);
+}
+/** A math run's content moved into a `w:del` in it (`CT_MathRunTrackChange`), its `m:t` kept as `m:t`, as Word writes it. */
+function deleteMathRun(tracker, run) {
+    var _a;
+    const content = ((_a = run.content) !== null && _a !== void 0 ? _a : (run.content = []));
+    const value = { TYPE_NAME: 'org_docx4j_wml.CTMathRunTrackChange', ...tracker.markup(), rest: content.splice(0) };
+    const del = element('del', value);
+    linkParents(value.rest, value);
+    content.push(del);
+    linkParents(del, run);
+}
+/** A structure's `m:ctrlPr` holding a `w:del` with the run properties it had, its properties made where it had none. */
+function deleteMathStructure(tracker, structure, tn, key) {
+    var _a, _b;
+    const properties = ((_a = structure[key]) !== null && _a !== void 0 ? _a : (structure[key] = { TYPE_NAME: `${tn}Pr` }));
+    const ctrlPr = ((_b = properties.ctrlPr) !== null && _b !== void 0 ? _b : (properties.ctrlPr = { TYPE_NAME: 'org_docx4j_math.CTCtrlPr' }));
+    const rPr = createCTRPrChangeRPr({ egrPrBase: ctrlPr.rPr ? rPrToElements(ctrlPr.rPr) : [] });
+    ctrlPr.del = createCTRPrChange({ ...tracker.markup(), rPr });
+    delete ctrlPr.rPr;
+    linkParents(properties, structure);
+}
+/**
+ * A revision an equation holds of its own, or undefined: a math run's, a structure's or an argument's, or a `w:ins` or
+ * `w:del` among its runs. How Word deletes such an equation isn't measured, so a tracked deletion puts it whole in a
+ * `w:del`, the form this package wrote for every equation before (CR-002 section 62.2, D2).
+ */
+export function equationRevisionIn(equation) {
+    let found;
+    walk(equation, (value) => {
+        if (found)
+            return;
+        const tn = value.TYPE_NAME;
+        if (tn === 'org_docx4j_wml.CTMathRunTrackChange')
+            found = 'a math run\'s revision';
+        else if (tn === 'org_docx4j_wml.RunIns' || tn === 'org_docx4j_wml.RunDel' || tn === 'org_docx4j_wml.RunTrackChange')
+            found = 'a revision among its runs';
+        else if (tn === 'org_docx4j_math.CTCtrlPr' && (value.ins || value.del))
+            found = 'a structure\'s revision';
+    });
+    return found;
+}
 // --- w:t <-> w:delText -------------------------------------------------------------------
 const DELETED_NAME = { t: 'delText', instrText: 'delInstrText' };
 const RESTORED_NAME = { delText: 't', delInstrText: 'instrText' };
@@ -517,11 +722,26 @@ export function toRestoredText(run) {
     rename(run, RESTORED_NAME, false);
 }
 function rename(run, table, deleting) {
-    const content = run.content;
+    renameIn(run.content, run, table, deleting);
+}
+/**
+ * `rename` over a run's items, and over a kept `mc:AlternateContent`'s selected branch among them: a
+ * deletion of a branch's text writes the selected branch's `w:delText` and keeps the other branches as
+ * they were (CR-012 section 12.2, the editor's ED-009 section 3.6).
+ */
+function renameIn(content, parent, table, deleting) {
+    var _a, _b, _c;
     if (!content)
         return;
     for (let i = 0; i < content.length; i++) {
         const item = content[i];
+        if (isAlternateContent(item)) {
+            const branch = selectedBranchOf(item.value);
+            const holder = branch === undefined ? undefined : ((_c = (_b = (_a = branch[0]) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.PARENT) !== null && _c !== void 0 ? _c : parent);
+            if (branch && holder)
+                renameIn(branch, holder, table, deleting);
+            continue;
+        }
         const to = table[item.name.localPart];
         if (to === undefined)
             continue;
@@ -530,7 +750,7 @@ function rename(run, table, deleting) {
             ? createDelText({ value: v.value, ...(v.space === undefined ? {} : { space: v.space }) })
             : { TYPE_NAME: 'org_docx4j_wml.Text', value: v.value, ...(v.space === undefined ? {} : { space: v.space }) };
         content[i] = element(to, value);
-        linkParents(content[i], run);
+        linkParents(content[i], parent);
     }
 }
 // --- w:rPr <-> w:rPrChange/w:rPr ---------------------------------------------------------