@docx4j/core-ts 0.5.0 → 0.7.0

package/dist/packages/OpcPackage.mjs

@@ -9,8 +9,9 @@ import { Docx4JException } from '../opc/exceptions.mjs';
 import { Namespaces } from '../parts/Namespaces.mjs';
 import { Parts } from '../parts/Parts.mjs';
 import { XmlPart } from '../parts/XmlPart.mjs';
-import { RelationshipsPart } from '../parts/RelationshipsPart.mjs';
+import { RelationshipsPart, isExternal } from '../parts/RelationshipsPart.mjs';
 import { DocPropsCorePart, DocPropsExtendedPart } from '../parts/docProps/index.mjs';
+import { assertTimeZone, runtimeTimeZone } from '../model/dateZone.mjs';
 import { mceKeep, mcePreprocess } from '../opc/mce/preprocessor.mjs';
 import { createPackageForContentType, registerGenericPackageClass } from './registry.mjs';
 /**
@@ -18,6 +19,27 @@ import { createPackageForContentType, registerGenericPackageClass } from './regi
  * the content types, the package relationships and the parts reachable from them.
  */
 export class OpcPackage {
+    /**
+     * The client's time zone for this package, an IANA id (`Australia/Sydney`), or undefined for the runtime's (CR-018; the
+     * portfolio's date rule of 2026-10-28, docx4j's `OpcPackage.setDateTimeZone`). Every instant the package holds is shown
+     * in it, and a `w:date` without `dateUtc` read in it: a new revision's or comment's stamp (Word's local wall-clock
+     * `w:date`), `TrackedChange.date` and `Comment.creationDate`, and date fields when they are evaluated (CR-012 phase 5).
+     * It is the client's for this package, not the document's, and reaches no saved file as such: a server reusing a
+     * loaded package sets it per request. Under Office JS the runtime's zone is already the client's. A bound date has no
+     * zone (CR-002 section 56) unless `boundDatesConvertedAsWord` asks for Word's conversion in this one. A zone the
+     * runtime does not know is refused with a `RangeError` at the set.
+     */
+    get dateTimeZone() {
+        return this.dateTimeZone_;
+    }
+    set dateTimeZone(id) {
+        this.dateTimeZone_ = id === undefined ? undefined : assertTimeZone(id);
+    }
+    /** The zone in force: `dateTimeZone`, else the runtime's. */
+    effectiveDateTimeZone() {
+        var _a;
+        return (_a = this.dateTimeZone_) !== null && _a !== void 0 ? _a : runtimeTimeZone();
+    }
     constructor() {
         /** The pseudo part name of the package itself: the source of the package relationships. */
         this.partName = PartName.ROOT;
@@ -26,7 +48,46 @@ export class OpcPackage {
         /** Custom XML parts by the (lower-cased) itemID of their properties part. */
         this.customXmlDataStorageParts = new Map();
         /** The options this package was loaded with. */
+        /**
+         * The names the container held more than one entry of, each read from its first entry under
+         * `LoadOptions.repair: 'word'` (WD REQ-206, CR-024); empty for a package loaded without one, or made here.
+         */
+        this.duplicateEntries = [];
         this.loadOptions = {};
+        /**
+         * Whether a save refuses a part holding a child its container never admits (CR-016 D2, docx4j CR-064's rules in the
+         * objects facade, its CR-017): a run straight in the body, a table in a paragraph, a cell beside a table's rows, a
+         * string in a run, a name and value that disagree. On by default: the save throws `MisplacedContentException` with
+         * every such child in the part, its path and docx4j's message naming the fix, and writes nothing, since Word 365
+         * refuses such a file or repairs it by dropping content (check 72). Off, the part is written as held and each is on
+         * `lastSave.misplaced`. Only a part being marshalled is checked (one unmarshalled, or given contents); a part copied
+         * from the source is never refused, so a document read and saved untouched never is. `checkContent()` is the same
+         * check on request. A misplaced child read from a file is a `target.misplaced` warning on its part (D7).
+         */
+        this.checkContentOnSave = true;
+        /**
+         * Whether a save refuses to lose what a read dropped (CR-025 sections 2.3 and 2.4, D8): a part holding `part.skipped` content
+         * that was changed throws `SaveLossException` and nothing is written. Off, the part is written without those items, each on
+         * `lastSave.lost`. A part read and not changed is copied either way, so nothing is lost there. Word's own save drops such
+         * content with no message (check 76), so off is Word's behaviour.
+         */
+        this.checkLossOnSave = true;
+        /**
+         * Show bound dates as Word displays them in the package's zone (CR-018, the date rule's point 3; docx4j's
+         * `setBoundDatesConvertedAsWord`): off by default, a bound date being the day its fields say wherever it is read
+         * (CR-002 section 56). On, a bound value carrying a `Z` or an offset is read as an instant and shown in
+         * `effectiveDateTimeZone()`, as Word reads the `Z` as UTC and shows the machine's local time (a day early west of
+         * UTC); a value with no marker, or a date alone, stays nominal. Setting `dateTimeZone` does not turn this on.
+         */
+        this.boundDatesConvertedAsWord = false;
+        /**
+         * Write the save's time into the core properties (CR-018, the date rule's point 6; docx4j's `docx4j.dcterms.write`):
+         * off by default, a save leaving `dcterms:created` and `dcterms:modified` as they are. On, each save sets
+         * `dcterms:modified` to now, UTC to the second (`2026-10-28T03:04:05Z`, the W3CDTF form Office writes), and
+         * `dcterms:created` too for a package created here that has none; a loaded package with no core properties part is
+         * left without one, as docx4j leaves it.
+         */
+        this.writeTimesOnSave = false;
         this.relationshipsPart = RelationshipsPart.createPackageRels();
         this.relationshipsPart.sourceP = this;
         this.relationshipsPart.package = this;
@@ -73,22 +134,71 @@ export class OpcPackage {
             default: return false;
         }
     }
-    /** The main part: the target of the officeDocument relationship. */
+    /** The main part: the target of the officeDocument relationship, an External one naming none. */
     getMainPart() {
-        var _a;
-        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;
+        const rels = this.relationshipsPart;
+        const rel = [...rels.getRelationshipsByType(Namespaces.DOCUMENT), ...rels.getRelationshipsByType(Namespaces.DOCUMENT_STRICT)].find((r) => !isExternal(r));
+        return rel ? rels.getPart(rel) : undefined;
     }
     /**
-     * The warnings of every part parsed so far (each XML part's `warnings`, CR-010 phase 1). A part
+     * The warnings of every part parsed so far (each XML part's `warnings`, CR-010 phase 1), after the
+     * load's own: a name the container holds twice, and more than one officeDocument relationship, read under
+     * `repair: 'word'` (CR-024), and an `External` main relationship dropped under `repair: 'all'` (CR-031). 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 = [];
+        const out = [...this.duplicateEntries];
+        if (this.multipleMainParts)
+            out.push(this.multipleMainParts);
+        if (this.externalMainPart)
+            out.push(this.externalMainPart);
         for (const part of this.parts)
             if (part instanceof XmlPart)
                 out.push(...part.warnings);
+        // a relationships part's own, what its read dropped: a child of another local name, an attribute the model doesn't map
+        // (CR-025 section 8, D12); after the parts', and outside the save's gate, since none names a part
+        for (const rels of [this.relationshipsPart, ...[...this.parts].map((p) => p.relationshipsPart)])
+            if (rels)
+                out.push(...rels.warnings);
+        return out;
+    }
+    /**
+     * Each relationships part a load under `repair: 'word'` read by local name, being in a wrong namespace (CR-031 section
+     * 2.3): the package's and its parts', in that order.
+     */
+    get relationshipsNamespaces() {
+        var _a;
+        const out = [];
+        for (const rels of [this.relationshipsPart, ...[...this.parts].map((p) => p.relationshipsPart)]) {
+            for (const w of (_a = rels === null || rels === void 0 ? void 0 : rels.warnings) !== null && _a !== void 0 ? _a : [])
+                if (w.code === 'package.relationships_namespace')
+                    out.push(w);
+        }
+        return out;
+    }
+    /**
+     * What the load repaired (WD REQ-207's `repaired`, CR-031 section 2.4), read from what it recorded, so it reports what the
+     * load did whatever the option: `'own'` for a repair of this package's own (an `External` main relationship dropped),
+     * `'word'` where only Word's were followed (a duplicated entry, several main relationships, a relationships part read by
+     * local name), else `'none'`.
+     */
+    get repaired() {
+        if (this.externalMainPart)
+            return 'own';
+        return this.duplicateEntries.length > 0 || this.multipleMainParts || this.relationshipsNamespaces.length > 0 ? 'word' : 'none';
+    }
+    /**
+     * Every child a part holds that its container never admits (CR-016 D6, the check on request): what a save would
+     * refuse for, over every typed XML part, each finding with its part, its path, the rule and docx4j's message naming
+     * the fix. Nothing is changed, and an untouched part stays untouched (read privately). `[]` for a package whose
+     * content is all in its place.
+     */
+    async checkContent() {
+        const out = [];
+        for (const part of this.parts)
+            if (part instanceof XmlPart)
+                out.push(...(await part.checkContent()));
         return out;
     }
     /** Unmarshals every XML part, so that `contents` is available synchronously everywhere. */
@@ -135,6 +245,12 @@ export class OpcPackage {
         if (copy.constructor !== this.constructor) {
             throw new Docx4JException(`Cloning ${this.constructor.name} produced ${copy.constructor.name}`);
         }
+        copy.normaliseOnSave = this.normaliseOnSave;
+        copy.checkContentOnSave = this.checkContentOnSave;
+        copy.checkLossOnSave = this.checkLossOnSave;
+        copy.dateTimeZone = this.dateTimeZone;
+        copy.boundDatesConvertedAsWord = this.boundDatesConvertedAsWord;
+        copy.writeTimesOnSave = this.writeTimesOnSave;
         this.copyPackageSettingsTo(copy);
         return copy;
     }

package/dist/packages/WordprocessingMLPackage.d.mts

@@ -4,6 +4,7 @@ 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 { 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,6 +12,7 @@ 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';
@@ -19,6 +21,9 @@ 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: {
@@ -102,6 +107,12 @@ export declare class WordprocessingMLPackage extends OpcPackage implements Track
      * 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
@@ -212,10 +223,24 @@ 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
@@ -223,15 +248,19 @@ export declare class WordprocessingMLPackage extends OpcPackage implements Track
      * 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(): Promise<number>;
+    acceptAllRevisions(filter?: TrackedChangeSelection): Promise<number>;
     /** Rejects every tracked change in every story, as `acceptAllRevisions` accepts them (Word's `Document.RejectAllRevisions`). */
-    rejectAllRevisions(): Promise<number>;
+    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. A footnote, an endnote or a comment is a body of its own over its content.
+     * 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`. */
@@ -294,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

package/dist/packages/WordprocessingMLPackage.mjs

@@ -4,27 +4,33 @@ import { registerPackageClass } from './registry.mjs';
 import { ContentTypes } from '../opc/ContentTypes.mjs';
 import { Docx4JException } from '../opc/exceptions.mjs';
 import { Namespaces } from '../parts/Namespaces.mjs';
-import { MainDocumentPart, StyleDefinitionsPart, DocumentSettingsPart } from '../parts/wml/index.mjs';
+import { MainDocumentPart, StyleDefinitionsPart, DocumentSettingsPart, GlossaryDocumentPart } from '../parts/wml/index.mjs';
 import { DocPropsCorePart, DocPropsExtendedPart } from '../parts/docProps/index.mjs';
 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 { Body, resolveStory, trackedChangesOfStory } from '../model/content/Body.mjs';
+import { pieceMatcher } from '../model/content/trackedChangeFilter.mjs';
 import { CustomXmlPartCollection } from '../model/customxml/CustomXmlPartCollection.mjs';
 import { DefaultXPathEngine } from '../model/customxml/xpath.mjs';
 import { ChangeTracker, highestAnnotationId } from '../model/content/tracking.mjs';
 import { NumberingFacade } from '../model/content/List.mjs';
 import { StylesFacade } from '../model/content/stylesFacade.mjs';
 import { flushPendingCommentRemovals } from '../model/content/Comment.mjs';
+import { GlossaryEntries } from '../model/content/placeholders.mjs';
 import { PropertyResolver } from '../model/properties/PropertyResolver.mjs';
 import { PropertyResolverNotCreatedException } from '../opc/exceptions.mjs';
-import { flushPendingNoteRemovals } from '../model/content/TrackedChange.mjs';
+import { flushPendingNoteRemovals, notesGoing } 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.
 import '../parts/wml/comments.mjs';
+// Registers the text model's outline reader with Body.outline (CR-012 D3), the same way: the content API
+// can't import the text model, which imports it.
+import '../model/text/outline.mjs';
+import { Texts } from '../model/text/Texts.mjs';
 const MAIN_CONTENT_TYPES = [
     ContentTypes.WORDPROCESSINGML_DOCUMENT,
     ContentTypes.WORDPROCESSINGML_DOCUMENT_MACROENABLED,
@@ -105,6 +111,12 @@ export class WordprocessingMLPackage extends OpcPackage {
          * 47). Settled on save, not at once, so a picture cut and pasted back keeps its image. An extension.
          */
         this.pendingRelationshipRemovals = new Map();
+        /**
+         * 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.
+         */
+        this.glossaryEntries = new 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
@@ -159,7 +171,8 @@ export class WordprocessingMLPackage extends OpcPackage {
         if (landscape)
             pgSz.orient = 'landscape';
         const pgMar = { top: 1440, right: 1440, bottom: 1440, left: 1440, header: 708, footer: 708, gutter: 0 };
-        const document = { body: { content: [], sectPr: { pgSz, pgMar } } };
+        // typed, as a loaded document is, so the objects facade's walks (its onMisplaced, CR-016) see the body as a container
+        const document = { TYPE_NAME: 'org_docx4j_wml.Document', body: { TYPE_NAME: 'org_docx4j_wml.Body', content: [], sectPr: { TYPE_NAME: 'org_docx4j_wml.SectPr', pgSz, pgMar } } };
         const main = new MainDocumentPart();
         main.setContents(document);
         pkg.addTargetPart(main);
@@ -414,12 +427,32 @@ export class WordprocessingMLPackage extends OpcPackage {
     }
     /**
      * 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() {
         return this.body.getTrackedChanges();
     }
+    /**
+     * 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.
+     */
+    async getAllTrackedChanges(filter) {
+        const matches = filter === undefined ? undefined : pieceMatcher(filter);
+        const out = [];
+        for (const body of await this.revisedStories())
+            out.push(...trackedChangesOfStory(body));
+        return matches ? out.filter((change) => change.pieces.some(matches)) : out;
+    }
     /**
      * 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
@@ -427,24 +460,30 @@ export class WordprocessingMLPackage extends OpcPackage {
      * 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.
      */
-    async acceptAllRevisions() {
-        return this.resolveEveryStory('accept');
+    async acceptAllRevisions(filter) {
+        return this.resolveEveryStory('accept', filter);
     }
     /** Rejects every tracked change in every story, as `acceptAllRevisions` accepts them (Word's `Document.RejectAllRevisions`). */
-    async rejectAllRevisions() {
-        return this.resolveEveryStory('reject');
+    async rejectAllRevisions(filter) {
+        return this.resolveEveryStory('reject', filter);
     }
-    async resolveEveryStory(what) {
+    async resolveEveryStory(what, filter) {
+        if (filter !== undefined)
+            pieceMatcher(filter); // a filter misread throws before anything is read or resolved
         let count = 0;
         for (const body of await this.revisedStories())
-            count += resolveStory(body, what);
+            count += resolveStory(body, what, filter);
         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.
+     * headers and footers in section order (`inSectionOrder`). A footnote, an endnote or a comment is a
+     * body of its own over its content.
      */
     async revisedStories() {
         var _a, _b;
@@ -452,22 +491,33 @@ export class WordprocessingMLPackage extends OpcPackage {
         const out = [];
         if (await holdsRevisions(main))
             out.push(await main.getBody());
+        // a note or comment a resolution has taken the reference or anchor of goes on save; it is no story now
+        const pending = this.pendingNoteRemovals;
+        const going = pending.footnote.size + pending.endnote.size > 0 ? notesGoing(await main.readContents(), pending) : pending;
         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 : []) {
+                if ((note.type === undefined || note.type === 'normal') && going[kind].has(Number(note.id)))
+                    continue;
                 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 : [])
+            for (const comment of (_b = (await comments.getContents()).comment) !== null && _b !== void 0 ? _b : []) {
+                if (this.pendingCommentRemovals.has(comment.id))
+                    continue;
                 out.push(new Body(comments, comment, `comment:${comment.id}`, this));
+            }
         }
+        const revised = [];
         for (const part of [...main.headerParts, ...main.footerParts])
             if (await holdsRevisions(part))
-                out.push(await part.getBody());
+                revised.push(part);
+        for (const part of revised.length > 1 ? await inSectionOrder(main, revised) : revised)
+            out.push(await part.getBody());
         return out;
     }
     /** The tracker every content-API mutation asks for; undefined while the mode is `Off`. */
@@ -583,6 +633,7 @@ export class WordprocessingMLPackage extends OpcPackage {
             target.pendingNoteRemovals.endnote.add(id);
         for (const [name, ids] of this.pendingRelationshipRemovals)
             target.pendingRelationshipRemovals.set(name, new Set(ids));
+        this.glossaryEntries.copyTo(target.glossaryEntries);
         target.trackedChangeDate = this.trackedChangeDate;
         target.fonts.defaultTheme = this.fonts.defaultTheme;
         target.xpathEngine = this.xpathEngine;
@@ -603,13 +654,23 @@ export class WordprocessingMLPackage extends OpcPackage {
         }
         if (this.pendingRelationshipRemovals.size > 0)
             flushPendingRelationshipRemovals(this, this.pendingRelationshipRemovals);
+        if (this.glossaryEntries.waiting) {
+            await this.glossaryEntries.flush(this, {
+                glossary: () => new GlossaryDocumentPart(),
+                styles: () => new StyleDefinitionsPart('/word/glossary/styles.xml'),
+            });
+        }
         if (this.requiredStyles.size > 0) {
             await this.styles.ensure([...this.requiredStyles]);
             this.requiredStyles.clear();
         }
         return super.saveTo(sink);
     }
-    /** 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.
+     */
     async paragraphAt(address) {
         for (const body of await this.bodies(address)) {
             const p = body.paragraphAt(address);
@@ -618,28 +679,44 @@ export class WordprocessingMLPackage extends OpcPackage {
         }
         return undefined;
     }
-    /** Every paragraph and table with its address, style and text (CR-002 section 3.3). Unmarshals the main part, headers and footers. */
-    async outline() {
+    /**
+     * 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.
+     */
+    async outline(options, context) {
         var _a, _b, _c, _d;
         const main = await this.getBody();
-        const out = { ...main.outline(), headers: [], footers: [] };
+        const ctx = context !== null && context !== void 0 ? context : await Texts.contextOf(this);
+        const out = { ...await main.outline(options, ctx), headers: [], footers: [] };
         for (const part of this.getMainDocumentPart().headerParts) {
             const body = await part.getBody();
-            out.headers.push({ relId: (_b = (_a = part.sourceRelationship) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : '', partName: part.partName.name, ...body.outline() });
+            out.headers.push({ relId: (_b = (_a = part.sourceRelationship) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : '', partName: part.partName.name, ...await body.outline(options, ctx) });
         }
         for (const part of this.getMainDocumentPart().footerParts) {
             const body = await part.getBody();
-            out.footers.push({ relId: (_d = (_c = part.sourceRelationship) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : '', partName: part.partName.name, ...body.outline() });
+            out.footers.push({ relId: (_d = (_c = part.sourceRelationship) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : '', partName: part.partName.name, ...await body.outline(options, ctx) });
         }
         return out;
     }
     async bodies(address) {
+        var _a;
         const main = this.getMainDocumentPart();
         if (typeof address === 'string' && !address.startsWith('w14:')) {
             const prefix = address.split('/')[0];
             if (prefix === 'body')
                 return [await main.getBody()];
             const [kind, relId] = prefix.split(':');
+            if (kind === 'footnote' || kind === 'endnote' || kind === 'comment') {
+                // a note's or a comment's body, by its w:id, as the text model and Comment address them (CR-012 D4)
+                const part = kind === 'footnote' ? main.footnotesPart : kind === 'endnote' ? main.endnotesPart : main.commentsPart;
+                if (!part)
+                    return [];
+                const contents = await part.getContents();
+                const entry = ((_a = contents[kind]) !== null && _a !== void 0 ? _a : []).find((e) => String(e.id) === relId);
+                await this.getPropertyResolver().catch(() => undefined);
+                return entry ? [new Body(part, entry, `${kind}:${relId}`, this)] : [];
+            }
             const parts = kind === 'header' ? main.headerParts : kind === 'footer' ? main.footerParts : [];
             const part = parts.find((p) => { var _a; return ((_a = p.sourceRelationship) === null || _a === void 0 ? void 0 : _a.id) === relId || p.partName.fileName === relId; });
             return part instanceof HeaderPart || part instanceof FooterPart ? [await part.getBody()] : [];
@@ -709,12 +786,72 @@ export class WordprocessingMLPackage extends OpcPackage {
             },
             customXmlRelationshipSource: () => this.getMainDocumentPart(),
             xhtmlHost: this,
+            getPropertyResolver: () => this.getPropertyResolver(),
         })));
     }
     get progId() {
         return 'Word.Document';
     }
 }
+/**
+ * Headers and footers in docx4j's order (its CR-043 `Lister.headersAndFooters`): as the sections
+ * reference them, in document order, a part once, then any other in the order of the main part's
+ * relationships. The main part's tree is read privately, so a main part nobody has otherwise read keeps
+ * its bytes.
+ */
+async function inSectionOrder(main, parts) {
+    var _a;
+    const rels = main.relationshipsPart;
+    if (!rels)
+        return parts;
+    const order = [];
+    const add = (part) => {
+        const known = parts.find((p) => p === part);
+        if (known && !order.includes(known))
+            order.push(known);
+    };
+    const body = (await main.readContents()).body;
+    for (const sectPr of sectionsOf(body))
+        for (const ref of (_a = sectPr.egHdrFtrReferences) !== null && _a !== void 0 ? _a : [])
+            add(rels.getPart(ref.id));
+    for (const rel of rels.list)
+        add(rels.getPart(rel));
+    for (const part of parts)
+        if (!order.includes(part))
+            order.push(part);
+    return order;
+}
+/**
+ * The body's `w:sectPr`s in document order, the paragraphs' first and the body's own last, as docx4j's
+ * walk finds them: not inside a run (where a text box's paragraphs are), DOM the model does not type
+ * left alone.
+ */
+function sectionsOf(body) {
+    const out = [];
+    const visit = (o) => {
+        if (typeof o !== 'object' || o === null || typeof o.nodeType === 'number')
+            return;
+        if (Array.isArray(o)) {
+            for (const item of o)
+                visit(item);
+            return;
+        }
+        const typeName = o.TYPE_NAME;
+        if (typeName === 'org_docx4j_wml.SectPr') {
+            out.push(o);
+            return;
+        }
+        if (typeName === 'org_docx4j_wml.R')
+            return;
+        for (const key in o)
+            if (key !== 'PARENT')
+                visit(o[key]);
+    };
+    visit(body === null || body === void 0 ? void 0 : body.content);
+    if (body === null || body === void 0 ? void 0 : body.sectPr)
+        out.push(body.sectPr);
+    return out;
+}
 /** 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/>]/;
 /**

package/dist/packages/index.d.mts

@@ -1,4 +1,4 @@
-export { OpcPackage, type PackageSource } from './OpcPackage.mjs';
+export { OpcPackage, type PackageSource, type PackageWarning, type Repaired } from './OpcPackage.mjs';
 export { WordprocessingMLPackage, type PageSizePaper, type CreatePackageOptions } from './WordprocessingMLPackage.mjs';
 export { PresentationMLPackage, createSlideSize, type SlideSizesWellKnown, type CreatePresentationOptions, } from './PresentationMLPackage.mjs';
 export { SpreadsheetMLPackage } from './SpreadsheetMLPackage.mjs';

package/dist/parts/DefaultXmlPart.mjs

@@ -2,7 +2,7 @@ import { Part } from './Part.mjs';
 import { ContentTypes } from '../opc/ContentTypes.mjs';
 import { Namespaces } from './Namespaces.mjs';
 import { Docx4JException } from '../opc/exceptions.mjs';
-import { parseXml, serializeXmlPart, encodeText, decodeXmlText } from '../xml/dom.mjs';
+import { parseXml, serializeXmlPart, encodeText, decodeXmlText, assertXmlCharacters } from '../xml/dom.mjs';
 /**
  * An XML part the object model does not type, held as a DOM (docx4j DefaultXmlPart / XmlPart).
  * The document is parsed on first `getDocument()`; a part whose document was never requested is
@@ -71,7 +71,7 @@ export class DefaultXmlPart extends Part {
     }
     async getBytes() {
         if (this.document !== undefined)
-            return encodeText(serializeXmlPart(this.document));
+            return encodeText(assertXmlCharacters(serializeXmlPart(this.document), `Part ${this.partName}`));
         if (this.bytes !== undefined)
             return this.bytes;
         const loaded = await this.loadSourceBytes();