@docx4j/core-ts 0.6.0 → 0.7.0

package/dist/opc/exceptions.d.mts

@@ -1,3 +1,4 @@
+import type { MisplacedContentWarning } from './mce/preprocessor.mjs';
 /** docx4j Docx4JException: anything the packaging layer cannot recover from. */
 export declare class Docx4JException extends Error {
     readonly cause: unknown;
@@ -11,6 +12,113 @@ export declare class InvalidFormatException extends Docx4JException {
         cause?: unknown;
     });
 }
+/**
+ * A relationships part in another namespace, or in none, on its root or on any `Relationship` (CR-025 section 8, D10): refused when
+ * it is read, which is at the load, since the walk reads every relationships part it meets. Word reads such a part only through a
+ * repair, which reads every `Relationship` by its local name (the `rels-namespace` round), where the runtime here drops each one
+ * in a wrong namespace and with it the part it names, so a save would lose those parts with nothing said. `namespace` is the
+ * namespace found, `null` for none. The code is docx4j's and the WD's. `LoadOptions.repair: 'word'` reads such a part as Word's
+ * repair does, every `Relationship` by its local name (CR-031 section 2.3).
+ */
+export declare class RelationshipsNamespaceException extends InvalidFormatException {
+    readonly partName: string;
+    readonly namespace: string | null;
+    /** The finding's code, the WD's, shared with docx4j and docx4j-python. */
+    readonly code = "package.relationships_namespace";
+    constructor(partName: string, namespace: string | null);
+}
+/**
+ * A package whose container holds two entries of one name, OPC part names compared without case (WD REQ-206; CR-024),
+ * refused when it is loaded, before anything is read. Word reads such a file only after a repair, and the readers that
+ * don't refuse read different copies. `entries` gives each duplicated name, as its first entry spells it, with the
+ * number of entries; `LoadOptions.repair: 'word'` reads the first copy of each instead (CR-031).
+ */
+export declare class DuplicateEntryException extends InvalidFormatException {
+    readonly entries: Readonly<Record<string, number>>;
+    /** The finding's code, shared with docx4j-python (its CR-032). */
+    readonly code = "package.duplicate_entry";
+    constructor(entries: Readonly<Record<string, number>>);
+}
+/**
+ * Under `LoadOptions.repair: 'word'` or `'all'`, a name the container holds more than one entry of (WD REQ-206; CR-024):
+ * the first entry in the container's order is read, the rest ignored, and a save writes only the copy read, as Word's
+ * repaired save does. On `pkg.warnings`, ahead of the parts' warnings. The code and the fields are docx4j-python's (its
+ * CR-032): `entry`, the name as the first entry spells it (no leading '/'), and `count`, the entries of that name.
+ */
+export interface DuplicateEntryWarning {
+    code: 'package.duplicate_entry';
+    entry: string;
+    count: number;
+    message: string;
+}
+/**
+ * A package whose package relationships hold more than one officeDocument relationship (WD REQ-206's statement, WD 0.100;
+ * CR-024 section 9), refused when it is loaded, as a duplicated entry is and for the same reason: Word reads such a file
+ * only through a repair, and which target it reads then alternates with each repaired open in a Word session. A
+ * transitional and a strict relationship are two, and so are two naming one target. An External one names no part and
+ * isn't counted. `targets` gives each as a part name (`/word/document.xml`), in the relationships' order.
+ * `LoadOptions.repair: 'word'` reads the last relationship's target instead, as a fresh Word does (CR-031).
+ */
+export declare class MultipleMainPartsException extends InvalidFormatException {
+    readonly targets: readonly string[];
+    /** The finding's code, the WD's, shared with docx4j and docx4j-python. */
+    readonly code = "package.multiple_main_parts";
+    constructor(targets: readonly string[]);
+}
+/**
+ * Under `LoadOptions.repair: 'word'` or `'all'`, a package with more than one officeDocument relationship (WD REQ-206's
+ * statement; CR-024 section 9): the last relationship's target is read, as a fresh Word reads it, the other relationships
+ * go at the load, and a save writes the one main part. On `pkg.warnings`, after any `DuplicateEntryWarning` and ahead of
+ * the parts' warnings. The fields are docx4j-python's: `partName`, the part read (`/word/document.xml`), and `count`, the
+ * relationships there were.
+ */
+export interface MultipleMainPartsWarning {
+    code: 'package.multiple_main_parts';
+    partName: string;
+    count: number;
+    message: string;
+}
+/**
+ * An `External` officeDocument relationship beside an internal one (WD REQ-206's NOTE, WD 0.102; CR-031 D3), refused at the load
+ * under `LoadOptions.repair` `'refuse'`, the default, and `'word'`, first or last alike: Word offers a repair and then fails
+ * (the `x-ext-*` rounds), so there is no reading of Word's to follow. `urls` gives each `External` relationship's target as
+ * written and `targets` each internal one's as a part name, in the relationships' order (docx4j-python's fields). The URL is
+ * never fetched. `repair: 'all'` reads the internal target instead, a repair of this package's own.
+ */
+export declare class ExternalMainPartException extends InvalidFormatException {
+    readonly urls: readonly string[];
+    readonly targets: readonly string[];
+    /** The finding's code, the WD's, shared with docx4j and docx4j-python. */
+    readonly code = "package.external_main_part";
+    constructor(urls: readonly string[], targets: readonly string[]);
+}
+/**
+ * Under `LoadOptions.repair: 'all'`, an `External` officeDocument relationship beside an internal one (WD REQ-206's NOTE;
+ * CR-031 section 2.2): the internal target is read, every `External` officeDocument relationship goes at the load, so a save
+ * writes none, and the URL is never fetched. A repair of this package's own, so a reading's `repaired` is `own`. On
+ * `pkg.externalMainPart` and on `pkg.warnings`, after the other load warnings. `partName` is the part read, `urls` each URL
+ * as written, in the relationships' order (the text model's `detail` the first).
+ */
+export interface ExternalMainPartWarning {
+    code: 'package.external_main_part';
+    partName: string;
+    urls: readonly string[];
+    message: string;
+}
+/**
+ * Under `LoadOptions.repair: 'word'` or `'all'`, a relationships part in another namespace, or in none, on its root or on any
+ * `Relationship` (CR-031 section 2.3; CR-025 section 8 refuses it otherwise): every `Relationship` is read by its local name,
+ * as Word's repair reads it, and a save writes the right namespace, so nothing is lost. On the relationships part's `warnings`
+ * and so on `pkg.warnings`. `partName` is the relationships part, `namespace` the first wrong one found (`null` for none),
+ * `count` the relationships read (the WD's `detail`, docx4j's).
+ */
+export interface RelationshipsNamespaceWarning {
+    code: 'package.relationships_namespace';
+    partName: string;
+    namespace: string | null;
+    count: number;
+    message: string;
+}
 /**
  * docx4j CyclicStylesException: a style's `w:basedOn` chain comes back to a style it already
  * holds, or goes deeper than docx4j's limit of 32. Thrown only when
@@ -70,3 +178,35 @@ export declare class PartUnmarshalException extends Docx4JException {
     readonly line: number | undefined;
     readonly column: number | undefined;
 }
+/**
+ * A save refused for a child its container never admits (CR-016 D2): the part being marshalled holds a run straight in
+ * the body, a table in a paragraph, a string in a run, ..., which Word 365 refuses the file for or repairs by dropping
+ * content (check 72). Nothing was written. `findings` are the part's, each with its path and docx4j's message naming
+ * the fix; `pkg.checkContentOnSave = false` writes the file as held and reports them on `pkg.lastSave.misplaced` instead.
+ */
+export declare class MisplacedContentException extends Docx4JException {
+    /** The part refused: `/word/document.xml`. */
+    readonly partName: string;
+    readonly findings: readonly MisplacedContentWarning[];
+    constructor(
+    /** The part refused: `/word/document.xml`. */
+    partName: string, findings: readonly MisplacedContentWarning[], options?: {
+        cause?: unknown;
+    });
+}
+/** One part a save would lose content from (CR-025 section 2.3). */
+export interface ContentLoss {
+    partName: string;
+    kind: 'skipped';
+    /** The items its read dropped that Word's own save doesn't drop too: `part.skipped` with `onSave: 'lost'`, one each (CR-025 section 10). */
+    count: number;
+}
+/**
+ * A save refused because a part holding what its read dropped was changed, so a marshal would lose that (CR-025 section 2.3, the
+ * repair policy's P7). Nothing is written. The code and the wording are docx4j-python's, with this package's way past it.
+ */
+export declare class SaveLossException extends Docx4JException {
+    readonly losses: readonly ContentLoss[];
+    readonly code = "save.content_lost";
+    constructor(losses: readonly ContentLoss[]);
+}

