@docx4j/core-ts 0.3.2 → 0.5.0

package/dist/opc/mce/preprocessor.d.mts

@@ -1,15 +1,71 @@
 import type { XmlPart } from '../../parts/XmlPart.mjs';
 export declare const MCE_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+/**
+ * The hosts whose mc:AlternateContent is kept whole on load, as `{namespace}localName`
+ * (CR-010 phase 1): a chart's `c:chartSpace` and SpreadsheetML's `workbook`.
+ */
+export declare const KEPT_HOSTS: ReadonlySet<string>;
 export interface McePreprocessOptions {
     /** Namespaces counted as understood; defaults to the object model's modules. */
     understood?: ReadonlySet<string>;
+    /** Hosts, as `{namespace}localName`, whose mc:AlternateContent is left whole; defaults to `KEPT_HOSTS`. */
+    keptHosts?: ReadonlySet<string>;
+    /**
+     * False leaves every element whole and reports what resolving would (CR-010 phase 4): the same
+     * warnings, from the same elements, and no change to the DOM. Defaults to true.
+     */
+    resolve?: boolean;
+}
+/**
+ * What load reports about a part (CR-010 phase 1; the text extraction paper's warning channel).
+ * `mce.branches_differ`: an mc:AlternateContent whose branches' text differs, so a reader that
+ * takes another branch than this package's reads something else. `selected` is the branch this
+ * package took (`Choice(wps)`, `Fallback`); `branches` gives every branch's text, in document
+ * order, as the w:t, a:t and m:t text it holds, with whitespace collapsed.
+ */
+export interface McBranchesDifferWarning {
+    code: 'mce.branches_differ';
+    partName: string | undefined;
+    /** Where the element starts in the part, where the DOM records it (xmldom does; a browser's DOMParser does not). */
+    line?: number;
+    column?: number;
+    selected: string;
+    branches: {
+        branch: string;
+        text: string;
+    }[];
+    message: string;
+}
+/** A warning load records on a part. */
+export type PartWarning = McBranchesDifferWarning;
+/**
+ * What one pass over a DOM did. `kept` counts the elements it met and left whole; it doesn't enter a
+ * branch the rule doesn't select, so an element nested there is not counted.
+ */
+export interface MceResult {
+    resolved: number;
+    kept: number;
+    warnings: PartWarning[];
 }
-/** The default preprocessor, over the object model's namespaces. */
-export declare function mcePreprocess(doc: Document, _part?: XmlPart<unknown>): void;
-/** A preprocessor over a namespace set of your own. */
-export declare function createMcePreprocessor(options: McePreprocessOptions): (doc: Document, part?: XmlPart<unknown>) => void;
 /**
- * Resolves every mc:AlternateContent under a node, innermost first (a chosen branch may contain
- * another). Returns the number resolved.
+ * Load's preprocessor since CR-010 phase 4: every mc:AlternateContent is kept, and the part's
+ * warnings are what resolving would report. Returns them.
+ */
+export declare function mceKeep(doc: Document, part?: XmlPart<unknown>): PartWarning[];
+/** The resolving preprocessor (`mcePreprocess: true`), over the object model's namespaces. Returns the part's warnings. */
+export declare function mcePreprocess(doc: Document, part?: XmlPart<unknown>): PartWarning[];
+/** A preprocessor over a namespace set (or kept hosts) of your own. */
+export declare function createMcePreprocessor(options: McePreprocessOptions): (doc: Document, part?: XmlPart<unknown>) => PartWarning[];
+/**
+ * Resolves every mc:AlternateContent under a node, outermost first, but those `KEPT_HOSTS` and the
+ * nothing-selectable rule keep (see the file comment). Returns the number resolved.
  */
 export declare function resolveAlternateContent(root: Node, understood?: ReadonlySet<string>): number;
+/**
+ * The pass itself: what it resolved, kept and reported. With `resolve: false` it visits the elements
+ * resolving would, outermost first and into the branch the rule selects, reports the same warnings,
+ * and leaves the DOM as it was.
+ */
+export declare function preprocessAlternateContent(root: Node, options?: McePreprocessOptions & {
+    partName?: string;
+}): MceResult;

package/dist/opc/mce/preprocessor.mjs

@@ -1,42 +1,97 @@
 import { UNDERSTOOD_NAMESPACES } from './understood.mjs';
 export const MCE_NS = 'http://schemas.openxmlformats.org/markup-compatibility/2006';
