@docx4j/core-ts 0.6.0 → 0.7.0

package/dist/model/text/PlainText.mjs

@@ -1,3 +1,4 @@
+import { CaseMapping } from './CaseMapping.mjs';
 /** The spaces for each 720-twip tab stop of indent under `layout: indent` (REQ-709). */
 export const INDENT_SPACES = 4;
 /** The note line before a table in the listed format (REQ-605, REQ-707). */
@@ -217,14 +218,16 @@ class Writer {
                 this.out += `${author !== null && author !== void 0 ? author : ''}: `;
                 break;
             case 'author_date':
-                this.out += `${author !== null && author !== void 0 ? author : ''}, ${date !== null && date !== void 0 ? date : ''}: `;
-                break;
+                this.out += `${author !== null && author !== void 0 ? author : ''}${date === undefined ? '' : `, ${date}`}: `;
+                break; // a mark with no date: its author alone (REQ-702)
             default:
         }
     }
     run(run) {
         switch (run.kind) {
-            case 'TEXT':
+            case 'TEXT': // w:caps in capitals, by the run's language (REQ-607)
+                this.out += CaseMapping.written(run, this.options);
+                break;
             case 'FIELD_CODE':
             case 'LIST_LABEL':
                 this.out += run.text;
@@ -263,7 +266,7 @@ class Writer {
     comment(comment) {
         this.out += '{>>';
         this.detail(comment.author, comment.date);
-        this.out += `${comment.text}<<}`;
+        this.out += `${CaseMapping.written(comment, this.options)}<<}`;
     }
     /** A block written on its own, for a table cell's value. */
     text(block) {

package/dist/model/text/TextContext.d.mts

@@ -1,13 +1,15 @@
 import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
 import type * as w15 from '@docx4j/generated-objects-ts/modules/org_docx4j_w15';
+import type * as w16cid from '@docx4j/generated-objects-ts/modules/org_docx4j_w16cid';
+import type * as w16cex from '@docx4j/generated-objects-ts/modules/org_docx4j_w16cex';
 import type * as core from '@docx4j/generated-objects-ts/modules/org_docx4j_docProps_core';
 import type * as extended from '@docx4j/generated-objects-ts/modules/org_docx4j_docProps_extended';
 import type * as custom from '@docx4j/generated-objects-ts/modules/org_docx4j_docProps_custom';
 import type { Part } from '../../parts/Part.mjs';
 import type { XmlPart } from '../../parts/XmlPart.mjs';
-import type { PropertyResolver } from '../properties/PropertyResolver.mjs';
-import type { NumberingDefinitions } from '../listnumbering/definitions.mjs';
-import type { NumberingPartLike } from '../listnumbering/Emulator.mjs';
+import { PropertyResolver } from '../properties/PropertyResolver.mjs';
+import { NumberingDefinitions } from '../listnumbering/definitions.mjs';
+import { Emulator, type NumberingPartLike } from '../listnumbering/Emulator.mjs';
 import { NumberingStates } from '../listnumbering/state.mjs';
 import { Body } from '../content/Body.mjs';
 import { ResolvedView } from '../content/ResolvedView.mjs';
@@ -24,8 +26,33 @@ export interface TextPackage {
     readonly docPropsCustomPart?: XmlPart<custom.Properties>;
     readonly customXmlDataStorageParts: ReadonlyMap<string, {
         parseDocument(): Promise<Document>;
+        readonly partName: {
+            readonly name: string;
+        };
     }>;
     xpathEngine: XPathEngine;
+    /** The names the container held twice, read from the first under `repair: 'word'` (CR-024). */
+    readonly duplicateEntries?: readonly {
+        readonly entry: string;
+        readonly count: number;
+    }[];
+    /** More than one officeDocument relationship, the last's target read under `repair: 'word'` (CR-024 section 9). */
+    readonly multipleMainParts?: {
+        readonly partName: string;
+        readonly count: number;
+    } | undefined;
+    /** An `External` officeDocument relationship beside an internal one, dropped under `repair: 'all'` (CR-031). */
+    readonly externalMainPart?: {
+        readonly partName: string;
+        readonly urls: readonly string[];
+    } | undefined;
+    /** The relationships parts read by local name under `repair: 'word'` (CR-031 section 2.3). */
+    readonly relationshipsNamespaces?: readonly {
+        readonly partName: string;
+        readonly count: number;
+    }[];
+    /** What the load repaired (REQ-207's `repaired`, CR-031). */
+    readonly repaired?: 'none' | 'word' | 'own';
 }
 /** As much of a `MainDocumentPart` as a reading uses. */
 export interface MainLike extends XmlPart<wml.Document> {
@@ -38,10 +65,17 @@ export interface MainLike extends XmlPart<wml.Document> {
     readonly endnotesPart?: XmlPart<wml.CTEndnotes>;
     readonly commentsPart?: XmlPart<wml.Comments>;
     readonly commentsExtendedPart?: XmlPart<w15.CTCommentsEx>;
+    readonly commentsIdsPart?: XmlPart<w16cid.CTCommentsIds>;
+    readonly commentsExtensiblePart?: XmlPart<w16cex.CTCommentsExtensible>;
     readonly glossaryDocumentPart?: XmlPart<wml.GlossaryDocument>;
     readonly headerParts: XmlPart<wml.Hdr>[];
     readonly footerParts: XmlPart<wml.Ftr>[];
 }
+/**
+ * A part a reading may need that it could not read (CR-012 section 28, WD REQ-801): its role, by what it supplies. Each is
+ * raised as `part.not_read`, naming the part, where the reading needs it.
+ */
+export type UnreadPart = 'styles' | 'numbering' | 'settings' | 'core' | 'app' | 'custom';
 /**
  * The trees one reading walks, each read **privately** where its part was not unmarshalled
  * (`XmlPart.readContents`), so that reading a document costs no part its byte-for-byte round trip
@@ -67,37 +101,98 @@ export declare class PackageTrees {
         tree: wml.Comments;
     } | undefined;
     commentsExtended: w15.CTCommentsEx | undefined;
+    /**
+     * Each comment's `w16cex:dateUtc`, by its last paragraph's `w14:paraId` (upper case): the comments ids part gives the
+     * paragraph's durable id, the comments extensible part the durable id's date (REQ-702's offset; docx4j's `commentDatesUtc`).
+     */
+    readonly commentDatesUtc: Map<string, wml.XmlCalendar>;
     /** Each header and footer part related from the main document part, with its content. */
     readonly headersAndFooters: Map<Part, wml.Ftr | wml.Hdr>;
     glossary: {
         part: Part;
         tree: wml.GlossaryDocument;
     } | undefined;
+    /** Each story part that could not be read, with the reason: a reading taking it raises `content.not_read` (REQ-801). */
+    readonly unreadable: Map<Part, unknown>;
     settings: wml.CTSettings | undefined;
     /** The document properties under `core`, `app` and `custom` (REQ-515). */
     properties: Record<string, unknown> | undefined;
-    /** The resolver, where the package has a styles part (docx4j makes none without one). */
+    /** The resolver, where the package has a styles part that can be read (docx4j makes none without one). */
     resolver: PropertyResolver | undefined;
-    numberingPart: NumberingPartLike | undefined;
+    /**
+     * What the numbering resolves a style's `w:numPr` through: the package's resolver, else, where a styles or numbering part
+     * cannot be read, the reading's own without it (CR-012 section 28); undefined where the package has neither part.
+     */
+    private numberingResolver;
     numbering: NumberingDefinitions | undefined;
-    /** Each binding store's DOM, by its upper-cased item id. */
+    /**
+     * The numbering this reading counts by: the numbering part's emulator, one of the reading's own where the styles cannot
+     * be read, or, where the numbering part is absent or cannot be read, one over Word's default definition, made at the
+     * first numbered paragraph (`numberingFor`).
+     */
+    emulator: Emulator | undefined;
+    /** Where the numbering part is absent or cannot be read: the warning the first numbered paragraph raises, and the part named. */
+    numberingMissing: {
+        kind: 'part.absent' | 'part.not_read';
+        partName: string;
+    } | undefined;
+    /** The parts this reading could not read that it may need, by role, each with its part's name (CR-012 section 28). */
+    readonly notRead: Map<UnreadPart, string>;
+    /** The custom XML stores and properties parts a binding could not be read against, by normalised store item id: their part names. */
+    private readonly unreadStores;
+    /** The core and application properties' DOMs, by their normalised store item ids. */
     private readonly stores;
+    /** The custom XML parts' DOMs, in the package's order: what a binding resolves to (CR-020). */
+    private readonly customStores;
+    private readonly storeItems;
     private xpath;
     private anchored;
     private constructor();
     /** The trees of a package. */
     static read(pkg: TextPackage): Promise<PackageTrees>;
+    /**
+     * The resolver and the numbering (CR-012 section 28, WD REQ-801). The package's own where they can be built; where a
+     * styles or numbering part cannot be read, a resolver of the reading's own without it, as for a package that lacks the
+     * part, the part kept in `notRead`. The package's resolver is never set from it, so the content API still refuses the
+     * part (CR-001 section 26), and a part put right is read again by the next reading. Where the styles cannot be read the
+     * numbering's definitions are read directly and counted by an emulator of the reading's own, so that nothing is kept on
+     * the numbering part. A numbering part absent or unread is Word's default definition (`numberingFor`, WD 0.76).
+     */
+    private readStylesAndNumbering;
+    /** `commentDatesUtc`, from the comments ids and extensible parts, read privately; neither read, as D3 (a) leaves them, nothing. */
+    private readCommentDates;
+    /** `readContents()`, undefined for a part that cannot be read, which is then kept in `notRead` under its role. */
+    private readOrNote;
+    /**
+     * The numbering a numbered paragraph is counted by. Where the numbering part is absent or cannot be read, Word's default
+     * definition (WD 0.76, REQ-510), made here once, at the first numbered paragraph, and never written to the package: one
+     * abstract definition of nine decimal levels, each `w:start` 1 and `w:lvlText` `%{level+1}.`, and one instance per
+     * `w:numId` other than 0 the document names, plain where a paragraph style's `w:numPr` names it, else with a
+     * `w:startOverride` of 1 at every level, so that the direct paragraphs restart at their first and then share the style's
+     * count.
+     */
+    numberingFor(): Emulator | undefined;
     /** Trees with no package: content read as it stands (docx4j's planless `Texts.of(content)`). */
     static none(): PackageTrees;
     /** The glossary document, read when `include: glossary` first asks for it. */
     readGlossary(): Promise<void>;
+    /** A story part's content; undefined where it has none, and where it could not be read, then kept in `unreadable`. */
+    private readStory;
     private readStores;
     /**
      * A data binding's value, docx4j `BoundValues`: the binding's XPath, with its own prefix mappings,
-     * against the custom XML part its `w:storeItemID` names (or the core or application properties); the
-     * string value of the first node selected. Undefined where the binding does not resolve.
+     * against the custom XML part its `w:storeItemID` names (or the core or application properties), or,
+     * where it names none, the part its XPath fits, as Word repairs it (CR-020; nothing is written back);
+     * the string value of the first node selected. Undefined where the binding does not resolve.
      */
     boundValue(binding: wml.CTDataBinding): string | undefined;
+    /**
+     * The name of the part a binding names that could not be read: a custom XML store, or the core or application
+     * properties (CR-012 section 28, D3); undefined where it names a part that was read, or none.
+     */
+    unreadStoreOf(binding: wml.CTDataBinding): string | undefined;
+    /** The nodes an XPath selects in a store, with a binding's prefix mappings (the default namespace's left out). */
+    private selectIn;
     /**
      * The ids of the comments anchored in the document: a `w:commentReference` or a `w:commentRangeStart`
      * in the main document, a header or footer, or a note, in any branch.

package/dist/model/text/TextContext.mjs

@@ -1,12 +1,16 @@
+import * as f from '@docx4j/generated-objects-ts/factory/org_docx4j_wml';
+import { PropertyResolver } from '../properties/PropertyResolver.mjs';
+import { NumberingDefinitions } from '../listnumbering/definitions.mjs';
+import { Emulator } from '../listnumbering/Emulator.mjs';
 import { NumberingStates } from '../listnumbering/state.mjs';
 import { Body } from '../content/Body.mjs';
 import { ResolvedView } from '../content/ResolvedView.mjs';
 import { parsePrefixMappings } from '../customxml/xpath.mjs';
+import { CORE_PROPERTIES_STOREITEMID, EXTENDED_PROPERTIES_STOREITEMID, StoreItemResolver, isPropertiesStoreItem, normaliseStoreItemId } from '../customxml/storeItems.mjs';
 import { parseXml, decodeXmlText } from '../../xml/dom.mjs';
 import { walk } from '@docx4j/generated-objects-ts/builders/wml';
-/** The `w:storeItemID`s of the core and application properties, which a control can be bound to (docx4j `BindingHandler`). */
-const CORE_PROPERTIES_STOREITEMID = '{6C3C8BC8-F283-45AE-878A-BAB7291924A1}';
-const EXTENDED_PROPERTIES_STOREITEMID = '{6668398D-A668-4E3E-A5EB-62B293D839F1}';
+/** Where a package keeps its numbering part: what `part.absent` names where it has none (WD 0.76). */
+const NUMBERING_PART_NAME = '/word/numbering.xml';
 /** `readContents()`, undefined for a part that cannot be read. */
 async function readQuietly(part) {
     if (!part)
@@ -27,10 +31,24 @@ async function readQuietly(part) {
 export class PackageTrees {
     constructor(pkg) {
         this.pkg = pkg;
+        /**
+         * Each comment's `w16cex:dateUtc`, by its last paragraph's `w14:paraId` (upper case): the comments ids part gives the
+         * paragraph's durable id, the comments extensible part the durable id's date (REQ-702's offset; docx4j's `commentDatesUtc`).
+         */
+        this.commentDatesUtc = new Map();
         /** Each header and footer part related from the main document part, with its content. */
         this.headersAndFooters = new Map();
-        /** Each binding store's DOM, by its upper-cased item id. */
+        /** Each story part that could not be read, with the reason: a reading taking it raises `content.not_read` (REQ-801). */
+        this.unreadable = new Map();
+        /** The parts this reading could not read that it may need, by role, each with its part's name (CR-012 section 28). */
+        this.notRead = new Map();
+        /** The custom XML stores and properties parts a binding could not be read against, by normalised store item id: their part names. */
+        this.unreadStores = new Map();
+        /** The core and application properties' DOMs, by their normalised store item ids. */
         this.stores = new Map();
+        /** The custom XML parts' DOMs, in the package's order: what a binding resolves to (CR-020). */
+        this.customStores = [];
+        this.storeItems = new StoreItemResolver(() => this.customStores);
     }
     /** The trees of a package. */
     static async read(pkg) {
@@ -44,46 +62,174 @@ export class PackageTrees {
         }
         if (main) {
             trees.main = { part: main, document: await main.readContents() };
-            if (main.styleDefinitionsPart) {
-                try {
-                    trees.resolver = await pkg.getPropertyResolver();
-                }
-                catch {
-                    trees.resolver = undefined; // hidden text and indents not resolved through styles
-                }
-            }
-            const numbering = main.numberingDefinitionsPart;
-            if (numbering) {
-                try {
-                    await pkg.getNumberingEmulator();
-                    trees.numbering = await numbering.getDefinitions();
-                    trees.numberingPart = numbering;
-                }
-                catch {
-                    trees.numberingPart = undefined;
-                }
-            }
-            trees.settings = await readQuietly(main.documentSettingsPart);
-            const footnotes = await readQuietly(main.footnotesPart);
+            await trees.readStylesAndNumbering(pkg, main);
+            trees.settings = await trees.readOrNote(main.documentSettingsPart, 'settings');
+            const footnotes = await trees.readStory(main.footnotesPart);
             if (footnotes && main.footnotesPart)
                 trees.footnotes = { part: main.footnotesPart, tree: footnotes };
-            const endnotes = await readQuietly(main.endnotesPart);
+            const endnotes = await trees.readStory(main.endnotesPart);
             if (endnotes && main.endnotesPart)
                 trees.endnotes = { part: main.endnotesPart, tree: endnotes };
-            const comments = await readQuietly(main.commentsPart);
+            const comments = await trees.readStory(main.commentsPart);
             if (comments && main.commentsPart)
                 trees.comments = { part: main.commentsPart, tree: comments };
-            trees.commentsExtended = await readQuietly(main.commentsExtendedPart);
+            trees.commentsExtended = await readQuietly(main.commentsExtendedPart); // passed over silently: CR-012 section 28's D3 (a), not ruled
+            await trees.readCommentDates(main);
             for (const part of [...main.headerParts, ...main.footerParts]) {
-                const content = await readQuietly(part);
+                const content = await trees.readStory(part);
                 if (content)
                     trees.headersAndFooters.set(part, content);
             }
         }
-        trees.properties = await properties(pkg);
+        trees.properties = await properties(pkg, (part, role) => trees.readOrNote(part, role));
         await trees.readStores(pkg);
         return trees;
     }
+    /**
+     * The resolver and the numbering (CR-012 section 28, WD REQ-801). The package's own where they can be built; where a
+     * styles or numbering part cannot be read, a resolver of the reading's own without it, as for a package that lacks the
+     * part, the part kept in `notRead`. The package's resolver is never set from it, so the content API still refuses the
+     * part (CR-001 section 26), and a part put right is read again by the next reading. Where the styles cannot be read the
+     * numbering's definitions are read directly and counted by an emulator of the reading's own, so that nothing is kept on
+     * the numbering part. A numbering part absent or unread is Word's default definition (`numberingFor`, WD 0.76).
+     */
+    async readStylesAndNumbering(pkg, main) {
+        const stylesPart = main.styleDefinitionsPart;
+        const numberingPart = main.numberingDefinitionsPart;
+        if (stylesPart || numberingPart) {
+            let packages = true;
+            try {
+                this.numberingResolver = await pkg.getPropertyResolver();
+            }
+            catch {
+                packages = false;
+                try {
+                    this.numberingResolver = await PropertyResolver.create(pkg, {
+                        onUnreadable: (role) => {
+                            const part = role === 'styles' ? stylesPart : numberingPart;
+                            if (part)
+                                this.notRead.set(role, part.partName.name);
+                        },
+                    });
+                }
+                catch {
+                    this.numberingResolver = undefined; // hidden text and indents not resolved through styles
+                }
+            }
+            if (stylesPart && !this.notRead.has('styles'))
+                this.resolver = this.numberingResolver;
+            if (numberingPart && !this.notRead.has('numbering')) {
+                try {
+                    if (packages) {
+                        await pkg.getNumberingEmulator();
+                        this.numbering = await numberingPart.getDefinitions();
+                        this.emulator = numberingPart.getEmulator();
+                    }
+                    else {
+                        const resolver = this.numberingResolver;
+                        this.numbering = new NumberingDefinitions(await numberingPart.readContents(), (id) => resolver === null || resolver === void 0 ? void 0 : resolver.getStyle(id));
+                        this.emulator = new Emulator(this.numbering, resolver);
+                    }
+                }
+                catch {
+                    this.numbering = undefined;
+                    this.emulator = undefined;
+                    this.notRead.set('numbering', numberingPart.partName.name);
+                }
+            }
+        }
+        if (this.emulator === undefined) {
+            this.numberingMissing = numberingPart
+                ? { kind: 'part.not_read', partName: numberingPart.partName.name }
+                : { kind: 'part.absent', partName: NUMBERING_PART_NAME };
+        }
+    }
+    /** `commentDatesUtc`, from the comments ids and extensible parts, read privately; neither read, as D3 (a) leaves them, nothing. */
+    async readCommentDates(main) {
+        var _a, _b;
+        const ids = await readQuietly(main.commentsIdsPart);
+        const extensible = await readQuietly(main.commentsExtensiblePart);
+        if (!ids || !extensible)
+            return;
+        const byDurableId = new Map();
+        for (const ce of (_a = extensible.commentExtensible) !== null && _a !== void 0 ? _a : []) {
+            if (ce.durableId && ce.dateUtc)
+                byDurableId.set(ce.durableId.toUpperCase(), ce.dateUtc);
+        }
+        for (const ci of (_b = ids.commentId) !== null && _b !== void 0 ? _b : []) {
+            if (!ci.paraId || !ci.durableId)
+                continue;
+            const utc = byDurableId.get(ci.durableId.toUpperCase());
+            if (utc)
+                this.commentDatesUtc.set(ci.paraId.toUpperCase(), utc);
+        }
+    }
+    /** `readContents()`, undefined for a part that cannot be read, which is then kept in `notRead` under its role. */
+    async readOrNote(part, role) {
+        if (!part)
+            return undefined;
+        try {
+            return await part.readContents();
+        }
+        catch {
+            this.notRead.set(role, part.partName.name);
+            return undefined;
+        }
+    }
+    /**
+     * The numbering a numbered paragraph is counted by. Where the numbering part is absent or cannot be read, Word's default
+     * definition (WD 0.76, REQ-510), made here once, at the first numbered paragraph, and never written to the package: one
+     * abstract definition of nine decimal levels, each `w:start` 1 and `w:lvlText` `%{level+1}.`, and one instance per
+     * `w:numId` other than 0 the document names, plain where a paragraph style's `w:numPr` names it, else with a
+     * `w:startOverride` of 1 at every level, so that the direct paragraphs restart at their first and then share the style's
+     * count.
+     */
+    numberingFor() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        if (this.emulator !== undefined || this.numberingMissing === undefined)
+            return this.emulator;
+        const resolver = this.numberingResolver;
+        const plain = new Set();
+        for (const style of (_a = resolver === null || resolver === void 0 ? void 0 : resolver.getStylesInOrder()) !== null && _a !== void 0 ? _a : []) {
+            const numId = Number(style.type === 'paragraph' ? (_d = (_c = (_b = style.pPr) === null || _b === void 0 ? void 0 : _b.numPr) === null || _c === void 0 ? void 0 : _c.numId) === null || _d === void 0 ? void 0 : _d.val : undefined);
+            if (Number.isInteger(numId) && numId !== 0)
+                plain.add(numId);
+        }
+        const direct = new Set();
+        const roots = [(_e = this.main) === null || _e === void 0 ? void 0 : _e.document, ...this.headersAndFooters.values(), (_f = this.footnotes) === null || _f === void 0 ? void 0 : _f.tree, (_g = this.endnotes) === null || _g === void 0 ? void 0 : _g.tree, (_h = this.comments) === null || _h === void 0 ? void 0 : _h.tree, (_j = this.glossary) === null || _j === void 0 ? void 0 : _j.tree];
+        for (const root of roots) {
+            if (root === undefined)
+                continue;
+            walk(root, (v) => {
+                var _a;
+                if (v.TYPE_NAME !== 'org_docx4j_wml.PPrBase.NumPr')
+                    return;
+                const numId = Number((_a = v.numId) === null || _a === void 0 ? void 0 : _a.val);
+                if (Number.isInteger(numId) && numId !== 0 && !plain.has(numId))
+                    direct.add(numId);
+            });
+        }
+        const levels = [0, 1, 2, 3, 4, 5, 6, 7, 8];
+        const num = (numId, restart) => f.createNumberingNum({
+            numId,
+            abstractNumId: f.createNumberingNumAbstractNumId({ val: 0 }),
+            lvlOverride: restart
+                ? levels.map((ilvl) => f.createNumberingNumLvlOverride({ ilvl, startOverride: f.createNumberingNumLvlOverrideStartOverride({ val: 1 }) }))
+                : [],
+        });
+        const tree = f.createNumbering({
+            abstractNum: [f.createNumberingAbstractNum({
+                    abstractNumId: 0,
+                    lvl: levels.map((ilvl) => f.createLvl({
+                        ilvl, start: f.createLvlStart({ val: 1 }), numFmt: f.createNumFmt({ val: 'decimal' }), lvlText: f.createLvlLvlText({ val: `%${ilvl + 1}.` }),
+                    })),
+                })],
+            num: [...[...plain].map((n) => num(n, false)), ...[...direct].map((n) => num(n, true))],
+        });
+        this.numbering = new NumberingDefinitions(tree, (id) => resolver === null || resolver === void 0 ? void 0 : resolver.getStyle(id));
+        this.emulator = new Emulator(this.numbering, resolver);
+        return this.emulator;
+    }
     /** Trees with no package: content read as it stands (docx4j's planless `Texts.of(content)`). */
     static none() {
         return new PackageTrees(undefined);
@@ -94,22 +240,38 @@ export class PackageTrees {
         const part = (_a = this.main) === null || _a === void 0 ? void 0 : _a.part.glossaryDocumentPart;
         if (this.glossary || !part)
             return;
-        const tree = await readQuietly(part);
+        const tree = await this.readStory(part);
         if (tree)
             this.glossary = { part, tree };
     }
+    /** A story part's content; undefined where it has none, and where it could not be read, then kept in `unreadable`. */
+    async readStory(part) {
+        if (!part)
+            return undefined;
+        try {
+            return await part.readContents();
+        }
+        catch (e) {
+            this.unreadable.set(part, e);
+            return undefined;
+        }
+    }
     // --- bound values (REQ-509) ---------------------------------------------------------------------
     async readStores(pkg) {
         let context;
         for (const [id, part] of pkg.customXmlDataStorageParts) {
+            let doc;
             try {
-                const doc = await part.parseDocument();
-                this.stores.set(id.toUpperCase(), doc);
+                doc = await part.parseDocument();
                 context !== null && context !== void 0 ? context : (context = doc);
             }
             catch {
-                this.stores.set(id.toUpperCase(), undefined);
+                // read as absent (CR-012 section 28, D3; WD 0.69): no candidate for a binding, which REQ-509's repair resolves to the
+                // store its XPath fits, else its surface; its id kept, for the part.not_read a binding naming it raises
+                this.unreadStores.set(normaliseStoreItemId(id), part.partName.name);
+                continue;
             }
+            this.customStores.push({ part: doc, id, partName: part.partName.name, root: doc.documentElement, selects: (xpath, mappings) => this.selectIn(doc, xpath, mappings).length > 0 });
         }
         for (const [id, part] of [[CORE_PROPERTIES_STOREITEMID, pkg.docPropsCorePart], [EXTENDED_PROPERTIES_STOREITEMID, pkg.docPropsExtendedPart]]) {
             if (!part)
@@ -117,11 +279,12 @@ export class PackageTrees {
             try {
                 // the part's XML as it would be saved, parsed apart from it: the part keeps its round trip
                 const doc = parseXml(decodeXmlText(await part.getBytes()));
-                this.stores.set(id, doc);
+                this.stores.set(normaliseStoreItemId(id), doc);
                 context !== null && context !== void 0 ? context : (context = doc);
             }
             catch {
-                this.stores.set(id, undefined);
+                this.stores.set(normaliseStoreItemId(id), undefined);
+                this.unreadStores.set(normaliseStoreItemId(id), part.partName.name);
             }
         }
         if (context === undefined)
@@ -136,29 +299,42 @@ export class PackageTrees {
     }
     /**
      * A data binding's value, docx4j `BoundValues`: the binding's XPath, with its own prefix mappings,
-     * against the custom XML part its `w:storeItemID` names (or the core or application properties); the
-     * string value of the first node selected. Undefined where the binding does not resolve.
+     * against the custom XML part its `w:storeItemID` names (or the core or application properties), or,
+     * where it names none, the part its XPath fits, as Word repairs it (CR-020; nothing is written back);
+     * the string value of the first node selected. Undefined where the binding does not resolve.
      */
     boundValue(binding) {
-        var _a;
+        var _a, _b;
         if (!binding.xpath || !binding.storeItemID || !this.xpath)
             return undefined;
-        const doc = this.stores.get(binding.storeItemID.toUpperCase());
-        if (!doc)
-            return undefined;
+        const doc = isPropertiesStoreItem(binding.storeItemID)
+            ? this.stores.get(normaliseStoreItemId(binding.storeItemID))
+            : (_a = this.storeItems.resolve(binding.storeItemID, binding.xpath, binding.prefixMappings)) === null || _a === void 0 ? void 0 : _a.part;
         try {
-            const mappings = parsePrefixMappings(binding.prefixMappings);
-            delete mappings[''];
-            const nodes = this.xpath.select(binding.xpath, doc, mappings);
-            const node = nodes[0];
+            const node = this.selectIn(doc, binding.xpath, binding.prefixMappings)[0];
             if (!node)
                 return undefined;
-            return node.nodeType === 2 ? node.value : ((_a = node.textContent) !== null && _a !== void 0 ? _a : '');
+            return node.nodeType === 2 ? node.value : ((_b = node.textContent) !== null && _b !== void 0 ? _b : '');
         }
         catch {
             return undefined;
         }
     }
+    /**
+     * The name of the part a binding names that could not be read: a custom XML store, or the core or application
+     * properties (CR-012 section 28, D3); undefined where it names a part that was read, or none.
+     */
+    unreadStoreOf(binding) {
+        return binding.storeItemID ? this.unreadStores.get(normaliseStoreItemId(binding.storeItemID)) : undefined;
+    }
+    /** The nodes an XPath selects in a store, with a binding's prefix mappings (the default namespace's left out). */
+    selectIn(doc, xpath, prefixMappings) {
+        if (!doc || !this.xpath)
+            return [];
+        const mappings = parsePrefixMappings(prefixMappings);
+        delete mappings[''];
+        return this.xpath.select(xpath, doc, mappings);
+    }
     // --- the comments anchored in the document (REQ-504) -----------------------------------------------
     /**
      * The ids of the comments anchored in the document: a `w:commentReference` or a `w:commentRangeStart`
@@ -311,17 +487,16 @@ export class TextContext {
         this.endnoteCount = Math.max(this.endnoteCount, other.endnoteCount);
     }
 }
-// --- the document properties (REQ-515; docx4j `Metadata`) --------------------------------------------
-/** The properties under `core`, `app` and `custom`, each where the package has that part. */
-async function properties(pkg) {
+/** The properties under `core`, `app` and `custom`, each where the package has that part and it can be read. */
+async function properties(pkg, read) {
     const out = {};
-    const c = await readQuietly(pkg.docPropsCorePart);
+    const c = await read(pkg.docPropsCorePart, 'core');
     if (c)
         out.core = coreProperties(c);
-    const a = await readQuietly(pkg.docPropsExtendedPart);
+    const a = await read(pkg.docPropsExtendedPart, 'app');
     if (a)
         out.app = appProperties(a);
-    const x = await readQuietly(pkg.docPropsCustomPart);
+    const x = await read(pkg.docPropsCustomPart, 'custom');
     if (x)
         out.custom = customProperties(x);
     return out;