package/dist/opc/exceptions.mjs

@@ -13,6 +13,83 @@ export class InvalidFormatException extends Docx4JException {
         this.name = 'InvalidFormatException';
     }
 }
+/**
+ * A relationships part in another namespace, or in none, on its root or on any `Relationship` (CR-025 section 8, D10): refused when
+ * it is read, which is at the load, since the walk reads every relationships part it meets. Word reads such a part only through a
+ * repair, which reads every `Relationship` by its local name (the `rels-namespace` round), where the runtime here drops each one
+ * in a wrong namespace and with it the part it names, so a save would lose those parts with nothing said. `namespace` is the
+ * namespace found, `null` for none. The code is docx4j's and the WD's. `LoadOptions.repair: 'word'` reads such a part as Word's
+ * repair does, every `Relationship` by its local name (CR-031 section 2.3).
+ */
+export class RelationshipsNamespaceException extends InvalidFormatException {
+    constructor(partName, namespace) {
+        super(`${partName}: a relationships part in ${namespace === null ? 'no namespace' : `another namespace, ${namespace}`}, which Word reads `
+            + "only through a repair; refused, since its relationships would be lost with the parts they name. Load with { repair: 'word' } "
+            + 'to read every Relationship by its local name, as Word does (REQ-207)');
+        this.partName = partName;
+        this.namespace = namespace;
+        /** The finding's code, the WD's, shared with docx4j and docx4j-python. */
+        this.code = 'package.relationships_namespace';
+        this.name = 'RelationshipsNamespaceException';
+    }
+}
+/**
+ * A package whose container holds two entries of one name, OPC part names compared without case (WD REQ-206; CR-024),
+ * refused when it is loaded, before anything is read. Word reads such a file only after a repair, and the readers that
+ * don't refuse read different copies. `entries` gives each duplicated name, as its first entry spells it, with the
+ * number of entries; `LoadOptions.repair: 'word'` reads the first copy of each instead (CR-031).
+ */
+export class DuplicateEntryException extends InvalidFormatException {
+    constructor(entries) {
+        const list = Object.entries(entries);
+        super(list.length === 1
+            ? `Duplicate entry ${list[0][0]} in this package: ${list[0][1]} entries (REQ-206). Load with { repair: 'word' } to read the first, as Word does (REQ-207)`
+            : `Duplicate entries in this package: ${list.map(([name, n]) => `${name}, ${n} entries`).join('; ')} (REQ-206). `
+                + "Load with { repair: 'word' } to read the first of each, as Word does (REQ-207)");
+        this.entries = entries;
+        /** The finding's code, shared with docx4j-python (its CR-032). */
+        this.code = 'package.duplicate_entry';
+        this.name = 'DuplicateEntryException';
+    }
+}
+/**
+ * A package whose package relationships hold more than one officeDocument relationship (WD REQ-206's statement, WD 0.100;
+ * CR-024 section 9), refused when it is loaded, as a duplicated entry is and for the same reason: Word reads such a file
+ * only through a repair, and which target it reads then alternates with each repaired open in a Word session. A
+ * transitional and a strict relationship are two, and so are two naming one target. An External one names no part and
+ * isn't counted. `targets` gives each as a part name (`/word/document.xml`), in the relationships' order.
+ * `LoadOptions.repair: 'word'` reads the last relationship's target instead, as a fresh Word does (CR-031).
+ */
+export class MultipleMainPartsException extends InvalidFormatException {
+    constructor(targets) {
+        super(`${targets.length} officeDocument relationships in this package: ${targets.join(', ')} (REQ-206). `
+            + "Load with { repair: 'word' } to read the last, as a fresh Word does (REQ-207)");
+        this.targets = targets;
+        /** The finding's code, the WD's, shared with docx4j and docx4j-python. */
+        this.code = 'package.multiple_main_parts';
+        this.name = 'MultipleMainPartsException';
+    }
+}
+/**
+ * An `External` officeDocument relationship beside an internal one (WD REQ-206's NOTE, WD 0.102; CR-031 D3), refused at the load
+ * under `LoadOptions.repair` `'refuse'`, the default, and `'word'`, first or last alike: Word offers a repair and then fails
+ * (the `x-ext-*` rounds), so there is no reading of Word's to follow. `urls` gives each `External` relationship's target as
+ * written and `targets` each internal one's as a part name, in the relationships' order (docx4j-python's fields). The URL is
+ * never fetched. `repair: 'all'` reads the internal target instead, a repair of this package's own.
+ */
+export class ExternalMainPartException extends InvalidFormatException {
+    constructor(urls, targets) {
+        super(`${urls.length === 1 ? 'An External officeDocument relationship' : `${urls.length} External officeDocument relationships`} in this package, `
+            + `to ${urls.join(', ')}, beside ${targets.length === 1 ? 'an internal one' : `${targets.length} internal ones`}, to ${targets.join(', ')} `
+            + "(REQ-206). Word refuses such a package, even through its repair. Load with { repair: 'all' } to read "
+            + `${targets[targets.length - 1]} and drop the External relationship, a repair of this package's own (REQ-207)`);
+        this.urls = urls;
+        this.targets = targets;
+        /** The finding's code, the WD's, shared with docx4j and docx4j-python. */
+        this.code = 'package.external_main_part';
+        this.name = 'ExternalMainPartException';
+    }
+}
 /**
  * docx4j CyclicStylesException: a style's `w:basedOn` chain comes back to a style it already
  * holds, or goes deeper than docx4j's limit of 32. Thrown only when
@@ -78,3 +155,34 @@ export class PartUnmarshalException extends Docx4JException {
         this.column = options === null || options === void 0 ? void 0 : options.column;
     }
 }
+/**
+ * A save refused for a child its container never admits (CR-016 D2): the part being marshalled holds a run straight in
+ * the body, a table in a paragraph, a string in a run, ..., which Word 365 refuses the file for or repairs by dropping
+ * content (check 72). Nothing was written. `findings` are the part's, each with its path and docx4j's message naming
+ * the fix; `pkg.checkContentOnSave = false` writes the file as held and reports them on `pkg.lastSave.misplaced` instead.
+ */
+export class MisplacedContentException extends Docx4JException {
+    constructor(
+    /** The part refused: `/word/document.xml`. */
+    partName, findings, options) {
+        super(`Save refused: ${partName} holds ${findings.length === 1 ? 'a child its container never admits' : `${findings.length} children their containers never admit`}, `
+            + 'which Word 365 refuses the file for or repairs by dropping content (set pkg.checkContentOnSave = false to write it as held):\n'
+            + findings.map((f) => `  ${f.message}`).join('\n'), options);
+        this.partName = partName;
+        this.findings = findings;
+        this.name = 'MisplacedContentException';
+    }
+}
+/**
+ * A save refused because a part holding what its read dropped was changed, so a marshal would lose that (CR-025 section 2.3, the
+ * repair policy's P7). Nothing is written. The code and the wording are docx4j-python's, with this package's way past it.
+ */
+export class SaveLossException extends Docx4JException {
+    constructor(losses) {
+        super(`Saving would lose content Word's own save keeps or isn't measured on: ${losses.map((l) => `${l.partName} holds ${l.count} item${l.count === 1 ? '' : 's'} the load skipped (part.skipped, onSave lost)`).join(', ')}. `
+            + `Set pkg.checkLossOnSave = false to write ${losses.length === 1 ? 'the part without it' : 'the parts without them'}.`);
+        this.losses = losses;
+        this.code = 'save.content_lost';
+        this.name = 'SaveLossException';
+    }
+}

