@docx4j/core-ts 0.4.0 → 0.5.0

package/dist/model/content/Range.mjs

@@ -1,6 +1,6 @@
 import { Font } from './Font.mjs';
 import { runFontSelectorOf } from '../fonts/lookup.mjs';
-import { typeNameOf, linkParents, runItemsOf, runsOf } from './tree.mjs';
+import { typeNameOf, linkParents, runItemsOf, runsOf, revisionKindOf, WHOLE } from './tree.mjs';
 import { Docx4JException } from '../../opc/exceptions.mjs';
 import { ContentControl } from './ContentControl.mjs';
 import { sdt as sdtOf, nextSdtId, applyRunOptions, t as textElement } from '@docx4j/generated-objects-ts/builders/wml';
@@ -15,12 +15,23 @@ import { commentApi } from './comments.mjs';
  * A subset of Office JS `Word.Range`: a span of text within one paragraph, [start, end) in the
  * paragraph's text. Positions are recomputed from the tree on every use, so a range stays
  * valid across edits made through it; edits made elsewhere may shift it.
+ *
+ * A picture has a place in the text and no text of its own, so a picture at the range's start or
+ * end offset may be inside it or outside it. `whole` says: a range from `Paragraph.getRange('Whole')`
+ * or `'Content'` holds the paragraph's whole content, the pictures at its edges too, and deleting or
+ * replacing it deletes them; any other range holds the pictures strictly inside it, so that a search
+ * hit replaced does not take the picture beside it (CR-002 section 48).
  */
 export class Range {
-    constructor(paragraph, start, end) {
+    constructor(paragraph, start, end, whole = false) {
         this.paragraph = paragraph;
         this.start = start;
         this.end = end;
+        this.whole = whole;
+    }
+    /** The edges `Paragraph.splice` is given: both for a whole range. */
+    get edges() {
+        return this.whole ? WHOLE : undefined;
     }
     get paragraphs() {
         return [this.paragraph];
@@ -93,7 +104,7 @@ export class Range {
     insertText(text, location) {
         let r;
         if (location === 'Replace')
-            r = this.paragraph.splice(this.start, this.end, text);
+            r = this.paragraph.splice(this.start, this.end, text, 'before', this.edges);
         // text put before the range joins the run the range starts in - inside the link the range is on,
         // as Office JS (check 32: insertText('Before') on a link's text went into the link, as 'After' did)
         else if (location === 'Before' || location === 'Start')
@@ -145,9 +156,9 @@ export class Range {
                 : { element: el, container: this.paragraph.container };
         });
     }
-    /** Removes the span's text. */
+    /** Removes the span's text, and the pictures in it (CR-002 section 48). */
     delete() {
-        this.paragraph.splice(this.start, this.end, '');
+        this.paragraph.splice(this.start, this.end, '', 'before', this.edges);
         this.end = this.start;
     }
     search(text, options) {
@@ -183,7 +194,7 @@ export class Range {
             return new Range(this.paragraph, this.start, this.start);
         if (location === 'End')
             return new Range(this.paragraph, this.end, this.end);
-        return new Range(this.paragraph, this.start, this.end);
+        return new Range(this.paragraph, this.start, this.end, this.whole);
     }
     /** The span's text as it stands (extension; Office JS getOoxml wraps it in a package). */
     toString() {
@@ -209,7 +220,7 @@ export class Range {
      * span gets an empty control at its position. Returns the control.
      */
     insertContentControl(kind) {
-        var _a, _b;
+        var _a;
         const paragraph = this.paragraph;
         const body = paragraph.parentBody;
         // The control is built empty first: `sdt` refuses a kind that cannot be run-level (a repeating
@@ -220,62 +231,44 @@ export class Range {
             paragraph.insertItemsAt(this.start, [sdt]);
             return new ContentControl(sdt, containerOf(sdt, paragraph), body);
         }
-        paragraph.splitAt(this.start);
-        paragraph.splitAt(this.end);
-        const segments = paragraph.segments().filter((s) => s.start >= this.start && s.end <= this.end);
-        if (segments.length === 0)
+        // Every refusal before anything changes (CR-002 section 43): until then the runs were split first.
+        const covered = coveredSegments(paragraph, this.start, this.end);
+        if (covered.length === 0)
             throw new Docx4JException('This range covers no run');
-        const owner = segments[0].runOwner;
-        if (segments.some((s) => s.runOwner !== owner)) {
+        const coveredOwner = covered[0].runOwner;
+        if (covered.some((s) => s.runOwner !== coveredOwner)) {
             throw new Docx4JException('This range spans more than one run holder (a hyperlink or a tracked change); wrap a narrower span');
         }
-        const items = [];
-        for (const segment of segments) {
-            const element = owner[segment.runIndex];
-            if (!items.includes(element))
-                items.push(element);
-        }
-        const at = owner.indexOf(items[0]);
+        refuseTrackedDeletion(coveredOwner, covered);
         const tracker = paragraph.changeTracker;
-        const revision = segments[0].revision;
+        const coveredRevision = revisionHolding(covered[0], coveredOwner);
+        if (tracker && coveredRevision && itemsKeyOf(coveredRevision) === undefined) {
+            throw new Docx4JException('This range is in a revision that cannot be split around a content control');
+        }
+        paragraph.splitAt(this.start);
+        paragraph.splitAt(this.end);
+        const segments = paragraph.segments().filter((s) => s.start >= this.start && s.end <= this.end);
+        const owner = segments[0].runOwner;
+        const { at, items } = wrappedItems(owner, segments);
+        const revision = revisionHolding(segments[0], owner);
         if (tracker && revision) {
             // The runs are in a revision: the control goes between its halves, not in it, and the runs go
             // into the control in a revision of the same kind and attributes with a new id - Word's form for
             // inserted text wrapped in a new control (check 30, inserted-text-wrapped: the w:ins inside the
             // control, the control's own markers outside it).
-            const index = revision.items.indexOf(items[0]);
-            revision.items.splice(index, items.length);
-            const value = revision.value;
-            const itemsKey = Object.keys(value).find((key) => value[key] === revision.items);
-            const inner = {};
-            for (const [key, v] of Object.entries(value))
-                if (key !== itemsKey && key !== 'PARENT')
-                    inner[key] = v;
-            inner.id = tracker.nextId();
-            inner[itemsKey] = items;
-            const wrapped = { name: revision.element.name, value: inner };
-            linkParents(items, inner);
+            revision.items.splice(at, items.length);
+            const wrapped = revisionAround(revision, items, tracker.nextId());
             sdt.value.sdtContent.content = [wrapped];
             linkParents(wrapped, sdt.value.sdtContent);
-            const holderOwner = revision.owner;
-            const parent = (_a = revision.value.PARENT) !== null && _a !== void 0 ? _a : paragraph.p;
-            if (revision.items.length === 0) {
-                holderOwner.splice(holderOwner.indexOf(revision.element), 1, sdt); // the whole revision wrapped
-                linkParents(sdt, parent);
-            }
-            else if (index === 0) {
-                holderOwner.splice(holderOwner.indexOf(revision.element), 0, sdt); // its start wrapped
-                linkParents(sdt, parent);
-            }
-            else if (!paragraph.splitHolderAround(revision, index, sdt, () => tracker.nextId())) {
+            if (!placeInRevision(paragraph, revision, at, sdt, () => tracker.nextId())) {
                 throw new Docx4JException('This range is in a revision that cannot be split around a content control');
             }
-            markHolderInserted(tracker, sdt, holderOwner, () => { });
-            return new ContentControl(sdt, holderOwner, body);
+            markHolderInserted(tracker, sdt, revision.owner, () => { });
+            return new ContentControl(sdt, revision.owner, body);
         }
         sdt.value.sdtContent.content = items;
         owner.splice(at, items.length, sdt);
-        linkParents(sdt, (_b = segments[0].run.PARENT) !== null && _b !== void 0 ? _b : paragraph.p);
+        linkParents(sdt, (_a = segments[0].run.PARENT) !== null && _a !== void 0 ? _a : paragraph.p);
         // under tracking the control itself is the insertion, the runs in it what they were (check 30)
         if (tracker)
             markHolderInserted(tracker, sdt, owner, () => { });
@@ -340,12 +333,18 @@ export class Range {
             start = Math.min(start, span[0]);
             end = Math.max(end, span[1]);
         }
-        this.removeHyperlinks();
-        if (value === '')
-            return;
         const hash = value.indexOf('#');
         const address = hash === -1 ? value : value.slice(0, hash);
         const location = hash === -1 ? '' : value.slice(hash + 1);
+        // Every refusal comes before anything changes, judged on what the range would hold once the links
+        // it touches were unwrapped (CR-002 section 43). Until then the setter unwrapped them, added the
+        // relationship and split the runs before it refused, so a refused call left the links gone, an
+        // orphan relationship and split runs (found by the docx4j-python session).
+        if (value !== '')
+            this.refuseUnlinkable(start, end, address);
+        this.removeHyperlinks();
+        if (value === '')
+            return;
         // w:history="1" is what Word writes on every hyperlink it makes, and what docx4j writes when
         // it builds one (MainDocumentPart.addHyperlink): "add the target to the viewed hyperlinks"
         // (ECMA-376 17.16.22). Readers do not depend on it, but a document holding one holder from
@@ -359,26 +358,79 @@ export class Range {
         paragraph.splitAt(start);
         paragraph.splitAt(end);
         const segments = paragraph.segments().filter((seg) => seg.start >= start && seg.end <= end);
-        if (segments.length === 0)
-            throw new Docx4JException('This range covers no run');
         const owner = segments[0].runOwner;
-        if (segments.some((seg) => seg.runOwner !== owner)) {
-            throw new Docx4JException('This range spans more than one run holder (a hyperlink or a tracked change); wrap a narrower span');
+        const { at, items } = wrappedItems(owner, segments);
+        const revision = revisionHolding(segments[0], owner);
+        let runsParent = holder.value;
+        if (revision) {
+            // A w:hyperlink cannot be in a w:ins or w:moveTo (CT_RunTrackChange holds EG_ContentRunContent
+            // only), so over runs in one, tracked or not, the link goes between the revision's halves and the
+            // runs into it in a revision of the same kind and attributes with a new id, as a content control
+            // over inserted text does (CR-002 section 43; the docx4j-python session's form). Until then the
+            // link went into the revision, which marshalled with an xsi:type. Word's own form for a link set
+            // on inserted text is a HYPERLINK field in the one w:ins (check 30, link-on-inserted-text), which
+            // this setter's getter would not read back.
+            revision.items.splice(at, items.length);
+            const inner = revisionAround(revision, items, paragraph.nextAnnotationId());
+            holder.value.content = [inner];
+            linkParents(inner, holder.value);
+            if (!placeInRevision(paragraph, revision, at, holder, () => paragraph.nextAnnotationId())) {
+                throw new Docx4JException('This range is in a revision that cannot be split around a hyperlink');
+            }
+            runsParent = inner.value;
         }
-        const items = [];
-        for (const segment of segments) {
-            const element = owner[segment.runIndex];
-            if (!items.includes(element))
-                items.push(element);
+        else {
+            holder.value.content = items;
+            owner.splice(at, items.length, holder);
+            linkParents(holder, (_a = segments[0].run.PARENT) !== null && _a !== void 0 ? _a : paragraph.p);
         }
-        const at = owner.indexOf(items[0]);
-        holder.value.content = items;
-        owner.splice(at, items.length, holder);
-        linkParents(holder, (_a = segments[0].run.PARENT) !== null && _a !== void 0 ? _a : paragraph.p);
         this.restyle(holder.value, true);
-        mergeTextRuns(holder.value.content, holder.value);
+        mergeTextRuns(items, runsParent);
         (_c = (_b = paragraph.parentBody.package_) === null || _b === void 0 ? void 0 : _b.requireStyles) === null || _c === void 0 ? void 0 : _c.call(_b, [HYPERLINK_STYLE]);
     }
+    /**
+     * Refuses, before anything changes, a link the setter could not make over [start, end): one with an
+     * address on a range with no part, over no run, over runs in more than one holder, or around a
+     * tracked deletion - each judged as the range would stand once the links it touches were unwrapped,
+     * their runs then in the list holding them.
+     */
+    refuseUnlinkable(start, end, address) {
+        const paragraph = this.paragraph;
+        if (address !== '' && !paragraph.parentBody.part) {
+            throw new Docx4JException('This range has no part, so a hyperlink cannot be related to it');
+        }
+        const touched = hyperlinkHolders(paragraph).filter((h) => this.touches(h));
+        const unwrapsInto = new Map();
+        for (const holder of touched) {
+            const inner = runItemsOf(holder.value);
+            if (inner)
+                unwrapsInto.set(inner, containerOf(holder, paragraph));
+        }
+        const ownerOnceUnwrapped = (owner) => {
+            let o = owner;
+            for (let guard = 0; guard < 100 && unwrapsInto.has(o); guard++)
+                o = unwrapsInto.get(o);
+            return o;
+        };
+        const covered = coveredSegments(paragraph, start, end);
+        if (covered.length === 0)
+            throw new Docx4JException('This range covers no run');
+        const owner = ownerOnceUnwrapped(covered[0].runOwner);
+        if (covered.some((seg) => ownerOnceUnwrapped(seg.runOwner) !== owner)) {
+            throw new Docx4JException('This range spans more than one run holder (a hyperlink or a tracked change); wrap a narrower span');
+        }
+        const unwrapped = new Set(touched);
+        const flatten = (items) => items.flatMap((item) => {
+            var _a;
+            return (unwrapped.has(item)
+                ? flatten(((_a = runItemsOf(item.value)) !== null && _a !== void 0 ? _a : [])) : [item]);
+        });
+        refuseTrackedDeletion(flatten(owner), covered);
+        const revision = revisionHolding(covered[0], owner);
+        if (revision && itemsKeyOf(revision) === undefined) {
+            throw new Docx4JException('This range is in a revision that cannot be split around a hyperlink');
+        }
+    }
     /** The first `w:hyperlink` this range touches, if any. */
     hyperlinkHolder() {
         return hyperlinkHolders(this.paragraph).find((holder) => this.touches(holder));
@@ -541,6 +593,84 @@ function hyperlinkHolders(paragraph) {
     return out;
 }
 /** The run-level array holding an element, after `insertItemsAt` put it somewhere in the paragraph. */
+/**
+ * The segments a range covers, read before its runs are split at its edges: those inside it, and those
+ * a split would cut, whose inner part then is. What `segments()` gives inside the range once it is
+ * split, so that a wrapper's refusals can come before anything changes.
+ */
+function coveredSegments(paragraph, start, end) {
+    return paragraph.segments().filter((s) => (s.start >= start && s.end <= end) || (s.start < end && s.end > start));
+}
+/**
+ * The items a range's runs are wrapped in place of: everything from the first run it covers to the
+ * last, in the one list holding them, so that what lies between - a bookmark, a comment's range, a
+ * proofing mark - goes into the wrapper with them. Until CR-002 section 43 as many items were taken as
+ * there were runs, from the first, which dropped what lay between and left a run in two places.
+ */
+function wrappedItems(owner, segments) {
+    const indexes = segments.map((s) => owner.indexOf(s.runOwner[s.runIndex])).filter((i) => i >= 0);
+    const at = Math.min(...indexes);
+    return { at, items: owner.slice(at, Math.max(...indexes) + 1) };
+}
+/**
+ * Refuses a range with a tracked deletion (or text moved away) between its runs: having no text in
+ * the range's, it would be wrapped unseen, and a range spanning a tracked change is refused (CR-002
+ * section 43).
+ */
+function refuseTrackedDeletion(items, segments) {
+    const indexes = segments.map((s) => items.indexOf(s.runOwner[s.runIndex])).filter((i) => i >= 0);
+    if (indexes.length === 0)
+        return;
+    for (const item of items.slice(Math.min(...indexes), Math.max(...indexes) + 1)) {
+        const kind = revisionKindOf(item);
+        if (kind === 'del' || kind === 'moveFrom') {
+            throw new Docx4JException('This range spans a tracked deletion; wrap the text on either side of it');
+        }
+    }
+}
+/** The `w:ins` or `w:moveTo` a segment's run is directly in, when `owner` is its own item list. */
+function revisionHolding(segment, owner) {
+    return segment.revision !== undefined && segment.revision.items === owner ? segment.revision : undefined;
+}
+/** The key under which a revision's value holds its items, or undefined where none does. */
+function itemsKeyOf(revision) {
+    const value = revision.value;
+    return Object.keys(value).find((key) => value[key] === revision.items);
+}
+/** A revision of the same kind and attributes as `revision`, with a new id, holding `items`. */
+function revisionAround(revision, items, id) {
+    const value = revision.value;
+    const itemsKey = itemsKeyOf(revision);
+    const inner = {};
+    for (const [key, v] of Object.entries(value))
+        if (key !== itemsKey && key !== 'PARENT')
+            inner[key] = v;
+    inner.id = id;
+    inner[itemsKey] = items;
+    linkParents(items, inner);
+    return { name: revision.element.name, value: inner };
+}
+/**
+ * Puts `item` where items from `index` on were taken out of `revision`: in its place where it holds
+ * nothing now, before it where they were its first, else between its halves. False where the revision
+ * cannot be split.
+ */
+function placeInRevision(paragraph, revision, index, item, nextId) {
+    var _a;
+    const owner = revision.owner;
+    const parent = (_a = revision.value.PARENT) !== null && _a !== void 0 ? _a : paragraph.p;
+    if (revision.items.length === 0) {
+        owner.splice(owner.indexOf(revision.element), 1, item); // the whole revision wrapped
+        linkParents(item, parent);
+        return true;
+    }
+    if (index === 0) {
+        owner.splice(owner.indexOf(revision.element), 0, item); // its start wrapped
+        linkParents(item, parent);
+        return true;
+    }
+    return paragraph.splitHolderAround(revision, index, item, nextId);
+}
 function containerOf(element, paragraph) {
     var _a, _b;
     var _c;

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

@@ -1,7 +1,11 @@
 import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
+import type * as math from '@docx4j/generated-objects-ts/modules/org_docx4j_math';
 import { type Element, type Located, type RevisionKind } from './tree.mjs';
 import { Range } from './Range.mjs';
 import type { Paragraph } from './Paragraph.mjs';
+import type { Body } from './Body.mjs';
+import type { Part } from '../../parts/Part.mjs';
+import { type RelationshipRemovals } from './relationships.mjs';
 /** Office JS `Word.ChangeTrackingState` (`Unknown` is not produced here). */
 export type TrackedChangeType = 'Added' | 'Deleted' | 'Formatted' | 'None' | 'Unknown';
 /** Which piece of revision markup a `TrackedChange` is over (an extension: Office JS has no such member). */
@@ -112,6 +116,51 @@ export type TrackedChangeTarget =
     outer: [Element, Element];
     inner: [Element, Element];
     value: wml.CTTrackChange;
+}
+/**
+ * A field Word inserted under tracking, in its own form: a `w:ins` around the field's begin and
+ * instruction runs and another around its end, the separator and the result between them plain
+ * (check 30, `field-inserted`). Office JS lists it as one `Added` change whose text is the result's,
+ * and Word's Reject All took the whole field away, the result with it (CR-002 section 44). `span` is
+ * the items of `owner` from the first `w:ins` to the last.
+ */
+ | {
+    kind: 'field';
+    span: Element[];
+    owner: Element[];
+    value: wml.CTTrackChange;
+}
+/**
+ * A `w:ins` or `w:del` inside an `m:r`, which is where Word writes an equation's text inserted or
+ * deleted (`m:r` > `w:ins` > `m:rPr`, `w:rPr`, `m:t`; docx4j's `tracked-changes-equations.docx`).
+ * `item` is the `w:ins` or `w:del` in the run's content, `run` the `m:r` and `runOwner` its list.
+ * Kept, its content takes its place in the run; not kept, it goes, and a run left with no text with it
+ * (CR-002 section 51). `equation` is the `m:oMath` or `m:oMathPara` in the paragraph that holds it.
+ */
+ | {
+    kind: 'mathRun';
+    revision: 'ins' | 'del';
+    item: Element;
+    run: Element<math.CTR>;
+    runOwner: Element[];
+    value: wml.CTMathRunTrackChange;
+    equation?: Element;
+}
+/**
+ * A `w:ins` or `w:del` in an equation structure's `m:ctrlPr`, Word's mark of an `m:sSup`, an `m:acc`,
+ * ... inserted or deleted as a whole. `structure` is that element and `owner` its list, two up from
+ * the `m:ctrlPr`; undefined for an argument's own `m:ctrlPr` (an `m:e`'s), which marks no structure.
+ * Kept, the marker goes and the run properties it recorded become the control's; not kept, the
+ * structure goes whole, as Word's Accept All and Reject All did (CR-002 section 51).
+ */
+ | {
+    kind: 'mathStructure';
+    revision: 'ins' | 'del';
+    ctrlPr: math.CTCtrlPr;
+    structure?: Element;
+    owner?: Element[];
+    value: wml.CTRPrChange;
+    equation?: Element;
 };
 /**
  * A subset of Office JS `Word.TrackedChange`: `type`, `author`, `date`, `text`, `accept()`,
@@ -122,9 +171,13 @@ export declare class TrackedChange {
     readonly target: TrackedChangeTarget;
     /** The paragraph the change is in; undefined for a row revision. */
     readonly paragraph: Paragraph | undefined;
+    /** The body a change without a paragraph (a row, a cell) is in, for the notes it may take away. */
+    readonly body?: Body | undefined;
     constructor(target: TrackedChangeTarget, 
     /** The paragraph the change is in; undefined for a row revision. */
-    paragraph: Paragraph | undefined);
+    paragraph: Paragraph | undefined, 
+    /** The body a change without a paragraph (a row, a cell) is in, for the notes it may take away. */
+    body?: Body | undefined);
     /** Office JS `Word.ChangeTrackingState`. */
     get type(): TrackedChangeType;
     get author(): string;
@@ -147,13 +200,76 @@ export declare class TrackedChange {
      * Either half of a move keeps the whole move, as Word's Review tab does (CR-002 section 29).
      */
     accept(): void;
+    private acceptHere;
     /**
      * 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(): void;
+    private rejectHere;
+    /** The body the change is in. */
+    private get body_();
+    /** The package the change is in, which keeps the notes whose references it took away. */
+    private get package_();
     private requireParagraph;
 }
+/** The ids of the footnotes and endnotes whose references removed content took with it. */
+export interface NoteRemovals {
+    footnote: Set<number>;
+    endnote: Set<number>;
+}
+/**
+ * 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 declare function resolving(pkg: unknown, body: Body | undefined, resolve: () => void): void;
+/** What `flushPendingNoteRemovals` needs of the main document part. */
+interface NotesHost {
+    getContents(): Promise<unknown>;
+    footnotesPart?: Part & {
+        getContents(): Promise<wml.CTFootnotes>;
+    };
+    endnotesPart?: Part & {
+        getContents(): Promise<wml.CTEndnotes>;
+    };
+}
+/** Where a removed note's own content goes on to: the package's queues (`WordprocessingMLPackage`). */
+interface NoteRemovalHost {
+    pendingCommentRemovals?: Set<number>;
+    pendingRelationshipRemovals?: RelationshipRemovals;
+}
+/**
+ * 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 declare function flushPendingNoteRemovals(main: NotesHost, pending: NoteRemovals, host?: NoteRemovalHost): Promise<void>;
 /**
  * The insertion of a content control or custom XML element, when `items[i]` is a
  * `w:customXmlInsRangeStart` and what follows is Word's form for one (check 30): the element, whose
@@ -161,6 +277,15 @@ export declare class TrackedChange {
  * one's end right after the element. Anything else is not one (a marker on its own is left alone).
  */
 export declare function holderInsertionAt(items: Element[], i: number, paragraph: Paragraph | undefined): TrackedChange | undefined;
+/**
+ * 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 declare function insertedFieldAt(items: Element[], i: number, paragraph: Paragraph | undefined): TrackedChange | undefined;
 /**
  * docx4j AcceptTrackedChanges: the paragraph takes the next one's content and properties, so the
  * mark that survives is the next one's. Called when a deleted mark is accepted and when an
@@ -200,11 +325,11 @@ export declare function groupTouching(tokens: TrackedChangeToken[]): TrackedChan
  * 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 declare function trackedChangesOfRow(tr: Element<wml.Tr>, owner: Element[], inner?: TrackedChange[], table?: Located<wml.Tbl>): TrackedChange[];
+export declare function trackedChangesOfRow(tr: Element<wml.Tr>, owner: Element[], inner?: TrackedChange[], table?: Located<wml.Tbl>, body?: Body): TrackedChange[];
 /** The change a table's property records make, one per table, or undefined when they make none. */
 export declare function tablePropertiesChangeOf(tbl: Element<wml.Tbl>): TrackedChange | undefined;
 /** A cell's own revision, `w:cellIns` or `w:cellDel`, or undefined. */
-export declare function cellChangeOf(tc: Element<wml.Tc>, owner: Element[], tr: wml.Tr): TrackedChange | undefined;
+export declare function cellChangeOf(tc: Element<wml.Tc>, owner: Element[], tr: wml.Tr, body?: Body): TrackedChange | undefined;
 /** The change to the body's last section (`w:body/w:sectPr/w:sectPrChange`), its text the section's paragraphs'. */
 export declare function bodySectionChangeOf(container: {
     content?: Element[];
@@ -219,3 +344,4 @@ export declare function bodySectionChangeOf(container: {
  * the form `holderInsertionAt` lists marks nothing that can be found, and goes either way.
  */
 export declare function resolveUnlisted(items: Element[], what: 'accept' | 'reject'): void;
+export {};