@docx4j/core-ts 0.4.0 → 0.6.0

package/dist/opc/mce/preprocessor.mjs

@@ -1,42 +1,97 @@
-import { UNDERSTOOD_NAMESPACES } from './understood.mjs';
+import { READ_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 `READ_UNDERSTOOD_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, 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 = READ_UNDERSTOOD_NAMESPACES) {
+    return preprocessAlternateContent(root, { understood }).resolved;
 }
 /**
- * Resolves every mc:AlternateContent under a node, innermost first (a chosen branch may contain
- * another). Returns the number 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 resolveAlternateContent(root, understood = UNDERSTOOD_NAMESPACES) {
-    let count = 0;
+export function preprocessAlternateContent(root, options = {}) {
+    var _a, _b, _c;
+    const understood = (_a = options.understood) !== null && _a !== void 0 ? _a : READ_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 replaceAlternateContent(ac, understood) {
-    let chosen;
+function isAlternateContent(el) {
+    return el.namespaceURI === MCE_NS && el.localName === 'AlternateContent';
+}
+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,35 @@
 export declare const UNDERSTOOD_NAMESPACES: ReadonlySet<string>;
+/**
+ * The conventional prefixes of `UNDERSTOOD_NAMESPACES` (`NAMESPACE_PREFIXES`), the object model's namespaces
+ * expressed as prefixes (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. The readers match
+ * against `READ_UNDERSTOOD_PREFIXES`, this and four more. An understood namespace with no conventional
+ * prefix has no entry.
+ */
+export declare const UNDERSTOOD_PREFIXES: ReadonlySet<string>;
+/**
+ * The namespaces a reader of a kept mc:AlternateContent counts as understood beyond `UNDERSTOOD_NAMESPACES`
+ * (CR-010 section 15): Word 365 takes a Choice requiring any of them (measured 2026-10-20), and docx4j's
+ * published understood list (`understood-namespaces.txt`) has all four, among the 11 its JAXB contexts
+ * bind and no generated module here does. The name is CR-010's, when only the readers counted them;
+ * since CR-013 (D3) resolving does too (`READ_UNDERSTOOD_NAMESPACES`). Resolving turns the Choice it takes
+ * into typed content, which no module types here, but what Word writes in these namespaces survives a
+ * re-marshal: in every file seen it is attributes only (`w16du:dateUtc`, `w16sdtdh:storeItemChecksum`,
+ * `x14ac:dyDescent` and `x14ac:knownFonts`; `w16sdtfl` is only declared), measured 2026-10-21.
+ */
+export declare const READ_ONLY_UNDERSTOOD_NAMESPACES: ReadonlySet<string>;
+/**
+ * What a reader of a kept mc:AlternateContent matches `mc:Choice/@Requires` against (`selectedBranchOf`,
+ * docx4j's `McMode.READ`): `UNDERSTOOD_PREFIXES` and the conventional prefixes of
+ * `READ_ONLY_UNDERSTOOD_NAMESPACES`. A Choice requiring only these is taken by the gate alone, as REQ-302
+ * of the text extraction specification reads, whatever its content (CR-010 section 15).
+ */
+export declare const READ_UNDERSTOOD_PREFIXES: ReadonlySet<string>;
+/**
+ * What load selects by, as namespaces: `UNDERSTOOD_NAMESPACES` and `READ_ONLY_UNDERSTOOD_NAMESPACES`, the
+ * readers' set (`READ_UNDERSTOOD_PREFIXES`) by URI. Resolving (`mcePreprocess: true`) takes the Choice it
+ * names, and the default load's `mce.branches_differ` reports it as the selected branch, so a resolved load
+ * takes the branch the readers of a kept load take, as Word 365 does (CR-013 D3).
+ */
+export declare const READ_UNDERSTOOD_NAMESPACES: 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,54 @@ 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',
 ]);
+const prefixesOf = (namespaces) => [...namespaces].map((uri) => NAMESPACE_PREFIXES[uri]).filter((prefix) => prefix !== undefined && prefix !== '');
+/**
+ * The conventional prefixes of `UNDERSTOOD_NAMESPACES` (`NAMESPACE_PREFIXES`), the object model's namespaces
+ * expressed as prefixes (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. The readers match
+ * against `READ_UNDERSTOOD_PREFIXES`, this and four more. An understood namespace with no conventional
+ * prefix has no entry.
+ */
+export const UNDERSTOOD_PREFIXES = new Set(prefixesOf(UNDERSTOOD_NAMESPACES));
+/**
+ * The namespaces a reader of a kept mc:AlternateContent counts as understood beyond `UNDERSTOOD_NAMESPACES`
+ * (CR-010 section 15): Word 365 takes a Choice requiring any of them (measured 2026-10-20), and docx4j's
+ * published understood list (`understood-namespaces.txt`) has all four, among the 11 its JAXB contexts
+ * bind and no generated module here does. The name is CR-010's, when only the readers counted them;
+ * since CR-013 (D3) resolving does too (`READ_UNDERSTOOD_NAMESPACES`). Resolving turns the Choice it takes
+ * into typed content, which no module types here, but what Word writes in these namespaces survives a
+ * re-marshal: in every file seen it is attributes only (`w16du:dateUtc`, `w16sdtdh:storeItemChecksum`,
+ * `x14ac:dyDescent` and `x14ac:knownFonts`; `w16sdtfl` is only declared), measured 2026-10-21.
+ */
+export const READ_ONLY_UNDERSTOOD_NAMESPACES = new Set([
+    'http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash', // w16sdtdh
+    'http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock', // w16sdtfl
+    'http://schemas.microsoft.com/office/word/2023/wordml/word16du', // w16du
+    'http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac', // x14ac
+]);
+/**
+ * What a reader of a kept mc:AlternateContent matches `mc:Choice/@Requires` against (`selectedBranchOf`,
+ * docx4j's `McMode.READ`): `UNDERSTOOD_PREFIXES` and the conventional prefixes of
+ * `READ_ONLY_UNDERSTOOD_NAMESPACES`. A Choice requiring only these is taken by the gate alone, as REQ-302
+ * of the text extraction specification reads, whatever its content (CR-010 section 15).
+ */
+export const READ_UNDERSTOOD_PREFIXES = new Set([...UNDERSTOOD_PREFIXES, ...prefixesOf(READ_ONLY_UNDERSTOOD_NAMESPACES)]);
+/**
+ * What load selects by, as namespaces: `UNDERSTOOD_NAMESPACES` and `READ_ONLY_UNDERSTOOD_NAMESPACES`, the
+ * readers' set (`READ_UNDERSTOOD_PREFIXES`) by URI. Resolving (`mcePreprocess: true`) takes the Choice it
+ * names, and the default load's `mce.branches_differ` reports it as the selected branch, so a resolved load
+ * takes the branch the readers of a kept load take, as Word 365 does (CR-013 D3).
+ */
+export const READ_UNDERSTOOD_NAMESPACES = new Set([...UNDERSTOOD_NAMESPACES, ...READ_ONLY_UNDERSTOOD_NAMESPACES]);

package/dist/packages/OpcPackage.d.mts

@@ -4,11 +4,13 @@ import { ContentTypeManager } from '../opc/ContentTypeManager.mjs';
 import { type PartStore, type PartSink } from '../opc/PartStore.mjs';
 import { type FlatOpcSinkOptions } from '../opc/FlatOpcPartStore.mjs';
 import { type LoadOptions } from '../opc/Load.mjs';
+import { type SaveReport } from '../opc/Save.mjs';
 import { Part, type RelationshipSource } from '../parts/Part.mjs';
 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;
 /**
@@ -30,6 +32,18 @@ export declare class OpcPackage implements RelationshipSource {
     docPropsCorePart: DocPropsCorePart | undefined;
     docPropsExtendedPart: DocPropsExtendedPart | undefined;
     docPropsCustomPart: DocPropsCustomPart | undefined;
+    /**
+     * Whether a save writes run properties in their normal form (CR-015 D2; docx4j CR-061's
+     * `setNormaliseOnSave`): a colour Word accepts as upper-case `RRGGBB`, one it rejects left out (a text or
+     * underline colour) or `auto` (a fill's, a border's), a `w:highlight`, `w:vertAlign` or `w:em` Word repairs away
+     * left out; a revision's former properties too. Only what is written changes: the tree keeps what it read, and a
+     * part nobody unmarshalled is still copied byte for byte. Undefined defers to the objects package's process-wide
+     * `setNormaliseOnSave` (on unless set off); a package's own setting wins over it. False writes values as read.
+     * On/off values and `w:u`'s are settled when the part is read, so they are written the same either way.
+     */
+    normaliseOnSave: boolean | undefined;
+    /** What the last save did beyond writing the package: each value it normalised (CR-015 D8). Undefined until one. */
+    lastSave: SaveReport | undefined;
     constructor();
     get package(): OpcPackage;
     /**
@@ -44,6 +58,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)
@@ -123,6 +135,7 @@ export class OpcPackage {
         if (copy.constructor !== this.constructor) {
             throw new Docx4JException(`Cloning ${this.constructor.name} produced ${copy.constructor.name}`);
         }
+        copy.normaliseOnSave = this.normaliseOnSave;
         this.copyPackageSettingsTo(copy);
         return copy;
     }

package/dist/packages/WordprocessingMLPackage.d.mts

@@ -3,7 +3,8 @@ 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 TrackedChangeSelection } from '../model/content/trackedChangeFilter.mjs';
 import type { Paragraph } from '../model/content/Paragraph.mjs';
 import type { Author } from '../model/content/comments.mjs';
 import { CustomXmlPartCollection } from '../model/customxml/CustomXmlPartCollection.mjs';
@@ -11,13 +12,18 @@ import { type XPathEngine } from '../model/customxml/xpath.mjs';
 import { ChangeTracker, type ChangeTrackingMode, type TrackingHost, type TrackingScope } from '../model/content/tracking.mjs';
 import { NumberingFacade } from '../model/content/List.mjs';
 import { StylesFacade } from '../model/content/stylesFacade.mjs';
+import { GlossaryEntries } from '../model/content/placeholders.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';
+import '../model/text/outline.mjs';
+import type { TextContext } from '../model/text/TextContext.mjs';
+import type { TextOptions, TextOptionsInit } from '../model/text/TextOptions.mjs';
 /** The outline of a document: the body's paragraphs and tables, then each header's and footer's (loaded ones only). */
 export interface DocumentOutline extends Outline {
     headers: {
@@ -87,6 +93,26 @@ 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 glossary's placeholder entries: read privately when a body is first read (`getBody`, `Word.run`), and those a
+     * placeholder written since names, which go into the glossary when the package is saved, the glossary made where the
+     * file has none (CR-002 section 63, D8 and D9). An extension.
+     */
+    readonly glossaryEntries: GlossaryEntries;
     /**
      * 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
@@ -197,10 +223,46 @@ export declare class WordprocessingMLPackage extends OpcPackage implements Track
     private settingsPart;
     /**
      * Office JS `document.getTrackedChanges()`: every tracked change in the main document part,
-     * in document order (headers and footers have their own `Body`). The part must be
-     * unmarshalled, as `body` needs it to be.
+     * in document order (headers and footers have their own `Body`; `getAllTrackedChanges` lists
+     * every story). The part must be unmarshalled, as `body` needs it to be.
      */
     getTrackedChanges(): TrackedChange[];
+    /**
+     * Every tracked change in every story, in docx4j's order (its CR-043 `TrackedChanges.in`, CR-011):
+     * the main document, each footnote, each endnote, each comment, then the headers and footers in the
+     * order the sections reference them; a text box's after the story it is in. Each story's are its
+     * `Body.getTrackedChanges()`, grouped as Office JS groups them, so changes never group across two
+     * stories. `TrackedChange.part` says which part each is in.
+     *
+     * With a filter, the changes with a piece it matches, each whole (docx4j's `in(pkg, filter)`).
+     *
+     * A story part whose source holds no revision markup is not read, so it keeps its bytes; one that
+     * does is unmarshalled, since the views returned must be resolvable, and so is re-marshalled on save.
+     * An extension: Office JS lists one body at a time.
+     */
+    getAllTrackedChanges(filter?: TrackedChangeSelection): Promise<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.
+     *
+     * With a filter (CR-011), only the single changes it matches are accepted, as `Body.acceptAll`
+     * takes one, and the count is of the listed changes with a matching piece.
+     */
+    acceptAllRevisions(filter?: TrackedChangeSelection): Promise<number>;
+    /** Rejects every tracked change in every story, as `acceptAllRevisions` accepts them (Word's `Document.RejectAllRevisions`). */
+    rejectAllRevisions(filter?: TrackedChangeSelection): 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 in section order (`inSectionOrder`). 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;
     /**
@@ -261,10 +323,18 @@ export declare class WordprocessingMLPackage extends OpcPackage implements Track
     /** A clone carries the identity, the tracking date, the theme setting, the XPath engine and the styles still to ensure. */
     protected copyPackageSettingsTo(target: OpcPackage): void;
     saveTo<R>(sink: PartSink<R>): Promise<R>;
-    /** The paragraph at an address anywhere in the document: 'body/3', 'header:rId5/0', a paraId, or a text match. */
+    /**
+     * The paragraph at an address anywhere in the document: 'body/3', 'header:rId5/0', 'footnote:2/0',
+     * 'endnote:1/0', 'comment:5/0', 'body/3/textbox:0/1' (a text box's paragraph, read-only: CR-012 D4 and
+     * D5), a paraId, or a text match. Undefined where the address names no paragraph.
+     */
     paragraphAt(address: Address): Promise<Paragraph | undefined>;
-    /** Every paragraph and table with its address, style and text (CR-002 section 3.3). Unmarshals the main part, headers and footers. */
-    outline(): Promise<DocumentOutline>;
+    /**
+     * Every paragraph and table with its address, style and text (CR-002 section 3.3), read by the text model
+     * under one context (CR-012 D3: `Body.outline`, whose options it takes): the main document, then each
+     * header and footer. Unmarshals the main part, headers and footers.
+     */
+    outline(options?: TextOptionsInit | TextOptions, context?: TextContext): Promise<DocumentOutline>;
     private bodies;
     /**
      * The XPath engine the custom XML views use (CR-002 section 3.6): `document.evaluate` in a