package/dist/opc/index.d.mts

@@ -4,9 +4,12 @@ export { ContentTypeManager, CONTENT_TYPES_NS } from './ContentTypeManager.mjs';
 export { type PartStore, type PartSink, type PutOptions, MemoryPartStore, MemoryPartSink } from './PartStore.mjs';
 export { ZipPartStore, ZipPartSink } from './ZipPartStore.mjs';
 export { FlatOpcPartStore, FlatOpcPartSink, type FlatOpcSinkOptions, PKG_NS } from './FlatOpcPartStore.mjs';
-export { loadPackage, type LoadOptions } from './Load.mjs';
+export { loadPackage, type LoadOptions, type RepairMode, REPAIR_MODES } from './Load.mjs';
 export { savePackage, type ValueNormalised, type SaveReport } from './Save.mjs';
-export { mceKeep, mcePreprocess, createMcePreprocessor, resolveAlternateContent, preprocessAlternateContent, MCE_NS, KEPT_HOSTS, type McePreprocessOptions, type McBranchesDifferWarning, type ValueKeptWarning, type PartWarning, type MceResult } from './mce/preprocessor.mjs';
-export { UNDERSTOOD_NAMESPACES, UNDERSTOOD_PREFIXES, READ_ONLY_UNDERSTOOD_NAMESPACES, READ_UNDERSTOOD_NAMESPACES, READ_UNDERSTOOD_PREFIXES } from './mce/understood.mjs';
-export { Docx4JException, InvalidFormatException, PartUnrecognisedException, PartUnmarshalException, CyclicStylesException, PropertyResolverNotCreatedException } from './exceptions.mjs';
+export { mceKeep, mcePreprocess, createMcePreprocessor, resolveAlternateContent, preprocessAlternateContent, MCE_NS, KEPT_HOSTS, type McePreprocessOptions, type McBranchesDifferWarning, type McNothingSelectedWarning, type McUndeclaredPrefixWarning, type ValueKeptWarning, type ValueOutOfRangeWarning, type MisplacedContentWarning, type PartWarning, type MceResult } from './mce/preprocessor.mjs';
+export { repairBreaksOutsideRuns, type BrOutsideRunWarning } from './repair/breaks.mjs';
+export { readMainPartRoot, type UnexpectedRootWarning } from './repair/mainRoot.mjs';
+export type { ContentSkippedWarning } from './skipped.mjs';
+export { UNDERSTOOD_NAMESPACES, TRAVERSAL_NAMESPACES } from './mce/understood.mjs';
+export { Docx4JException, InvalidFormatException, PartUnrecognisedException, PartUnmarshalException, MisplacedContentException, SaveLossException, type ContentLoss, DuplicateEntryException, type DuplicateEntryWarning, MultipleMainPartsException, type MultipleMainPartsWarning, RelationshipsNamespaceException, type RelationshipsNamespaceWarning, ExternalMainPartException, type ExternalMainPartWarning, CyclicStylesException, PropertyResolverNotCreatedException } from './exceptions.mjs';
 export { parseXml, serializeXml, serializeXmlPart, createDocument, encodeText, decodeXmlText, stripXmlDeclaration, base64Encode, base64Decode, childElements, XML_DECLARATION } from '../xml/dom.mjs';

