@docx4j/core-ts 0.4.0 → 0.5.0

package/dist/model/properties/PropertyResolver.mjs

@@ -1,5 +1,5 @@
 import { deepCopy } from '@docx4j/generated-objects-ts';
-import { Docx4JException } from '../../opc/exceptions.mjs';
+import { Docx4JException, PartUnmarshalException } from '../../opc/exceptions.mjs';
 import { log } from './log.mjs';
 import { NumberingDefinitions } from '../listnumbering/definitions.mjs';
 import { applyPPr, applyPPrBase, applyRPr, applyStyle, applyStyleLevel, applyTblPr, applyToggles, hasDirectFormattingPPr, hasDirectFormattingRPr, isCyclic, isEmptyStyle, } from './styleUtil.mjs';
@@ -75,6 +75,26 @@ export function headingLevelByName(style) {
     const match = HEADING_NAME.exec(name.trim());
     return match ? Number(match[1]) : -1;
 }
+/**
+ * A styles or numbering part the resolver can't do without: when it can't be read, nothing in the
+ * document can be given its formatting, so the document is refused (Jason, 2026-10-17), and the
+ * error says so before it says what was wrong where. A `PartUnmarshalException` stays one, with its
+ * part, location, line and column, so a caller showing the fault reads the same fields as for any
+ * part.
+ */
+async function readOrRefuse(part, role) {
+    try {
+        return await part.readContents();
+    }
+    catch (e) {
+        const why = role === 'styles' ? "every paragraph's formatting depends on it" : "its lists' numbers and indents depend on it";
+        const lead = `The document cannot be opened: its ${role} part could not be read, and ${why}.`;
+        if (e instanceof PartUnmarshalException) {
+            throw new PartUnmarshalException(`${lead} ${e.message}`, e.partName, { cause: e, location: e.location, line: e.line, column: e.column });
+        }
+        throw new Docx4JException(`${lead} ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+    }
+}
 export class PropertyResolver {
     constructor(provider, 
     /** Set when the styles tree the resolver holds is not the styles part's own. */
@@ -104,6 +124,12 @@ export class PropertyResolver {
         this.composedRPrCache = new CompositionCache();
         /** See {@link appliesTableStyleSizeJcException}; read once per `refresh()`. */
         this.tableStyleSizeJcException = true;
+        /**
+         * Whether the document's own `w:docDefaults` state a size, rather than the 10pt the resolver
+         * makes explicit where they do not: the size exception takes the document defaults' size only
+         * where they state one. Read once per `refresh()`.
+         */
+        this.docDefaultsStateSize = false;
         /** Missing styles are logged once each per resolver. */
         this.missingLogged = new Set();
         this.source = provider();
@@ -132,8 +158,8 @@ export class PropertyResolver {
         }
         const stylesPart = main.styleDefinitionsPart;
         const numberingPart = main.numberingDefinitionsPart;
-        const privateStyles = stylesPart === undefined ? undefined : await stylesPart.readContents();
-        const privateNumbering = numberingPart === undefined ? undefined : await numberingPart.readContents();
+        const privateStyles = stylesPart === undefined ? undefined : await readOrRefuse(stylesPart, 'styles');
+        const privateNumbering = numberingPart === undefined ? undefined : await readOrRefuse(numberingPart, 'numbering');
         // the settings are read for two compatibility values (CR-007), privately, as the others are
         const settingsPart = main.documentSettingsPart;
         let privateSettings;
@@ -189,6 +215,7 @@ export class PropertyResolver {
             ? { TYPE_NAME: 'org_docx4j_wml.PPr' } : deepCopy(docDefaults.pPrDefault.pPr);
         this.documentDefaultRPr = ((_f = docDefaults === null || docDefaults === void 0 ? void 0 : docDefaults.rPrDefault) === null || _f === void 0 ? void 0 : _f.rPr) === undefined
             ? { TYPE_NAME: 'org_docx4j_wml.RPr' } : deepCopy(docDefaults.rPrDefault.rPr);
+        this.docDefaultsStateSize = this.documentDefaultRPr.sz !== undefined;
         if (this.documentDefaultRPr.sz === undefined) {
             // Word's default made explicit: 10pt where nothing states a size (measured, CR-015 probe
             // styles-no-size-anywhere: identical to an explicit 10pt run)
@@ -384,7 +411,7 @@ export class PropertyResolver {
         return styleId;
     }
     getEffectivePPr(arg, cellContext) {
-        if (cellContext !== undefined && cellContext.formatsText && typeof arg !== 'string') {
+        if (this.composes(cellContext) && typeof arg !== 'string') {
             const composed = this.composedPPr(this.paragraphStyleOf(arg), cellContext);
             if (!hasDirectFormattingPPr(arg))
                 return composed;
@@ -415,7 +442,7 @@ export class PropertyResolver {
     getEffectiveRPr(arg, pPr, cellContext) {
         if (typeof arg === 'string')
             return this.effectiveRPrOfStyle(arg);
-        if (cellContext !== undefined && cellContext.formatsText) {
+        if (this.composes(cellContext)) {
             const inTable = deepCopy(this.composedRPr(this.paragraphStyleOf(pPr), cellContext));
             this.applyCharacterStyleAndDirect(arg, inTable);
             return inTable;
@@ -462,23 +489,43 @@ export class PropertyResolver {
     }
     /**
      * The run properties of the paragraph mark: document defaults, the paragraph style's run
-     * properties, then the `w:pPr`'s own `w:rPr`. What sizes an empty paragraph, and what a list
-     * label starts from.
+     * properties, the mark's character style, then the `w:pPr`'s own `w:rPr`. What sizes an empty
+     * paragraph, and what a list label starts from.
      */
     getEffectiveParagraphMarkRPr(pPr, cellContext) {
-        if (cellContext !== undefined && cellContext.formatsText) {
+        if (this.composes(cellContext)) {
             // in a table cell: the table level beneath the paragraph style's (CR-007)
             const inTable = deepCopy(this.composedRPr(this.paragraphStyleOf(pPr), cellContext));
             if ((pPr === null || pPr === void 0 ? void 0 : pPr.rPr) !== undefined)
-                applyRPr(pPr.rPr, inTable);
+                this.applyMarkRPr(pPr.rPr, inTable);
             return inTable;
         }
         const effective = deepCopy(this.documentDefaultRPr);
         applyRPr(this.getChainRPr(this.paragraphStyleOf(pPr)), effective);
         if ((pPr === null || pPr === void 0 ? void 0 : pPr.rPr) !== undefined)
-            applyRPr(pPr.rPr, effective);
+            this.applyMarkRPr(pPr.rPr, effective);
         return effective;
     }
+    /**
+     * The paragraph mark's character style (`w:pPr/w:rPr/w:rStyle`) as a level over what is
+     * beneath it, then the mark's direct formatting: the order {@link applyCharacterStyleAndDirect}
+     * gives a run. docx4j `applyMarkRPr`, since 17.3.2 (fb2a764f7: until then the mark's
+     * `w:rStyle` was copied as an attribute and never resolved, so an empty paragraph whose mark
+     * names a 9pt character style was sized at its paragraph style's 12pt).
+     */
+    applyMarkRPr(mark, effective) {
+        var _a;
+        const runStyleId = (_a = mark.rStyle) === null || _a === void 0 ? void 0 : _a.val;
+        if (runStyleId !== undefined) {
+            if (this.getLiveStyle(runStyleId) === undefined) {
+                this.logMissing(runStyleId);
+            }
+            else {
+                applyStyleLevel(this.getChainRPr(runStyleId), effective, this.documentDefaultRPr);
+            }
+        }
+        applyRPr(mark, effective);
+    }
     /** Whether the run states any formatting of its own (docx4j's deprecated `hasDirectRPrFormatting`). */
     hasDirectRPrFormatting(rPr) {
         return hasDirectFormattingRPr(rPr);
@@ -609,6 +656,15 @@ export class PropertyResolver {
         const found = enclosingCellOf(p);
         return found === undefined ? undefined : this.tableContext(found.tbl).forParagraph(found.tr, found.tc, p.pPr);
     }
+    /**
+     * Whether a paragraph in this context is composed over its table level: where the table style
+     * gives it text formatting, or, under [MS-DOCX]'s size exception, where the style formats text
+     * anywhere ({@link CellContext.styleFormatsText}). docx4j `composes` (900b6a212, 17.3.2).
+     */
+    composes(cellContext) {
+        return cellContext !== undefined && (cellContext.formatsText
+            || (this.tableStyleSizeJcException && cellContext.styleFormatsText));
+    }
     clearTableCaches() {
         this.tableStyleChains.clear();
         this.composedPPrCache.clear();
@@ -663,18 +719,29 @@ export class PropertyResolver {
         // the table and the paragraph style are two levels of the hierarchy: the twelve toggles
         // combine across them rather than the paragraph's overriding (17.7.3)
         applyToggles(paragraphLevel, tableLevel, this.documentDefaultRPr, composed);
-        if (this.tableStyleSizeJcException && (tableOnly === null || tableOnly === void 0 ? void 0 : tableOnly.sz) !== undefined
+        // The size the table level gives is its own where the table style states one, else the
+        // document defaults' where they state one: Word applies the exception wherever the table
+        // style formats text at all, not only where it states a size (docx4j 900b6a212, measured on
+        // its table-style-size-trigger probes: in mode 12, with docDefaults 11pt and Normal 12pt, a
+        // table style with only a w:pPr, only an rPr colour, or only a firstRow format sets its
+        // table's paragraphs at 11pt; with none of these, at Normal's 12pt).  But where neither the
+        // table style nor the docDefaults state a size, Normal keeps its 12pt, not the 10pt Word
+        // falls back to (docx4j's corpus documents 10244 and 12723).
+        const tableStatesSize = (tableOnly === null || tableOnly === void 0 ? void 0 : tableOnly.sz) !== undefined;
+        if (this.tableStyleSizeJcException && ctx.styleFormatsText && tableLevel.sz !== undefined
+            && (tableStatesSize || this.docDefaultsStateSize)
             && this.paragraphStyleGivesWay(styleId, true)) {
-            composed.sz = deepCopy(tableOnly.sz);
+            composed.sz = deepCopy(tableLevel.sz);
         }
         this.composedRPrCache.set(styleId, ctx.key, composed);
         return composed;
     }
     /**
-     * [MS-DOCX]'s exception, for a paragraph in a table whose style states a size (or a
-     * justification): the paragraph's style gives way to it if the style is the default paragraph
-     * style, or states no size (justification) of its own, and resolves to 12pt (left). A style of
-     * the paragraph's own which states one keeps it.
+     * [MS-DOCX]'s exception, for a paragraph in a table whose style formats text (for the size: the
+     * style need not state one, since docx4j 17.3.2) or states a justification: the paragraph's
+     * style gives way to it if the style is the default paragraph style, or states no size
+     * (justification) of its own, and resolves to 12pt (left). A style of the paragraph's own which
+     * states one keeps it.
      */
     paragraphStyleGivesWay(styleId, size) {
         var _a, _b, _c, _d;

package/dist/model/properties/catalogue.d.mts

@@ -39,7 +39,12 @@ export declare function isTrue(value: wml.BooleanDefaultTrue | undefined): boole
 export declare function isEmptyRStyle(value: wml.RStyle | undefined): boolean;
 /** docx4j `isEmpty(RFonts)`: insensitive to a `w:hint` (which `apply` still carries). */
 export declare function isEmptyRFonts(value: wml.RFonts | undefined): boolean;
+/**
+ * A `w:color` stating only a theme colour is not empty: it is inherited, where until docx4j CR-034
+ * (2e381ef26) it was dropped.
+ */
 export declare function isEmptyColor(value: wml.Color | undefined): boolean;
+/** The underline's colour attributes count, the theme ones too (docx4j CR-034, 2e381ef26). */
 export declare function isEmptyU(value: wml.U | undefined): boolean;
 export declare function isEmptyHighlight(value: wml.Highlight | undefined): boolean;
 /** @since CR-015 phase 1: a style stating only `w:lang` used to count as empty and was never applied. */
@@ -87,8 +92,17 @@ export declare const mergePStyle: Merge<wml.PPrBase.PStyle>;
  * formatted).
  */
 export declare const mergeRFonts: Merge<wml.RFonts>;
+/**
+ * A colour inherits as one (docx4j CR-034, 2e381ef26): where the source states a value or a theme
+ * reference, its value, theme colour, tint and shade replace the destination's together. Word
+ * draws a theme reference over the value written beside it, so taken one by one, a run's
+ * `w:val="FF0000"` under a style's `w:themeColor="accent1"` would keep the style's reference and
+ * draw accent1, where Word draws red. A tint or shade stated alone still inherits on its own. The
+ * same holds for the colours of `w:u`, `w:shd` (its pattern colour and its fill) and the borders.
+ * (Attribute by attribute until then, CR-015 phase 1.)
+ */
 export declare const mergeColor: Merge<wml.Color>;
-/** `w:val` and the colour attributes each inherit on their own (CR-015 phase 1). */
+/** `w:val` and the colour inherit on their own (CR-015 phase 1), the colour as one ({@link mergeColor}). */
 export declare const mergeU: Merge<wml.U>;
 /** `w:val`, `w:eastAsia` and `w:bidi` each name the language of one script range and each inherits. */
 export declare const mergeLang: Merge<wml.CTLanguage>;

package/dist/model/properties/catalogue.mjs

@@ -29,9 +29,12 @@ function emptyThemeColor(value) {
 function attr(source, destination) {
     return source === undefined ? destination : source;
 }
-/** docx4j `StyleUtil.apply(STThemeColor, STThemeColor)`: `none` does not override. */
-function themeColor(source, destination) {
-    return emptyThemeColor(source) ? destination : source;
+/**
+ * docx4j `StyleUtil.statesColour`: a colour's value or theme reference is stated, so the colour
+ * inherits as one (docx4j CR-034, 2e381ef26; see {@link mergeColor}).
+ */
+function statesColour(val, theme) {
+    return !emptyString(val) || !emptyThemeColor(theme);
 }
 /** A merge with no per-attribute rule: a copy of the source where it has one, else the inherited. */
 export function mergeReplace(source, destination) {
@@ -71,11 +74,20 @@ export function isEmptyRFonts(value) {
             && emptyString(value.eastAsia) && value.eastAsiaTheme === undefined
             && emptyString(value.hAnsi) && value.hAnsiTheme === undefined);
 }
+/**
+ * A `w:color` stating only a theme colour is not empty: it is inherited, where until docx4j CR-034
+ * (2e381ef26) it was dropped.
+ */
 export function isEmptyColor(value) {
-    return value === undefined || emptyString(value.val);
+    return value === undefined
+        || (emptyString(value.val) && value.themeColor === undefined
+            && emptyString(value.themeTint) && emptyString(value.themeShade));
 }
+/** The underline's colour attributes count, the theme ones too (docx4j CR-034, 2e381ef26). */
 export function isEmptyU(value) {
-    return value === undefined || (value.val === undefined && emptyString(value.color));
+    return value === undefined
+        || (value.val === undefined && emptyString(value.color) && value.themeColor === undefined
+            && emptyString(value.themeTint) && emptyString(value.themeShade));
 }
 export function isEmptyHighlight(value) {
     return value === undefined || emptyString(value.val);
@@ -291,28 +303,49 @@ export const mergeRFonts = (source, destination) => {
         out.hint = source.hint;
     return out;
 };
+/**
+ * A colour inherits as one (docx4j CR-034, 2e381ef26): where the source states a value or a theme
+ * reference, its value, theme colour, tint and shade replace the destination's together. Word
+ * draws a theme reference over the value written beside it, so taken one by one, a run's
+ * `w:val="FF0000"` under a style's `w:themeColor="accent1"` would keep the style's reference and
+ * draw accent1, where Word draws red. A tint or shade stated alone still inherits on its own. The
+ * same holds for the colours of `w:u`, `w:shd` (its pattern colour and its fill) and the borders.
+ * (Attribute by attribute until then, CR-015 phase 1.)
+ */
 export const mergeColor = (source, destination) => {
     if (isEmptyColor(source))
         return destination;
     const s = source;
     const out = (destination !== null && destination !== void 0 ? destination : {});
-    out.themeColor = themeColor(s.themeColor, out.themeColor);
-    out.themeShade = attr(s.themeShade, out.themeShade);
-    out.themeTint = attr(s.themeTint, out.themeTint);
-    out.val = attr(s.val, out.val);
+    if (statesColour(s.val, s.themeColor)) {
+        out.val = s.val;
+        out.themeColor = s.themeColor;
+        out.themeTint = s.themeTint;
+        out.themeShade = s.themeShade;
+    }
+    else {
+        out.themeShade = attr(s.themeShade, out.themeShade);
+        out.themeTint = attr(s.themeTint, out.themeTint);
+    }
     return out;
 };
-/** `w:val` and the colour attributes each inherit on their own (CR-015 phase 1). */
+/** `w:val` and the colour inherit on their own (CR-015 phase 1), the colour as one ({@link mergeColor}). */
 export const mergeU = (source, destination) => {
     if (isEmptyU(source))
         return destination;
     const s = source;
     const out = destination !== null && destination !== void 0 ? destination : {};
     out.val = attr(s.val, out.val);
-    out.color = attr(s.color, out.color);
-    out.themeColor = themeColor(s.themeColor, out.themeColor);
-    out.themeTint = attr(s.themeTint, out.themeTint);
-    out.themeShade = attr(s.themeShade, out.themeShade);
+    if (statesColour(s.color, s.themeColor)) {
+        out.color = s.color;
+        out.themeColor = s.themeColor;
+        out.themeTint = s.themeTint;
+        out.themeShade = s.themeShade;
+    }
+    else {
+        out.themeTint = attr(s.themeTint, out.themeTint);
+        out.themeShade = attr(s.themeShade, out.themeShade);
+    }
     return out;
 };
 /** `w:val`, `w:eastAsia` and `w:bidi` each name the language of one script range and each inherits. */
@@ -331,16 +364,29 @@ export const mergeShd = (source, destination) => {
         return destination;
     const s = source;
     const out = (destination !== null && destination !== void 0 ? destination : {});
-    out.color = attr(s.color, out.color);
-    out.fill = attr(s.fill, out.fill);
     out.val = attr(s.val, out.val);
-    out.themeTint = attr(s.themeTint, out.themeTint);
-    out.themeShade = attr(s.themeShade, out.themeShade);
-    out.themeFillTint = attr(s.themeFillTint, out.themeFillTint);
-    out.themeFillShade = attr(s.themeFillShade, out.themeFillShade);
-    // the enums only when the source states them (until CR-015 a null source cleared them)
-    out.themeColor = themeColor(s.themeColor, out.themeColor);
-    out.themeFill = themeColor(s.themeFill, out.themeFill);
+    // the pattern colour and the fill each inherit as one (see mergeColor), so a direct w:shd
+    // stating no fill still leaves an inherited w:themeFill (CR-015)
+    if (statesColour(s.color, s.themeColor)) {
+        out.color = s.color;
+        out.themeColor = s.themeColor;
+        out.themeTint = s.themeTint;
+        out.themeShade = s.themeShade;
+    }
+    else {
+        out.themeTint = attr(s.themeTint, out.themeTint);
+        out.themeShade = attr(s.themeShade, out.themeShade);
+    }
+    if (statesColour(s.fill, s.themeFill)) {
+        out.fill = s.fill;
+        out.themeFill = s.themeFill;
+        out.themeFillTint = s.themeFillTint;
+        out.themeFillShade = s.themeFillShade;
+    }
+    else {
+        out.themeFillTint = attr(s.themeFillTint, out.themeFillTint);
+        out.themeFillShade = attr(s.themeFillShade, out.themeFillShade);
+    }
     return out;
 };
 export const mergeBorder = (source, destination) => {
@@ -348,13 +394,20 @@ export const mergeBorder = (source, destination) => {
         return destination;
     const s = source;
     const out = (destination !== null && destination !== void 0 ? destination : {});
-    out.color = attr(s.color, out.color);
     out.space = attr(s.space, out.space);
     out.sz = attr(s.sz, out.sz);
-    out.themeColor = themeColor(s.themeColor, out.themeColor);
-    out.themeShade = attr(s.themeShade, out.themeShade);
-    out.themeTint = attr(s.themeTint, out.themeTint);
     out.val = attr(s.val, out.val);
+    // the colour inherits as one (see mergeColor)
+    if (statesColour(s.color, s.themeColor)) {
+        out.color = s.color;
+        out.themeColor = s.themeColor;
+        out.themeTint = s.themeTint;
+        out.themeShade = s.themeShade;
+    }
+    else {
+        out.themeShade = attr(s.themeShade, out.themeShade);
+        out.themeTint = attr(s.themeTint, out.themeTint);
+    }
     return out;
 };
 export const mergePBdr = (source, destination) => {

package/dist/model/properties/table.d.mts

@@ -40,9 +40,21 @@ export declare class CellContext {
     /**
      * Whether the table style gives this paragraph anything at all: its own `w:pPr` or `w:rPr`, or
      * a conditional format with one. Where it does not, resolving with this context gives the same
-     * answer as resolving without one.
+     * answer as resolving without one - except under [MS-DOCX]'s size exception, for which see
+     * {@link styleFormatsText}.
      */
     readonly formatsText: boolean;
+    /**
+     * Whether the table style formats text anywhere: its own `w:pPr` or `w:rPr`, or a conditional
+     * format with one, whether or not that condition holds for this paragraph. Below compatibility
+     * mode 15 this, not what applies here, is what brings [MS-DOCX]'s size exception into play:
+     * measured on docx4j's table-style-size-trigger probes (its corpus document 1912), a table
+     * style with only a `w:pPr`, only an `w:rPr` colour, or only a `firstRow` format sets every row
+     * of its table at the document defaults' size where Normal states 12pt - the `firstRow`
+     * format's second row included - while a style with none of these leaves Normal's 12pt.
+     * docx4j `styleFormatsText()` (900b6a212, 17.3.2).
+     */
+    readonly styleFormatsText: boolean;
     /** What the table level's composition depends on. A value, for keying caches. */
     readonly key: CellContextKey;
     constructor(
@@ -138,7 +150,9 @@ export declare class TableContextTracker {
     /**
      * Walks everything under `root` (an object, an element pair or an array of them), in document
      * order, calling `visit` for each paragraph with its context. It descends through every
-     * member but the `PARENT` pointers, so a text box's paragraphs are reached, in no table.
+     * member but the `PARENT` pointers, so a text box's paragraphs are reached, in no table. A kept
+     * `mc:AlternateContent` is descended through its selected branch alone (`selectedBranchOf`,
+     * docx4j's `McMode.READ`), so a text box held in both branches is visited once (CR-010 phase 3).
      */
     walk(root: unknown, visit: (p: wml.P, cellContext: CellContext | undefined) => void): void;
 }

package/dist/model/properties/table.mjs

@@ -1,5 +1,5 @@
 import { isEmptyPPr, isEmptyRPr } from './styleUtil.mjs';
-import { rowsOf, cellsOf } from '../content/tree.mjs';
+import { rowsOf, cellsOf, selectedBranchOf, ALTERNATE_CONTENT } from '../content/tree.mjs';
 import { PRECEDENCE, DEFAULT_LOOK, lookOf, rowBandSize, colBandSize, rowCnf, resolve, rowConditions, applicable, formatsText, key as conditionsKey, } from './tableStyleConditions.mjs';
 /** The conditions as bits over {@link PRECEDENCE}: an exact value for keying caches. */
 function maskOf(conditions) {
@@ -43,6 +43,7 @@ export class CellContext {
     tableStyleId, 
     /** That style's `w:basedOn` chain merged (`getTableStyleChain`): shared, read it only. */
     tableStyle, conditions) {
+        var _a;
         this.tableStyleId = tableStyleId;
         this.tableStyle = tableStyle;
         const c = new Set(conditions !== null && conditions !== void 0 ? conditions : []);
@@ -56,7 +57,10 @@ export class CellContext {
             }
         }
         this.textConditions = text;
-        this.formatsText = text.length > 0 || !isEmptyPPr(tableStyle.pPr) || !isEmptyRPr(tableStyle.rPr);
+        const own = !isEmptyPPr(tableStyle.pPr) || !isEmptyRPr(tableStyle.rPr);
+        this.formatsText = text.length > 0 || own;
+        this.styleFormatsText = own
+            || ((_a = tableStyle.tblStylePr) !== null && _a !== void 0 ? _a : []).some((pr) => pr !== undefined && pr !== null && formatsText(pr));
         this.key = new CellContextKey(tableStyleId, named);
     }
     toString() {
@@ -248,7 +252,9 @@ export class TableContextTracker {
     /**
      * Walks everything under `root` (an object, an element pair or an array of them), in document
      * order, calling `visit` for each paragraph with its context. It descends through every
-     * member but the `PARENT` pointers, so a text box's paragraphs are reached, in no table.
+     * member but the `PARENT` pointers, so a text box's paragraphs are reached, in no table. A kept
+     * `mc:AlternateContent` is descended through its selected branch alone (`selectedBranchOf`,
+     * docx4j's `McMode.READ`), so a text box held in both branches is visited once (CR-010 phase 3).
      */
     walk(root, visit) {
         const seen = new Set();
@@ -264,6 +270,10 @@ export class TableContextTracker {
                 return;
             seen.add(o);
             const typeName = o.TYPE_NAME;
+            if (typeName === ALTERNATE_CONTENT) {
+                descend(selectedBranchOf(o), depth + 1);
+                return;
+            }
             if (typeName === P)
                 visit(o, this.cellContext(o));
             const leave = this.enter(o);

package/dist/opc/Load.d.mts

@@ -5,9 +5,16 @@ import type { OpcPackage } from '../packages/OpcPackage.mjs';
 export interface LoadOptions {
     /** Part classes by content type; defaults to docx4j's table. */
     registry?: PartRegistry;
-    /** Resolve `mc:AlternateContent` before unmarshalling (default true, as docx4j and Word). */
+    /**
+     * Resolve `mc:AlternateContent` before unmarshalling, as Word does on open. Default false since
+     * CR-010 phase 4: every element is kept with all its branches, as docx4j keeps it since its CR-021;
+     * readers take the branch resolving would (`selectedBranchOf`), mutators every branch, and a save
+     * writes them all. Either way a part's `warnings` report where the branches' text differs. True
+     * resolves, but keeps the element under a `KEPT_HOSTS` host and one nothing can be selected from
+     * (CR-010 phase 1).
+     */
     mcePreprocess?: boolean;
-    /** Runs over every XML part's DOM before it is unmarshalled; set by the package from `mcePreprocess`. */
+    /** Runs over every XML part's DOM before it is unmarshalled; set by the package from `mcePreprocess` (`mceKeep` or `mcePreprocess`). */
     preprocessor?: DomPreprocessor;
 }
 /**

package/dist/opc/index.d.mts

@@ -6,7 +6,7 @@ export { ZipPartStore, ZipPartSink } from './ZipPartStore.mjs';
 export { FlatOpcPartStore, FlatOpcPartSink, type FlatOpcSinkOptions, PKG_NS } from './FlatOpcPartStore.mjs';
 export { loadPackage, type LoadOptions } from './Load.mjs';
 export { savePackage } from './Save.mjs';
-export { mcePreprocess, createMcePreprocessor, resolveAlternateContent, MCE_NS, type McePreprocessOptions } from './mce/preprocessor.mjs';
-export { UNDERSTOOD_NAMESPACES } from './mce/understood.mjs';
+export { mceKeep, mcePreprocess, createMcePreprocessor, resolveAlternateContent, preprocessAlternateContent, MCE_NS, KEPT_HOSTS, type McePreprocessOptions, type McBranchesDifferWarning, type PartWarning, type MceResult } from './mce/preprocessor.mjs';
+export { UNDERSTOOD_NAMESPACES, UNDERSTOOD_PREFIXES } from './mce/understood.mjs';
 export { Docx4JException, InvalidFormatException, PartUnrecognisedException, PartUnmarshalException, 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

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