-/** The default preprocessor, over the object model's namespaces. */
-export function mcePreprocess(doc, _part) {
-    resolveAlternateContent(doc, UNDERSTOOD_NAMESPACES);
+/**
+ * The hosts whose mc:AlternateContent is kept whole on load, as `{namespace}localName`
+ * (CR-010 phase 1): a chart's `c:chartSpace` and SpreadsheetML's `workbook`.
+ */
+export const KEPT_HOSTS = new Set([
+    '{http://schemas.openxmlformats.org/drawingml/2006/chart}chartSpace',
+    '{http://schemas.openxmlformats.org/spreadsheetml/2006/main}workbook',
+]);
+/**
+ * Load's preprocessor since CR-010 phase 4: every mc:AlternateContent is kept, and the part's
+ * warnings are what resolving would report. Returns them.
+ */
+export function mceKeep(doc, part) {
+    return preprocessAlternateContent(doc, { resolve: false, partName: part === null || part === void 0 ? void 0 : part.partName.name }).warnings;
 }
-/** A preprocessor over a namespace set of your own. */
+/** The resolving preprocessor (`mcePreprocess: true`), over the object model's namespaces. Returns the part's warnings. */
+export function mcePreprocess(doc, part) {
+    return preprocessAlternateContent(doc, { partName: part === null || part === void 0 ? void 0 : part.partName.name }).warnings;
+}
+/** A preprocessor over a namespace set (or kept hosts) of your own. */
 export function createMcePreprocessor(options) {
-    var _a;
-    const understood = (_a = options.understood) !== null && _a !== void 0 ? _a : UNDERSTOOD_NAMESPACES;
-    return (doc) => resolveAlternateContent(doc, understood);
+    return (doc, part) => preprocessAlternateContent(doc, { ...options, partName: part === null || part === void 0 ? void 0 : part.partName.name }).warnings;
 }
 /**
- * Resolves every mc:AlternateContent under a node, innermost first (a chosen branch may contain
- * another). Returns the number resolved.
+ * Resolves every mc:AlternateContent under a node, outermost first, but those `KEPT_HOSTS` and the
+ * nothing-selectable rule keep (see the file comment). Returns the number resolved.
  */
 export function resolveAlternateContent(root, understood = UNDERSTOOD_NAMESPACES) {
-    let count = 0;
+    return preprocessAlternateContent(root, { understood }).resolved;
+}
+/**
+ * The pass itself: what it resolved, kept and reported. With `resolve: false` it visits the elements
+ * resolving would, outermost first and into the branch the rule selects, reports the same warnings,
+ * and leaves the DOM as it was.
+ */
+export function preprocessAlternateContent(root, options = {}) {
+    var _a, _b, _c;
+    const understood = (_a = options.understood) !== null && _a !== void 0 ? _a : UNDERSTOOD_NAMESPACES;
+    const keptHosts = (_b = options.keptHosts) !== null && _b !== void 0 ? _b : KEPT_HOSTS;
+    const resolve = (_c = options.resolve) !== null && _c !== void 0 ? _c : true;
+    const result = { resolved: 0, kept: 0, warnings: [] };
     const visit = (node) => {
-        // Snapshot: replacing a child mutates the list.
-        const children = [];
+        var _a;
+        const hostKept = node.nodeType === 1 && keptHosts.has(`{${(_a = node.namespaceURI) !== null && _a !== void 0 ? _a : ''}}${node.localName}`);
+        // A work list, not the live child list: resolving replaces a child with the branch's content,
+        // which is visited in its turn (it may hold, or be, another mc:AlternateContent).
+        const queue = [];
         for (let c = node.firstChild; c; c = c.nextSibling)
-            children.push(c);
-        for (const child of children) {
-            if (child.nodeType !== 1)
+            queue.push(c);
+        for (let i = 0; i < queue.length; i++) {
+            if (queue[i].nodeType !== 1)
+                continue;
+            const el = queue[i];
+            if (!isAlternateContent(el)) {
+                visit(el);
+                continue;
+            }
+            const { choices, fallback } = branchesOf(el);
+            const chosen = choices.find((c) => choiceUnderstood(c, understood));
+            const branch = chosen !== null && chosen !== void 0 ? chosen : fallback;
+            if (hostKept || (branch === undefined && choices.length > 0)) {
+                result.kept++;
+                continue;
+            }
+            const warning = branchesDiffer(el, choices, fallback, branch, understood, options.partName);
+            if (warning)
+                result.warnings.push(warning);
+            if (!resolve) {
+                result.kept++;
+                if (branch)
+                    visit(branch);
                 continue;
-            visit(child);
-            const el = child;
-            if (el.namespaceURI === MCE_NS && el.localName === 'AlternateContent') {
-                replaceAlternateContent(el, understood);
-                count++;
             }
+            const moved = [];
+            if (branch)
+                for (let c = branch.firstChild; c; c = c.nextSibling)
+                    moved.push(c);
+            for (const n of moved)
+                node.insertBefore(n, el);
+            node.removeChild(el);
+            queue.splice(i + 1, 0, ...moved);
+            result.resolved++;
         }
     };
     visit(root);
-    return count;
+    return result;
+}
+function isAlternateContent(el) {
+    return el.namespaceURI === MCE_NS && el.localName === 'AlternateContent';
 }
-function replaceAlternateContent(ac, understood) {
-    let chosen;
+function branchesOf(ac) {
+    const choices = [];
     let fallback;
     for (let c = ac.firstChild; c; c = c.nextSibling) {
         if (c.nodeType !== 1)
@@ -44,21 +99,12 @@ function replaceAlternateContent(ac, understood) {
         const el = c;
         if (el.namespaceURI !== MCE_NS)
             continue;
-        if (el.localName === 'Choice' && !chosen && choiceUnderstood(el, understood))
-            chosen = el;
+        if (el.localName === 'Choice')
+            choices.push(el);
         else if (el.localName === 'Fallback' && !fallback)
             fallback = el;
     }
-    const branch = chosen !== null && chosen !== void 0 ? chosen : fallback;
-    const parent = ac.parentNode;
-    if (branch) {
-        const moved = [];
-        for (let c = branch.firstChild; c; c = c.nextSibling)
-            moved.push(c);
-        for (const n of moved)
-            parent.insertBefore(n, ac);
-    }
-    parent.removeChild(ac);
+    return { choices, fallback };
 }
 function choiceUnderstood(choice, understood) {
     var _a;
@@ -72,3 +118,64 @@ function choiceUnderstood(choice, understood) {
     }
     return true;
 }
+/** The text elements a branch's text is read from: WordprocessingML's, DrawingML's and OMML's `t`. */
+const TEXT_NAMESPACES = new Set([
+    'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
+    'http://schemas.openxmlformats.org/drawingml/2006/main',
+    'http://schemas.openxmlformats.org/officeDocument/2006/math',
+]);
+/**
+ * The text a branch holds: its w:t, a:t and m:t, whitespace collapsed. A nested
+ * mc:AlternateContent contributes the branch the same rule selects, or its first Choice when
+ * nothing is selectable (the reading rule).
+ */
+function textOfBranch(node, understood) {
+    const out = [];
+    const walk = (n) => {
+        var _a, _b, _c, _d;
+        for (let c = n.firstChild; c; c = c.nextSibling) {
+            if (c.nodeType !== 1)
+                continue;
+            const el = c;
+            if (isAlternateContent(el)) {
+                const { choices, fallback } = branchesOf(el);
+                const branch = (_b = (_a = choices.find((x) => choiceUnderstood(x, understood))) !== null && _a !== void 0 ? _a : fallback) !== null && _b !== void 0 ? _b : choices[0];
+                if (branch)
+                    walk(branch);
+            }
+            else if (el.localName === 't' && TEXT_NAMESPACES.has((_c = el.namespaceURI) !== null && _c !== void 0 ? _c : ''))
+                out.push((_d = el.textContent) !== null && _d !== void 0 ? _d : '');
+            else
+                walk(el);
+        }
+    };
+    walk(node);
+    return out.join('').replace(/\s+/g, ' ').trim();
+}
+function branchName(branch) {
+    var _a;
+    return branch.localName === 'Choice' ? `Choice(${((_a = branch.getAttribute('Requires')) !== null && _a !== void 0 ? _a : '').trim()})` : 'Fallback';
+}
+function branchesDiffer(ac, choices, fallback, selected, understood, partName) {
+    const all = fallback ? [...choices, fallback] : choices;
+    if (all.length < 2 || selected === undefined)
+        return undefined;
+    const branches = all.map((b) => ({ branch: branchName(b), text: textOfBranch(b, understood) }));
+    const taken = branches[all.indexOf(selected)];
+    if (branches.every((b) => b.text === taken.text))
+        return undefined;
+    const located = ac;
+    const where = typeof located.lineNumber === 'number' ? ` (line ${located.lineNumber}, column ${located.columnNumber})` : '';
+    const others = branches.filter((b) => b !== taken).map((b) => `${b.branch} ${JSON.stringify(abbreviate(b.text))}`).join(', ');
+    return {
+        code: 'mce.branches_differ',
+        partName,
+        ...(typeof located.lineNumber === 'number' ? { line: located.lineNumber, column: located.columnNumber } : {}),
+        selected: taken.branch,
+        branches,
+        message: `${partName !== null && partName !== void 0 ? partName : 'a part'}${where}: mc:AlternateContent's branches say different things; ${taken.branch} was read (${JSON.stringify(abbreviate(taken.text))}), not ${others}`,
+    };
+}
+function abbreviate(text) {
+    return text.length > 60 ? `${text.slice(0, 57)}...` : text;
+}

package/dist/opc/mce/understood.d.mts

@@ -1 +1,11 @@
 export declare const UNDERSTOOD_NAMESPACES: ReadonlySet<string>;
+/**
+ * The conventional prefixes of `UNDERSTOOD_NAMESPACES` (`NAMESPACE_PREFIXES`), which is what a reader of a
+ * kept mc:AlternateContent matches `mc:Choice/@Requires` against (CR-010 section 11.5): the unmarshalled
+ * model does not keep the declarations in force at the element, so the objects package's `mcBranchOf`
+ * compares prefixes, and its default set, every prefix `NAMESPACE_PREFIXES` knows, is wider than what
+ * load understands. Through this set a reader takes the branch the preprocessor would have resolved to,
+ * wherever the document writes the conventional prefixes. An understood namespace with no conventional
+ * prefix has no entry.
+ */
+export declare const UNDERSTOOD_PREFIXES: ReadonlySet<string>;

package/dist/opc/mce/understood.mjs

@@ -4,10 +4,12 @@
 //
 // It is the defaultElementNamespaceURI of every generated module of @docx4j/generated-objects-ts
 // (0.3.0), which `mce.test.mjs` asserts so that the next regeneration announces an addition, plus
-// two groups of hand-kept entries, each marked below: namespaces no module *defaults* to but which
-// the model binds anyway (attributes, or elements a module of another namespace declares), and the
+// three groups of hand-kept entries, each marked below: namespaces no module *defaults* to but which
+// the model binds anyway (attributes, or elements a module of another namespace declares), the
 // slicer namespaces of CR-004 phase B, whose content the model does not bind at all but carries
-// through as DOM.
+// through as DOM, and the chartex namespaces Office gates a chart's frame with, which nothing in the
+// Choice uses (CR-009 section 8).
+import { NAMESPACE_PREFIXES } from '@docx4j/generated-objects-ts';
 export const UNDERSTOOD_NAMESPACES = new Set([
     'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
     'http://schemas.openxmlformats.org/package/2006/relationships',
@@ -124,4 +126,24 @@ export const UNDERSTOOD_NAMESPACES = new Set([
     'http://schemas.microsoft.com/office/drawing/2010/slicer',
     'http://schemas.microsoft.com/office/drawing/2012/slicer',
     'http://schemas.microsoft.com/office/drawing/2012/timeslicer',
+    // Office's chartex charts (CR-009 section 8). Word, Excel and PowerPoint gate a chartex frame with
+    // a later chartex namespace than the chart's own: Requires="cx1" (2015/9/8) for a waterfall or a
+    // histogram, "cx2" (2015/10/21) for a funnel. Nothing in the Choice is in it: the frame's
+    // a:graphicData holds a cx:chart of the 2014 namespace, which the model binds. Nothing binds these
+    // two (docx4j has no schema for them), but the Choice round-trips whole, and the Fallback is only a
+    // picture of the chart, or in Excel a box saying the chart is not available, so leaving it would
+    // lose the chart on any save that re-marshals the part. Office's other chartex namespaces are not
+    // here: no file seen gates a Choice with one.
+    'http://schemas.microsoft.com/office/drawing/2015/9/8/chartex',
+    'http://schemas.microsoft.com/office/drawing/2015/10/21/chartex',
 ]);
+/**
+ * The conventional prefixes of `UNDERSTOOD_NAMESPACES` (`NAMESPACE_PREFIXES`), which is what a reader of a
+ * kept mc:AlternateContent matches `mc:Choice/@Requires` against (CR-010 section 11.5): the unmarshalled
+ * model does not keep the declarations in force at the element, so the objects package's `mcBranchOf`
+ * compares prefixes, and its default set, every prefix `NAMESPACE_PREFIXES` knows, is wider than what
+ * load understands. Through this set a reader takes the branch the preprocessor would have resolved to,
+ * wherever the document writes the conventional prefixes. An understood namespace with no conventional
+ * prefix has no entry.
+ */
+export const UNDERSTOOD_PREFIXES = new Set([...UNDERSTOOD_NAMESPACES].map((uri) => NAMESPACE_PREFIXES[uri]).filter((prefix) => prefix !== undefined && prefix !== ''));

package/dist/packages/OpcPackage.d.mts

@@ -9,6 +9,7 @@ import { Parts } from '../parts/Parts.mjs';
 import { RelationshipsPart, type AddPartBehaviour } from '../parts/RelationshipsPart.mjs';
 import type { CustomXmlDataStoragePart } from '../parts/DefaultXmlPart.mjs';
 import { DocPropsCorePart, DocPropsExtendedPart, DocPropsCustomPart } from '../parts/docProps/index.mjs';
+import { type PartWarning } from '../opc/mce/preprocessor.mjs';
 /** Anything `OpcPackage.load` accepts: zip bytes, a flat OPC string, or a container. */
 export type PackageSource = Uint8Array | ArrayBuffer | string | PartStore;
 /**
@@ -44,6 +45,12 @@ export declare class OpcPackage implements RelationshipSource {
     setPartShortcut(part: Part, relationshipType: string): boolean;
     /** The main part: the target of the officeDocument relationship. */
     getMainPart(): Part | undefined;
+    /**
+     * The warnings of every part parsed so far (each XML part's `warnings`, CR-010 phase 1). A part
+     * is parsed when something reads it, so a reader that wants a whole package's warnings reads its
+     * parts first; `unmarshalAll()` does, at the cost of re-marshalling every part on save.
+     */
+    get warnings(): PartWarning[];
     /** Unmarshals every XML part, so that `contents` is available synchronously everywhere. */
     unmarshalAll(): Promise<void>;
     /** Adds empty core properties if absent (docx4j addDocPropsCorePart). */

package/dist/packages/OpcPackage.mjs

@@ -11,7 +11,7 @@ import { Parts } from '../parts/Parts.mjs';
 import { XmlPart } from '../parts/XmlPart.mjs';
 import { RelationshipsPart } from '../parts/RelationshipsPart.mjs';
 import { DocPropsCorePart, DocPropsExtendedPart } from '../parts/docProps/index.mjs';
-import { mcePreprocess } from '../opc/mce/preprocessor.mjs';
+import { mceKeep, mcePreprocess } from '../opc/mce/preprocessor.mjs';
 import { createPackageForContentType, registerGenericPackageClass } from './registry.mjs';
 /**
  * An Open Packaging Conventions package (docx4j org.docx4j.openpackaging.packages.OpcPackage):
@@ -41,8 +41,8 @@ export class OpcPackage {
     static async load(source, options = {}) {
         const store = toStore(source);
         const opts = { ...options };
-        if (opts.preprocessor === undefined && opts.mcePreprocess !== false)
-            opts.preprocessor = mcePreprocess;
+        if (opts.preprocessor === undefined)
+            opts.preprocessor = opts.mcePreprocess === true ? mcePreprocess : mceKeep;
         const pkg = await loadPackage(store, createPackageForContentType, opts);
         pkg.loadOptions = opts;
         return pkg;
@@ -79,6 +79,18 @@ export class OpcPackage {
         const rel = (_a = this.relationshipsPart.getRelationshipByType(Namespaces.DOCUMENT)) !== null && _a !== void 0 ? _a : this.relationshipsPart.getRelationshipByType(Namespaces.DOCUMENT_STRICT);
         return rel ? this.relationshipsPart.getPart(rel) : undefined;
     }
+    /**
+     * The warnings of every part parsed so far (each XML part's `warnings`, CR-010 phase 1). A part
+     * is parsed when something reads it, so a reader that wants a whole package's warnings reads its
+     * parts first; `unmarshalAll()` does, at the cost of re-marshalling every part on save.
+     */
+    get warnings() {
+        const out = [];
+        for (const part of this.parts)
+            if (part instanceof XmlPart)
+                out.push(...part.warnings);
+        return out;
+    }
     /** Unmarshals every XML part, so that `contents` is available synchronously everywhere. */
     async unmarshalAll() {
         for (const part of this.parts)

package/dist/packages/WordprocessingMLPackage.d.mts

@@ -3,7 +3,7 @@ import type { LoadOptions } from '../opc/Load.mjs';
 import type { Part } from '../parts/Part.mjs';
 import { MainDocumentPart, StyleDefinitionsPart, type NumberingDefinitionsPart } from '../parts/wml/index.mjs';
 import { type FontSettings, type DefaultThemeValue } from '../model/fonts/defaultTheme.mjs';
-import type { Body, Address, Outline, OutlineParagraph, OutlineTable } from '../model/content/Body.mjs';
+import { Body, type Address, type Outline, type OutlineParagraph, type OutlineTable } from '../model/content/Body.mjs';
 import type { Paragraph } from '../model/content/Paragraph.mjs';
 import type { Author } from '../model/content/comments.mjs';
 import { CustomXmlPartCollection } from '../model/customxml/CustomXmlPartCollection.mjs';
@@ -14,7 +14,8 @@ import { StylesFacade } from '../model/content/stylesFacade.mjs';
 import type { Bound } from '../model/content/binder.mjs';
 import { PropertyResolver } from '../model/properties/PropertyResolver.mjs';
 import type { Emulator } from '../model/listnumbering/Emulator.mjs';
-import type { TrackedChange } from '../model/content/TrackedChange.mjs';
+import { type TrackedChange, type NoteRemovals } from '../model/content/TrackedChange.mjs';
+import { type RelationshipRemovals } from '../model/content/relationships.mjs';
 import { XmlPart } from '../parts/XmlPart.mjs';
 import type { PartSink } from '../opc/PartStore.mjs';
 import '../parts/wml/comments.mjs';
@@ -87,6 +88,20 @@ export declare class WordprocessingMLPackage extends OpcPackage implements Track
      * the package is saved (check 32; `TrackedChange`). An extension.
      */
     readonly pendingCommentRemovals: Set<number>;
+    /**
+     * Footnotes and endnotes whose references went with content a tracked change took away (a rejected
+     * insertion, an accepted deletion, a row or cell, a move's other half): their entries go from the
+     * notes parts when the package is saved, each unless a reference to it still stands, as Word took
+     * them (CR-002 section 44; `TrackedChange`). An extension.
+     */
+    readonly pendingNoteRemovals: NoteRemovals;
+    /**
+     * Relationships, by the name of their part, that a picture removed outright referenced (tracking off,
+     * or a picture taken back from its author's own insertion): each goes when the package is saved if
+     * nothing then references it, and its part with it when nothing else targets that (CR-002 section
+     * 47). Settled on save, not at once, so a picture cut and pasted back keeps its image. An extension.
+     */
+    readonly pendingRelationshipRemovals: RelationshipRemovals;
     /**
      * The parts `seedAnnotationIds()` has read, with what it read: `true` for a part still holding its
      * source, whose bytes cannot change, and otherwise the bytes that were set, which stay the same
@@ -201,6 +216,24 @@ export declare class WordprocessingMLPackage extends OpcPackage implements Track
      * unmarshalled, as `body` needs it to be.
      */
     getTrackedChanges(): TrackedChange[];
+    /**
+     * Accepts every tracked change in every story: the main document, the footnotes, the endnotes and
+     * the comments, the headers and footers, and the text boxes in each. Word's
+     * `Document.AcceptAllRevisions` did that on docx4j's CR-043 probe (Word 16.0.20326), and left no
+     * revision in any story; `Body.acceptAll` resolves its own story only, as Office JS's `body` does
+     * (CR-002 section 49). A story part with no revision markup is not read, so it keeps its bytes.
+     * Returns how many changes were listed, story by story. An extension, named after Word's verb.
+     */
+    acceptAllRevisions(): Promise<number>;
+    /** Rejects every tracked change in every story, as `acceptAllRevisions` accepts them (Word's `Document.RejectAllRevisions`). */
+    rejectAllRevisions(): Promise<number>;
+    private resolveEveryStory;
+    /**
+     * The body of every story whose part holds revision markup, in docx4j's order (its CR-043
+     * `TrackedChanges.in`): the main document, each footnote, each endnote, each comment, then the
+     * headers and footers. A footnote, an endnote or a comment is a body of its own over its content.
+     */
+    private revisedStories;
     /** The tracker every content-API mutation asks for; undefined while the mode is `Off`. */
     get changeTracker(): ChangeTracker | undefined;
     /**

package/dist/packages/WordprocessingMLPackage.mjs

@@ -10,6 +10,7 @@ import { DEFAULT_STYLES_XML } from '../parts/wml/defaultStyles.mjs';
 import { ThemePart } from '../parts/dml/index.mjs';
 import { newFontSettings, themeOfSettings, } from '../model/fonts/defaultTheme.mjs';
 import { HeaderPart, FooterPart } from '../parts/wml/index.mjs';
+import { Body, resolveStory } from '../model/content/Body.mjs';
 import { CustomXmlPartCollection } from '../model/customxml/CustomXmlPartCollection.mjs';
 import { DefaultXPathEngine } from '../model/customxml/xpath.mjs';
 import { ChangeTracker, highestAnnotationId } from '../model/content/tracking.mjs';
@@ -18,6 +19,8 @@ import { StylesFacade } from '../model/content/stylesFacade.mjs';
 import { flushPendingCommentRemovals } from '../model/content/Comment.mjs';
 import { PropertyResolver } from '../model/properties/PropertyResolver.mjs';
 import { PropertyResolverNotCreatedException } from '../opc/exceptions.mjs';
+import { flushPendingNoteRemovals } from '../model/content/TrackedChange.mjs';
+import { flushPendingRelationshipRemovals } from '../model/content/relationships.mjs';
 import { XmlPart } from '../parts/XmlPart.mjs';
 // Registers the comment parts with the content API (CR-002 phase G); no cycle: the model half
 // never imports a part, as packages/registry.mts does for the package classes.
@@ -88,6 +91,20 @@ export class WordprocessingMLPackage extends OpcPackage {
          * the package is saved (check 32; `TrackedChange`). An extension.
          */
         this.pendingCommentRemovals = new Set();
+        /**
+         * Footnotes and endnotes whose references went with content a tracked change took away (a rejected
+         * insertion, an accepted deletion, a row or cell, a move's other half): their entries go from the
+         * notes parts when the package is saved, each unless a reference to it still stands, as Word took
+         * them (CR-002 section 44; `TrackedChange`). An extension.
+         */
+        this.pendingNoteRemovals = { footnote: new Set(), endnote: new Set() };
+        /**
+         * Relationships, by the name of their part, that a picture removed outright referenced (tracking off,
+         * or a picture taken back from its author's own insertion): each goes when the package is saved if
+         * nothing then references it, and its part with it when nothing else targets that (CR-002 section
+         * 47). Settled on save, not at once, so a picture cut and pasted back keeps its image. An extension.
+         */
+        this.pendingRelationshipRemovals = new Map();
         /**
          * The parts `seedAnnotationIds()` has read, with what it read: `true` for a part still holding its
          * source, whose bytes cannot change, and otherwise the bytes that were set, which stay the same
@@ -220,6 +237,10 @@ export class WordprocessingMLPackage extends OpcPackage {
             this.resolver = resolver;
             this.resolverPending = undefined;
             return resolver;
+        }, (e) => {
+            // not kept: a styles part put right (setXml) is read again on the next call
+            this.resolverPending = undefined;
+            throw e;
         }));
         return this.resolverPending;
     }
@@ -399,6 +420,56 @@ export class WordprocessingMLPackage extends OpcPackage {
     getTrackedChanges() {
         return this.body.getTrackedChanges();
     }
+    /**
+     * Accepts every tracked change in every story: the main document, the footnotes, the endnotes and
+     * the comments, the headers and footers, and the text boxes in each. Word's
+     * `Document.AcceptAllRevisions` did that on docx4j's CR-043 probe (Word 16.0.20326), and left no
+     * revision in any story; `Body.acceptAll` resolves its own story only, as Office JS's `body` does
+     * (CR-002 section 49). A story part with no revision markup is not read, so it keeps its bytes.
+     * Returns how many changes were listed, story by story. An extension, named after Word's verb.
+     */
+    async acceptAllRevisions() {
+        return this.resolveEveryStory('accept');
+    }
+    /** Rejects every tracked change in every story, as `acceptAllRevisions` accepts them (Word's `Document.RejectAllRevisions`). */
+    async rejectAllRevisions() {
+        return this.resolveEveryStory('reject');
+    }
+    async resolveEveryStory(what) {
+        let count = 0;
+        for (const body of await this.revisedStories())
+            count += resolveStory(body, what);
+        return count;
+    }
+    /**
+     * The body of every story whose part holds revision markup, in docx4j's order (its CR-043
+     * `TrackedChanges.in`): the main document, each footnote, each endnote, each comment, then the
+     * headers and footers. A footnote, an endnote or a comment is a body of its own over its content.
+     */
+    async revisedStories() {
+        var _a, _b;
+        const main = this.getMainDocumentPart();
+        const out = [];
+        if (await holdsRevisions(main))
+            out.push(await main.getBody());
+        for (const [part, kind] of [[main.footnotesPart, 'footnote'], [main.endnotesPart, 'endnote']]) {
+            if (!part || !(await holdsRevisions(part)))
+                continue;
+            const contents = await part.getContents();
+            for (const note of (_a = (kind === 'footnote' ? contents.footnote : contents.endnote)) !== null && _a !== void 0 ? _a : []) {
+                out.push(new Body(part, note, `${kind}:${note.id}`, this));
+            }
+        }
+        const comments = main.commentsPart;
+        if (comments && (await holdsRevisions(comments))) {
+            for (const comment of (_b = (await comments.getContents()).comment) !== null && _b !== void 0 ? _b : [])
+                out.push(new Body(comments, comment, `comment:${comment.id}`, this));
+        }
+        for (const part of [...main.headerParts, ...main.footerParts])
+            if (await holdsRevisions(part))
+                out.push(await part.getBody());
+        return out;
+    }
     /** The tracker every content-API mutation asks for; undefined while the mode is `Off`. */
     get changeTracker() {
         const mode = this.changeTrackingMode;
@@ -506,6 +577,12 @@ export class WordprocessingMLPackage extends OpcPackage {
         target.author = { ...this.author };
         for (const id of this.pendingCommentRemovals)
             target.pendingCommentRemovals.add(id);
+        for (const id of this.pendingNoteRemovals.footnote)
+            target.pendingNoteRemovals.footnote.add(id);
+        for (const id of this.pendingNoteRemovals.endnote)
+            target.pendingNoteRemovals.endnote.add(id);
+        for (const [name, ids] of this.pendingRelationshipRemovals)
+            target.pendingRelationshipRemovals.set(name, new Set(ids));
         target.trackedChangeDate = this.trackedChangeDate;
         target.fonts.defaultTheme = this.fonts.defaultTheme;
         target.xpathEngine = this.xpathEngine;
@@ -514,8 +591,18 @@ export class WordprocessingMLPackage extends OpcPackage {
         var _a;
         if (this.trackingPending)
             await this.setChangeTrackingMode((_a = this.trackingMode) !== null && _a !== void 0 ? _a : 'Off');
-        if (this.pendingCommentRemovals.size > 0)
-            await flushPendingCommentRemovals(await this.getBody());
+        // what removed content took with it, until nothing more goes: a removed note takes the comments
+        // anchored in it, and a removed note or comment the relationships its content held, which the last
+        // step settles (CR-002 section 50; docx4j's Removals.flush repeats the same way)
+        const notes = this.pendingNoteRemovals;
+        for (let round = 0; round < 10 && this.pendingCommentRemovals.size + notes.footnote.size + notes.endnote.size > 0; round++) {
+            if (this.pendingCommentRemovals.size > 0)
+                await flushPendingCommentRemovals(await this.getBody());
+            if (notes.footnote.size + notes.endnote.size > 0)
+                await flushPendingNoteRemovals(this.getMainDocumentPart(), notes, this);
+        }
+        if (this.pendingRelationshipRemovals.size > 0)
+            flushPendingRelationshipRemovals(this, this.pendingRelationshipRemovals);
         if (this.requiredStyles.size > 0) {
             await this.styles.ensure([...this.requiredStyles]);
             this.requiredStyles.clear();
@@ -621,12 +708,22 @@ export class WordprocessingMLPackage extends OpcPackage {
                 return bodies;
             },
             customXmlRelationshipSource: () => this.getMainDocumentPart(),
+            xhtmlHost: this,
         })));
     }
     get progId() {
         return 'Word.Document';
     }
 }
+/** Revision markup, by local name in any prefix: what a story part holds when it has a tracked change to resolve. */
+const REVISION_MARKUP = /<(?:[\w.-]+:)?(?:ins|del|moveFrom|moveTo|rPrChange|pPrChange|sectPrChange|tblPrChange|trPrChange|tcPrChange|tblGridChange|tblPrExChange|cellIns|cellDel|cellMerge|numberingChange|customXmlInsRangeStart|customXmlDelRangeStart)[\s/>]/;
+/**
+ * True when a story part may hold a tracked change: always once it is unmarshalled, else when its
+ * source has revision markup, read without unmarshalling it, so a part with none keeps its bytes.
+ */
+async function holdsRevisions(part) {
+    return part.isUnmarshalled || REVISION_MARKUP.test(await part.getXml());
+}
 /**
  * `w:trackRevisions` is a flag, so a file cannot distinguish `TrackAll` from `TrackMineOnly`;
  * a document that has it on reads as `TrackAll`, and either value writes it.