package/dist/opc/index.mjs

@@ -5,9 +5,11 @@ export { ContentTypeManager, CONTENT_TYPES_NS } from './ContentTypeManager.mjs';
 export { MemoryPartStore, MemoryPartSink } from './PartStore.mjs';
 export { ZipPartStore, ZipPartSink } from './ZipPartStore.mjs';
 export { FlatOpcPartStore, FlatOpcPartSink, PKG_NS } from './FlatOpcPartStore.mjs';
-export { loadPackage } from './Load.mjs';
+export { loadPackage, REPAIR_MODES } from './Load.mjs';
 export { savePackage } from './Save.mjs';
 export { mceKeep, mcePreprocess, createMcePreprocessor, resolveAlternateContent, preprocessAlternateContent, MCE_NS, KEPT_HOSTS } from './mce/preprocessor.mjs';
-export { UNDERSTOOD_NAMESPACES, UNDERSTOOD_PREFIXES, READ_ONLY_UNDERSTOOD_NAMESPACES, READ_UNDERSTOOD_NAMESPACES, READ_UNDERSTOOD_PREFIXES } from './mce/understood.mjs';
-export { Docx4JException, InvalidFormatException, PartUnrecognisedException, PartUnmarshalException, CyclicStylesException, PropertyResolverNotCreatedException } from './exceptions.mjs';
+export { repairBreaksOutsideRuns } from './repair/breaks.mjs';
+export { readMainPartRoot } from './repair/mainRoot.mjs';
+export { UNDERSTOOD_NAMESPACES, TRAVERSAL_NAMESPACES } from './mce/understood.mjs';
+export { Docx4JException, InvalidFormatException, PartUnrecognisedException, PartUnmarshalException, MisplacedContentException, SaveLossException, DuplicateEntryException, MultipleMainPartsException, RelationshipsNamespaceException, ExternalMainPartException, CyclicStylesException, PropertyResolverNotCreatedException } from './exceptions.mjs';
 export { parseXml, serializeXml, serializeXmlPart, createDocument, encodeText, decodeXmlText, stripXmlDeclaration, base64Encode, base64Decode, childElements, XML_DECLARATION } from '../xml/dom.mjs';

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

@@ -1,4 +1,8 @@
 import type { XmlPart } from '../../parts/XmlPart.mjs';
+import type { BrOutsideRunWarning } from '../repair/breaks.mjs';
+import type { UnexpectedRootWarning } from '../repair/mainRoot.mjs';
+import type { ContentSkippedWarning } from '../skipped.mjs';
+import type { RelationshipsNamespaceWarning } from '../exceptions.mjs';
 export declare const MCE_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";
 /**
  * The hosts whose mc:AlternateContent is kept whole on load, as `{namespace}localName`
@@ -6,7 +10,7 @@ export declare const MCE_NS = "http://schemas.openxmlformats.org/markup-compatib
  */
 export declare const KEPT_HOSTS: ReadonlySet<string>;
 export interface McePreprocessOptions {
-    /** Namespaces counted as understood; defaults to `READ_UNDERSTOOD_NAMESPACES` (CR-013 D3). */
+    /** Namespaces counted as understood; defaults to `UNDERSTOOD_NAMESPACES`, the 114 Word 365 was measured to understand (WD REQ-306). */
     understood?: ReadonlySet<string>;
     /** Hosts, as `{namespace}localName`, whose mc:AlternateContent is left whole; defaults to `KEPT_HOSTS`. */
     keptHosts?: ReadonlySet<string>;
@@ -15,6 +19,12 @@ export interface McePreprocessOptions {
      * warnings, from the same elements, and no change to the DOM. Defaults to true.
      */
     resolve?: boolean;
+    /**
+     * Whether this is a word-processing part, where an element nothing can be selected from is reported and removed (WD
+     * REQ-305); in any other it is left whole and said nothing of (CR-029 D3). Defaults to true; the preprocessors read it
+     * from the part's content type.
+     */
+    wordProcessing?: boolean;
 }
 /**
  * What load reports about a part (CR-010 phase 1; the text extraction paper's warning channel).
@@ -36,14 +46,49 @@ export interface McBranchesDifferWarning {
     }[];
     message: string;
 }
+/**
+ * `mce.nothing_selected` (WD REQ-305, CR-029): an mc:AlternateContent with Choices, none understood, and no Fallback, so
+ * that the element and all it holds are absent, as ISO and Word read it. `namespaces` gives what its Choices require, each
+ * once, in order, a prefix nothing binds having none. `removed` says a resolving load took it out; `root` that it is a part's
+ * root, which is left whole. A reader's walk meets neither, so the text model carries such a warning with no address.
+ */
+export interface McNothingSelectedWarning {
+    code: 'mce.nothing_selected';
+    partName: string | undefined;
+    /** Where the element starts in the part, where the DOM records it (xmldom does; a browser's DOMParser does not). */
+    line?: number;
+    column?: number;
+    namespaces: string[];
+    removed: boolean;
+    root: boolean;
+    message: string;
+}
+/**
+ * `mce.undeclared_prefix` (WD REQ-323, CR-030): an `mc:Ignorable` listing a prefix with no namespace declaration in scope on the
+ * element carrying it. Such a prefix names no namespace, so it is read as though the list didn't hold it: nothing it seems to
+ * name is ignorable. Word repairs such a file and loses nothing (the `undeclared-ignorable` round). One warning a part, with
+ * every such prefix once, in document order. A declaration on a descendant doesn't put a prefix in scope. A save that writes
+ * the part anew holds none: the objects facade drops a prefix it doesn't know and declares one it does, and a part copied from
+ * its source keeps it as written.
+ */
+export interface McUndeclaredPrefixWarning {
+    code: 'mce.undeclared_prefix';
+    partName: string | undefined;
+    prefixes: string[];
+    message: string;
+}
 /**
  * An attribute value of Word's own WordprocessingML that its type refuses, read as Word 365 reads it
  * rather than failing the part (CR-015 D8; the objects facade's `wordInvalidValue`, its CR-013):
  * `value.kept.exact` where the text, trimmed of XML whitespace, is a form its type reads (`" false"`),
- * else `value.kept.invalid` (`"yes"`, `"Single"`). The names are docx4j-python CR-018's.
+ * else `value.kept.invalid` (`"yes"`, `"Single"`). The codes are this package's (CR-015 D8); the reasons, exact and invalid,
+ * are docx4j-python CR-018's (its `KeptValue.reason`). An integer attribute's value Word reads by its own rule (the objects
+ * package's CR-015, CR-017 P1): `value.truncated` for a decimal, cut toward zero as Word cuts it (`"720.5"` reads 720);
+ * `value.refused` for a form Word refuses a document for (`" 240 "`, `"0x10"`), dropped; `""` and the forms with no
+ * digit (`"."`, `"+"`) read as 0, `value.kept.invalid`.
  */
 export interface ValueKeptWarning {
-    code: 'value.kept.exact' | 'value.kept.invalid';
+    code: 'value.kept.exact' | 'value.kept.invalid' | 'value.truncated' | 'value.refused';
     partName: string | undefined;
     /** Where the element starts in the part, where the DOM records it (xmldom does; a browser's DOMParser does not). */
     line?: number;
@@ -55,14 +100,80 @@ export interface ValueKeptWarning {
     text: string;
     /**
      * What the tree holds instead: `true` for an on/off value (Word reads only exactly `false`, `off` and
-     * `0` as off), `'none'` for `w:u`'s on/off words, and undefined where the value was dropped, so the
-     * attribute reads as absent (a style's value beneath shows).
+     * `0` as off), `'none'` for `w:u`'s on/off words, an integer Word's reading of a decimal or of `""`, and
+     * undefined where the value was dropped, so the attribute reads as absent (a style's value beneath shows).
      */
-    value: boolean | string | undefined;
+    value: boolean | string | number | undefined;
+    message: string;
+}
+/**
+ * An integer attribute value Word 365 reads differently from the tree (CR-017 P2 and P3; the objects facade's
+ * `onOutOfRange`, its CR-016, docx4j CR-066's rounds 5 and 6): outside the width Word stores the attribute in, 16 bits
+ * for most, where Word reads it wrapped, sometimes then clamped, with no error or repair. The tree keeps the value as
+ * written, and a save writes it as held: the warning says what Word would show. The code and the fields are shared
+ * with docx4j-python (its CR-020 section 4.7, `word_reads` there), one name across the ports for the one condition
+ * (CR-017 E1). On load the warning is on the part, with the line and column where the DOM records them; on save it is
+ * on `pkg.lastSave.outOfRange`, with the `path` from the part's root.
+ */
+export interface ValueOutOfRangeWarning {
+    code: 'value.out_of_range';
+    partName: string | undefined;
+    /** Where the element starts in the part, where the DOM records it (xmldom does; a browser's DOMParser does not). */
+    line?: number;
+    column?: number;
+    /** On save, the attribute's path from the part's root: `/w:document/w:body[1]/w:p[3]/w:pPr[1]/w:ind[1]/@w:left`. */
+    path?: string;
+    /** The element and the attribute as the part writes them (`w:ind`, `w:left`). */
+    element: string;
+    attribute: string;
+    /** The value the tree holds, and a save writes. */
+    value: number;
+    /** What Word reads for it, after the wrap and any clamp; null for an attribute no round measured. */
+    wordReads: number | null;
+    /** The attribute Word reads the value in, where the shared field's sign moved it: `w:hanging` for a `w:firstLine` of 32768. */
+    readAs?: string;
+    /** For a line, a row height or a frame's height, the rule Word reads with the value (`exact`, `atLeast`, `auto`). */
+    rule?: 'auto' | 'exact' | 'atLeast';
+    /** How Word stores the attribute, the objects package's wording: `int16`, `uint16, then 144..31681`, `int16, the sign the rule`, ... */
+    storage: string;
+    /** The values Word keeps as written there, `[min, max]` in the attribute's own unit (`keptRange`); null where none is known. */
+    range: readonly [number, number] | null;
+    message: string;
+}
+/**
+ * A child its container never admits (CR-016 D7, the objects facade's `onMisplaced`, its CR-017; docx4j CR-064's rules):
+ * a run straight in the body, a table in a paragraph, a cell beside a table's rows, a string in a run, or a name and
+ * value that disagree. On load, one per child the facade reports as it reads the part, the tree keeping what it read
+ * (a string in a run excepted, which the runtime drops: `text` carries it); on a save with `checkContentOnSave` off,
+ * one per child written as held, on `pkg.lastSave.misplaced`; with it on, the save is refused with them
+ * (`MisplacedContentException`). The code and the fields are docx4j-python's (its CR-020 section 11.12), one code across
+ * the ports; `rule`, `text` and `line` are this package's own.
+ */
+export interface MisplacedContentWarning {
+    code: 'target.misplaced';
+    partName: string | undefined;
+    /** Where the child (else its container) starts in the part, where the DOM records it (xmldom does). */
+    line?: number;
+    column?: number;
+    /** On save, the child's path from the part's root (`/w:document/w:body[1]/w:p[1]/w:r[1]/w:tbl[1]`); the container's for a string. */
+    path?: string;
+    /** The container's class, docx4j's name (`P`, `R`, `Tbl`, `CTSdtContentRun`): the objects `TYPE_NAME`'s last segment. */
+    holder: string;
+    /** The child's position in the list holding it. */
+    index: number;
+    /** The child's class the same way (`Tbl`, `R`), where it has one; absent for a string. */
+    item?: string;
+    /** The child's element as the part writes it (`w:tbl`); absent for a string. */
+    element?: string;
+    /** `misplaced`, a class the container refuses; `name-value`, a value whose class isn't the one its name declares there. */
+    rule: 'misplaced' | 'name-value';
+    /** For a string in a container that admits none, the string (on load; a save never sees it). */
+    text?: string;
+    /** docx4j's wording, with the fix: "You can't add a run (w:r) directly to the body (w:body); ...", after the part and the place. */
     message: string;
 }
 /** A warning load records on a part. */
-export type PartWarning = McBranchesDifferWarning | ValueKeptWarning;
+export type PartWarning = McBranchesDifferWarning | McNothingSelectedWarning | McUndeclaredPrefixWarning | ValueKeptWarning | ValueOutOfRangeWarning | MisplacedContentWarning | BrOutsideRunWarning | UnexpectedRootWarning | ContentSkippedWarning | RelationshipsNamespaceWarning;
 /**
  * What one pass over a DOM did. `kept` counts the elements it met and left whole; it doesn't enter a
  * branch the rule doesn't select, so an element nested there is not counted.
@@ -77,13 +188,13 @@ export interface MceResult {
  * warnings are what resolving would report. Returns them.
  */
 export declare function mceKeep(doc: Document, part?: XmlPart<unknown>): PartWarning[];
-/** The resolving preprocessor (`mcePreprocess: true`), over `READ_UNDERSTOOD_NAMESPACES`. Returns the part's warnings. */
+/** The resolving preprocessor (`mcePreprocess: true`), over `UNDERSTOOD_NAMESPACES`. Returns the part's warnings. */
 export declare function mcePreprocess(doc: Document, part?: XmlPart<unknown>): PartWarning[];
 /** A preprocessor over a namespace set (or kept hosts) of your own. */
 export declare function createMcePreprocessor(options: McePreprocessOptions): (doc: Document, part?: XmlPart<unknown>) => PartWarning[];
 /**
- * Resolves every mc:AlternateContent under a node, outermost first, but those `KEPT_HOSTS` and the
- * nothing-selectable rule keep (see the file comment). Returns the number resolved.
+ * Resolves every mc:AlternateContent under a node, outermost first, but those the file comment keeps. Returns the number
+ * resolved, one nothing was selected from among them.
  */
 export declare function resolveAlternateContent(root: Node, understood?: ReadonlySet<string>): number;
 /**