@docx4j/core-ts 0.3.0 → 0.3.2

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

@@ -1,11 +1,17 @@
 import type * as wml from '@docx4j/generated-objects-ts/modules/org_docx4j_wml';
 import { NumberingDefinitions } from '../listnumbering/definitions.mjs';
+import { CellContext, TableContext } from './table.mjs';
 /** The parts the resolver reads. Structural, so this module imports no part class. */
 export interface ResolverSource {
     /** The styles part's `w:styles`, or undefined when the package has none. */
     styles?: wml.Styles;
     /** The numbering part's `w:numbering`, or undefined. */
     numbering?: wml.Numbering;
+    /**
+     * The settings part's `w:settings`, or undefined: read for the compatibility mode and
+     * `overrideTableStyleFontSizeAndJustification` (CR-007). A document with none is in mode 12.
+     */
+    settings?: wml.CTSettings;
 }
 /** As much of an `XmlPart<T>` as the resolver uses. */
 interface ReadablePart<T> {
@@ -18,6 +24,7 @@ interface PackageLike {
     getMainDocumentPart(): {
         styleDefinitionsPart?: ReadablePart<wml.Styles>;
         numberingDefinitionsPart?: ReadablePart<wml.Numbering>;
+        documentSettingsPart?: ReadablePart<wml.CTSettings>;
     };
 }
 /** 108 twips (0.08in): the left and right cell margin of Word's built-in Normal Table. */
@@ -44,6 +51,17 @@ export declare class PropertyResolver {
     /** The document defaults with the chain applied over them: what the style overloads return. */
     private readonly effectivePPrByStyle;
     private readonly effectiveRPrByStyle;
+    /** Each table style's `w:basedOn` chain merged, by id; styles only, so `refresh()` clears it. */
+    private readonly tableStyleChains;
+    /**
+     * A paragraph style composed over a table level, document defaults included; by (paragraph
+     * style, table level). What the overloads with a context start from, as
+     * `getEffectivePPr(styleId)` is what they start from without one.
+     */
+    private readonly composedPPrCache;
+    private readonly composedRPrCache;
+    /** See {@link appliesTableStyleSizeJcException}; read once per `refresh()`. */
+    private tableStyleSizeJcException;
     /** Missing styles are logged once each per resolver. */
     private readonly missingLogged;
     private numberingDefinitions;
@@ -142,6 +160,15 @@ export declare class PropertyResolver {
      * naming no style resolves as the default paragraph style does.
      */
     getEffectivePPr(styleId: string | undefined): wml.PPr;
+    /**
+     * The paragraph properties which apply to a paragraph in a table cell: as
+     * `getEffectivePPr(pPr)`, with the table style's contribution (its own `w:pPr`, then the
+     * conditional formats the paragraph is under) between the document defaults and the
+     * paragraph's style, and [MS-DOCX]'s justification exception where it applies. An undefined
+     * context - a paragraph in no table - resolves exactly as `getEffectivePPr(pPr)`. A live
+     * object where the paragraph has no direct formatting: copy it before changing it.
+     */
+    getEffectivePPr(pPr: wml.PPr | undefined, cellContext: CellContext | undefined): wml.PPr;
     private effectivePPrOfStyle;
     /**
      * The run properties which apply to a run, given its own `w:rPr` and the `w:pPr` of the
@@ -158,6 +185,14 @@ export declare class PropertyResolver {
      * what it contributes with nothing under it. Undefined when no such style exists.
      */
     getEffectiveRPr(styleId: string): wml.RPr | undefined;
+    /**
+     * The run properties which apply to a run in a table cell: as `getEffectiveRPr(rPr, pPr)`,
+     * with the table style's run properties (its own, then its conditional formats') as a level
+     * of the style hierarchy beneath the paragraph style's - the toggle properties combine across
+     * the two (ECMA-376-1 17.7.3) - and [MS-DOCX]'s size exception where it applies. An undefined
+     * context resolves exactly as `getEffectiveRPr(rPr, pPr)`. A new object each call.
+     */
+    getEffectiveRPr(rPr: wml.RPr | undefined, pPr: wml.PPr | undefined, cellContext: CellContext | undefined): wml.RPr;
     private effectiveRPrOfStyle;
     /**
      * The character style's chain, then the direct formatting.
@@ -173,29 +208,94 @@ export declare class PropertyResolver {
      * properties, then the `w:pPr`'s own `w:rPr`. What sizes an empty paragraph, and what a list
      * label starts from.
      */
-    getEffectiveParagraphMarkRPr(pPr: wml.PPr | undefined): wml.RPr;
+    getEffectiveParagraphMarkRPr(pPr: wml.PPr | undefined, cellContext?: CellContext | undefined): wml.RPr;
     /** Whether the run states any formatting of its own (docx4j's deprecated `hasDirectRPrFormatting`). */
     hasDirectRPrFormatting(rPr: wml.RPr | undefined): boolean;
     /**
      * The table style which applies, merged root-first down its `w:basedOn` chain, then the
      * table's own `w:tblPr` over it.
      *
-     * Word's built-in "Normal Table" (`w:tblInd` 0; cell margins 108 twips left and right, 0 top
-     * and bottom) underlies a table naming no style and a table whose chain reaches the
-     * document's default table style - and it is the built-in that applies, not the document's
-     * definition of that style (measured, CR-015 probe styles-table-default). So the default
-     * style's own layer is skipped in favour of the built-in, and a chain that does not reach it
-     * starts from nothing.
+     * Word goes by the style's **name** (measured, docx4j CR-030 probes T1, T2 and T7). A style
+     * named "Normal Table" is Word's built-in Normal Table (`w:tblInd` 0; cell margins 108 twips
+     * left and right, 0 top and bottom), whatever its own definition says and whether or not it is
+     * the document's default: the built-in stands in for it, and the walk up the chain ends there.
+     * Every other style applies as written, with nothing beneath it: a chain which reaches no style
+     * so named starts from nothing, and the document's default table style, where it is named
+     * otherwise, applies as written to a table naming no style. The built-in also stands in for a
+     * style which is missing, and where the document has no default table style. (Until CR-007 the
+     * built-in was decided by the default table style's *id*, as docx4j did until 17.3.1.)
      *
      * A new `Style` each call, with a non-null `w:tblPr`.
      */
     getEffectiveTableStyle(tblPr: wml.CTTblPrBase | undefined): wml.Style;
     /**
-     * Whether a table's style chain reaches the document's default table style - the flag
-     * {@link getEffectiveTableStyle} decides Word's built-in Normal Table by (a table naming no
-     * style counts as reaching it).
+     * Whether Word's built-in Normal Table underlies a table - the flag
+     * {@link getEffectiveTableStyle} decides by: the table's style chain (its own `w:tblStyle`,
+     * else the default table style) reaches a style *named* "Normal Table", or the style is
+     * missing, or there is none. Decided by name since CR-007; the method keeps docx4j's name
+     * from when it was decided by the default style's id.
      */
     reachesDefaultTableStyle(tblPr: wml.CTTblPrBase | undefined): boolean;
+    private builtInTableNormalUnderlies;
+    /**
+     * Whether [MS-DOCX]'s `overrideTableStyleFontSizeAndJustification` exception applies to this
+     * document: a default paragraph style's 12pt does not override the table style's size, nor its
+     * left justification the table style's, for paragraphs in tables. Measured with Word 365
+     * (docx4j CR-030 probes T5 and T6): it applies below compatibility mode 15 (a document stating
+     * no `compatibilityMode` is mode 12) where the setting is not on, and never in mode 15.
+     */
+    appliesTableStyleSizeJcException(): boolean;
+    /**
+     * The id of the table style a table resolves to: its own `w:tblStyle`, else the document's
+     * `w:default` table style, whatever its name; undefined where the table names none and the
+     * document has no default. (Whether that style contributes anything is
+     * {@link getTableStyleChain}'s question.)
+     */
+    getTableStyleIdOf(tblPr: wml.CTTblPrBase | undefined): string | undefined;
+    /**
+     * A table style's `w:basedOn` chain merged root-first, conditional formats merged per
+     * condition, as it gives the paragraphs of its tables their text formatting. Word goes by the
+     * style's *name*: a style named "Normal Table" is Word's built-in, which gives text nothing
+     * whatever its own definition says, so the walk up the chain ends below it; every other style
+     * applies as written, the default table style included.
+     *
+     * Cached per id, and shared: read it, do not change it. An empty style for undefined, for a
+     * missing style, and for a chain which is "Normal Table" all the way down.
+     */
+    getTableStyleChain(styleId: string | undefined): wml.Style;
+    /**
+     * The context of a table, for the paragraphs in it: build one per table and hold it while
+     * walking the table (the resolver keeps none, since it reads the table's content).
+     */
+    tableContext(tbl: wml.Tbl): TableContext;
+    /**
+     * The table context of one paragraph, found through its `PARENT` pointers: the nearest
+     * enclosing cell, its row and its table, through whatever lies between (`w:sdt`,
+     * `w:customXml`, `w:smartTag`). Undefined where the paragraph is in no table, where a story
+     * begins before a cell is reached (a text box, a footnote, endnote or comment, a header, a
+     * footer, the body), or where the pointers are not there (unmarshalled content, and content
+     * the content API inserted, has them: `linkParents`).
+     *
+     * Each call builds a {@link TableContext}, a walk of the table's rows. That is right for "what
+     * formatting does this paragraph have"; code resolving every paragraph of a document walks it
+     * with a `TableContextTracker` instead, since calling this for each paragraph of a large table
+     * is quadratic.
+     */
+    cellContextOf(p: wml.P): CellContext | undefined;
+    private clearTableCaches;
+    /** The table level's `w:pPr`: the style's own, then its conditional formats'; undefined if none. */
+    private tableLevelPPr;
+    /** The table level's `w:rPr`: the style's own, then its conditional formats'; undefined if none. */
+    private tableLevelRPr;
+    private composedPPr;
+    private composedRPr;
+    /**
+     * [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.
+     */
+    private paragraphStyleGivesWay;
     /** Word's built-in Normal Table, as a style: what it applies whatever the document's own definition says. */
     private builtInTableNormal;
     /**

package/dist/model/properties/PropertyResolver.mjs

@@ -2,9 +2,62 @@ import { deepCopy } from '@docx4j/generated-objects-ts';
 import { Docx4JException } from '../../opc/exceptions.mjs';
 import { log } from './log.mjs';
 import { NumberingDefinitions } from '../listnumbering/definitions.mjs';
-import { applyPPrBase, applyRPr, applyStyle, applyStyleLevel, applyTblPr, hasDirectFormattingPPr, hasDirectFormattingRPr, isCyclic, } from './styleUtil.mjs';
+import { applyPPr, applyPPrBase, applyRPr, applyStyle, applyStyleLevel, applyTblPr, applyToggles, hasDirectFormattingPPr, hasDirectFormattingRPr, isCyclic, isEmptyStyle, } from './styleUtil.mjs';
+import { TableContext, enclosingCellOf } from './table.mjs';
 /** The cache key for "no style" (a styles part with no default paragraph style). */
 const NO_STYLE = '';
+/** An empty table style: what a table with no style to apply contributes. Shared, never changed. */
+const NO_TABLE_STYLE = Object.freeze({ TYPE_NAME: 'org_docx4j_wml.Style' });
+/** Word's compatibility mode where the document states none (docx4j `CompatibilityOptions.DEFAULT_MODE`). */
+const DEFAULT_COMPATIBILITY_MODE = 12;
+const WORD_COMPAT_URI = 'http://schemas.microsoft.com/office/word';
+/** A `w:compatSetting` of Word's own (`w:uri` its namespace), by name. */
+function wordCompatSetting(settings, name) {
+    var _a, _b;
+    return (_b = (_a = settings === null || settings === void 0 ? void 0 : settings.compat) === null || _a === void 0 ? void 0 : _a.compatSetting) === null || _b === void 0 ? void 0 : _b.find((cs) => cs.uri === WORD_COMPAT_URI && cs.name === name);
+}
+/** `compatibilityMode` (11, 12, 14 or 15); 12 where none is stated or it is unreadable. */
+function compatibilityModeOf(settings) {
+    var _a;
+    const val = (_a = wordCompatSetting(settings, 'compatibilityMode')) === null || _a === void 0 ? void 0 : _a.val;
+    if (val === undefined || val === null)
+        return DEFAULT_COMPATIBILITY_MODE;
+    const text = String(val).trim();
+    // Integer.parseInt: an optional sign and decimal digits, nothing else
+    return /^[+-]?\d+$/.test(text) ? parseInt(text, 10) : DEFAULT_COMPATIBILITY_MODE;
+}
+/** Whether a Word compat setting is stated on (docx4j `CompatibilityOptions.setting(name, false)`). */
+function compatSettingOn(settings, name) {
+    var _a;
+    const val = (_a = wordCompatSetting(settings, name)) === null || _a === void 0 ? void 0 : _a.val;
+    if (val === undefined || val === null)
+        return false;
+    const v = String(val).trim().toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+/** A two-level cache: (paragraph style, table style) and then the conditions' mask - a structured key, never a joined string. */
+class CompositionCache {
+    constructor() {
+        this.byStyle = new Map();
+    }
+    get(styleId, key) {
+        var _a, _b, _c;
+        return (_c = (_a = this.byStyle.get(styleId !== null && styleId !== void 0 ? styleId : NO_STYLE)) === null || _a === void 0 ? void 0 : _a.get((_b = key.tableStyleId) !== null && _b !== void 0 ? _b : NO_STYLE)) === null || _c === void 0 ? void 0 : _c.get(key.mask);
+    }
+    set(styleId, key, value) {
+        var _a, _b;
+        let byTable = this.byStyle.get(styleId !== null && styleId !== void 0 ? styleId : NO_STYLE);
+        if (byTable === undefined)
+            this.byStyle.set(styleId !== null && styleId !== void 0 ? styleId : NO_STYLE, byTable = new Map());
+        let byMask = byTable.get((_a = key.tableStyleId) !== null && _a !== void 0 ? _a : NO_STYLE);
+        if (byMask === undefined)
+            byTable.set((_b = key.tableStyleId) !== null && _b !== void 0 ? _b : NO_STYLE, byMask = new Map());
+        byMask.set(key.mask, value);
+    }
+    clear() {
+        this.byStyle.clear();
+    }
+}
 /** 108 twips (0.08in): the left and right cell margin of Word's built-in Normal Table. */
 export const WORD_DEFAULT_CELL_MARGIN_TWIPS = 108;
 const HEADING_NAME = /^heading ([1-9])$/i;
@@ -40,6 +93,17 @@ export class PropertyResolver {
         /** The document defaults with the chain applied over them: what the style overloads return. */
         this.effectivePPrByStyle = new Map();
         this.effectiveRPrByStyle = new Map();
+        /** Each table style's `w:basedOn` chain merged, by id; styles only, so `refresh()` clears it. */
+        this.tableStyleChains = new Map();
+        /**
+         * A paragraph style composed over a table level, document defaults included; by (paragraph
+         * style, table level). What the overloads with a context start from, as
+         * `getEffectivePPr(styleId)` is what they start from without one.
+         */
+        this.composedPPrCache = new CompositionCache();
+        this.composedRPrCache = new CompositionCache();
+        /** See {@link appliesTableStyleSizeJcException}; read once per `refresh()`. */
+        this.tableStyleSizeJcException = true;
         /** Missing styles are logged once each per resolver. */
         this.missingLogged = new Set();
         this.source = provider();
@@ -70,9 +134,19 @@ export class PropertyResolver {
         const numberingPart = main.numberingDefinitionsPart;
         const privateStyles = stylesPart === undefined ? undefined : await stylesPart.readContents();
         const privateNumbering = numberingPart === undefined ? undefined : await numberingPart.readContents();
+        // the settings are read for two compatibility values (CR-007), privately, as the others are
+        const settingsPart = main.documentSettingsPart;
+        let privateSettings;
+        try {
+            privateSettings = settingsPart === undefined ? undefined : await settingsPart.readContents();
+        }
+        catch (e) {
+            log.warn(`The settings part could not be read; taking compatibility mode ${DEFAULT_COMPATIBILITY_MODE}: ${String(e)}`);
+        }
         return new PropertyResolver(() => ({
             styles: (stylesPart === null || stylesPart === void 0 ? void 0 : stylesPart.isUnmarshalled) === true ? stylesPart.contents : privateStyles,
             numbering: (numberingPart === null || numberingPart === void 0 ? void 0 : numberingPart.isUnmarshalled) === true ? numberingPart.contents : privateNumbering,
+            settings: (settingsPart === null || settingsPart === void 0 ? void 0 : settingsPart.isUnmarshalled) === true ? settingsPart.contents : privateSettings,
         }), () => stylesPart !== undefined && !stylesPart.isUnmarshalled);
     }
     /** Builds a resolver over object trees directly (a test, or parts already in hand). */
@@ -103,6 +177,10 @@ export class PropertyResolver {
         }
         if (this.defaultParagraphStyleId === undefined)
             log.warn('No default paragraph style!!');
+        // [MS-DOCX] overrideTableStyleFontSizeAndJustification: see appliesTableStyleSizeJcException
+        const settings = this.source.settings;
+        this.tableStyleSizeJcException = compatibilityModeOf(settings) < 15
+            && !compatSettingOn(settings, 'overrideTableStyleFontSizeAndJustification');
         // private copies: the resolver's defaults are its own, so nothing below writes into the
         // styles part (until CR-015 phase 3 the w:sz 20 default went into the part, and a docx
         // saved after an export carried it)
@@ -163,6 +241,7 @@ export class PropertyResolver {
         this.chainRPrCache.clear();
         this.effectivePPrByStyle.clear();
         this.effectiveRPrByStyle.clear();
+        this.clearTableCaches();
         this.missingLogged.clear();
         this.source = this.provider();
         this.init();
@@ -304,7 +383,15 @@ export class PropertyResolver {
         }
         return styleId;
     }
-    getEffectivePPr(arg) {
+    getEffectivePPr(arg, cellContext) {
+        if (cellContext !== undefined && cellContext.formatsText && typeof arg !== 'string') {
+            const composed = this.composedPPr(this.paragraphStyleOf(arg), cellContext);
+            if (!hasDirectFormattingPPr(arg))
+                return composed;
+            const effective = deepCopy(composed);
+            this.applyPPrLayer(arg, effective);
+            return effective;
+        }
         if (arg === undefined || typeof arg === 'string')
             return this.effectivePPrOfStyle(arg);
         const resolved = this.effectivePPrOfStyle(this.paragraphStyleOf(arg));
@@ -325,9 +412,14 @@ export class PropertyResolver {
         this.effectivePPrByStyle.set(key, resolved);
         return resolved;
     }
-    getEffectiveRPr(arg, pPr) {
+    getEffectiveRPr(arg, pPr, cellContext) {
         if (typeof arg === 'string')
             return this.effectiveRPrOfStyle(arg);
+        if (cellContext !== undefined && cellContext.formatsText) {
+            const inTable = deepCopy(this.composedRPr(this.paragraphStyleOf(pPr), cellContext));
+            this.applyCharacterStyleAndDirect(arg, inTable);
+            return inTable;
+        }
         const effective = deepCopy(this.documentDefaultRPr);
         applyRPr(this.getChainRPr(this.paragraphStyleOf(pPr)), effective);
         this.applyCharacterStyleAndDirect(arg, effective);
@@ -373,7 +465,14 @@ export class PropertyResolver {
      * properties, then the `w:pPr`'s own `w:rPr`. What sizes an empty paragraph, and what a list
      * label starts from.
      */
-    getEffectiveParagraphMarkRPr(pPr) {
+    getEffectiveParagraphMarkRPr(pPr, cellContext) {
+        if (cellContext !== undefined && cellContext.formatsText) {
+            // 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);
+            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)
@@ -389,45 +488,209 @@ export class PropertyResolver {
      * The table style which applies, merged root-first down its `w:basedOn` chain, then the
      * table's own `w:tblPr` over it.
      *
-     * Word's built-in "Normal Table" (`w:tblInd` 0; cell margins 108 twips left and right, 0 top
-     * and bottom) underlies a table naming no style and a table whose chain reaches the
-     * document's default table style - and it is the built-in that applies, not the document's
-     * definition of that style (measured, CR-015 probe styles-table-default). So the default
-     * style's own layer is skipped in favour of the built-in, and a chain that does not reach it
-     * starts from nothing.
+     * Word goes by the style's **name** (measured, docx4j CR-030 probes T1, T2 and T7). A style
+     * named "Normal Table" is Word's built-in Normal Table (`w:tblInd` 0; cell margins 108 twips
+     * left and right, 0 top and bottom), whatever its own definition says and whether or not it is
+     * the document's default: the built-in stands in for it, and the walk up the chain ends there.
+     * Every other style applies as written, with nothing beneath it: a chain which reaches no style
+     * so named starts from nothing, and the document's default table style, where it is named
+     * otherwise, applies as written to a table naming no style. The built-in also stands in for a
+     * style which is missing, and where the document has no default table style. (Until CR-007 the
+     * built-in was decided by the default table style's *id*, as docx4j did until 17.3.1.)
      *
      * A new `Style` each call, with a non-null `w:tblPr`.
      */
     getEffectiveTableStyle(tblPr) {
-        var _a, _b;
-        const styleId = (_a = tblPr === null || tblPr === void 0 ? void 0 : tblPr.tblStyle) === null || _a === void 0 ? void 0 : _a.val;
-        const chain = styleId === undefined ? [] : this.ancestry(styleId);
-        const builtIn = chain.length === 0
-            || (this.defaultTableStyleId !== undefined && chain.some((s) => s.styleId === this.defaultTableStyleId));
-        const result = builtIn ? this.builtInTableNormal() : emptyTableStyle();
-        for (const layer of chain) {
-            // the built-in stands in for the document's definition of the default table style
-            if (this.defaultTableStyleId !== undefined && layer.styleId === this.defaultTableStyleId)
-                continue;
-            applyStyle(layer, result);
-        }
+        var _a;
+        const styleId = this.getTableStyleIdOf(tblPr);
+        const result = this.builtInTableNormalUnderlies(styleId) ? this.builtInTableNormal() : emptyTableStyle();
+        const chain = this.getTableStyleChain(styleId);
+        if (chain !== NO_TABLE_STYLE)
+            applyStyle(deepCopy(chain), result);
         if (tblPr !== undefined) {
             result.tblPr = applyTblPr(tblPr, result.tblPr);
         }
-        (_b = result.tblPr) !== null && _b !== void 0 ? _b : (result.tblPr = { TYPE_NAME: 'org_docx4j_wml.CTTblPrBase' });
+        (_a = result.tblPr) !== null && _a !== void 0 ? _a : (result.tblPr = { TYPE_NAME: 'org_docx4j_wml.CTTblPrBase' });
         return result;
     }
     /**
-     * Whether a table's style chain reaches the document's default table style - the flag
-     * {@link getEffectiveTableStyle} decides Word's built-in Normal Table by (a table naming no
-     * style counts as reaching it).
+     * Whether Word's built-in Normal Table underlies a table - the flag
+     * {@link getEffectiveTableStyle} decides by: the table's style chain (its own `w:tblStyle`,
+     * else the default table style) reaches a style *named* "Normal Table", or the style is
+     * missing, or there is none. Decided by name since CR-007; the method keeps docx4j's name
+     * from when it was decided by the default style's id.
      */
     reachesDefaultTableStyle(tblPr) {
-        var _a;
-        const styleId = (_a = tblPr === null || tblPr === void 0 ? void 0 : tblPr.tblStyle) === null || _a === void 0 ? void 0 : _a.val;
-        const chain = styleId === undefined ? [] : this.ancestry(styleId);
-        return chain.length === 0
-            || (this.defaultTableStyleId !== undefined && chain.some((s) => s.styleId === this.defaultTableStyleId));
+        return this.builtInTableNormalUnderlies(this.getTableStyleIdOf(tblPr));
+    }
+    builtInTableNormalUnderlies(styleId) {
+        if (styleId === undefined)
+            return true;
+        const chain = this.ancestry(styleId);
+        return chain.length === 0 || chain.some(isNamedNormalTable);
+    }
+    // ------------------------------------------------------------------ the table context (CR-007)
+    /**
+     * Whether [MS-DOCX]'s `overrideTableStyleFontSizeAndJustification` exception applies to this
+     * document: a default paragraph style's 12pt does not override the table style's size, nor its
+     * left justification the table style's, for paragraphs in tables. Measured with Word 365
+     * (docx4j CR-030 probes T5 and T6): it applies below compatibility mode 15 (a document stating
+     * no `compatibilityMode` is mode 12) where the setting is not on, and never in mode 15.
+     */
+    appliesTableStyleSizeJcException() {
+        return this.tableStyleSizeJcException;
+    }
+    /**
+     * The id of the table style a table resolves to: its own `w:tblStyle`, else the document's
+     * `w:default` table style, whatever its name; undefined where the table names none and the
+     * document has no default. (Whether that style contributes anything is
+     * {@link getTableStyleChain}'s question.)
+     */
+    getTableStyleIdOf(tblPr) {
+        return (tblPr === null || tblPr === void 0 ? void 0 : tblPr.tblStyle) !== undefined ? tblPr.tblStyle.val : this.defaultTableStyleId;
+    }
+    /**
+     * A table style's `w:basedOn` chain merged root-first, conditional formats merged per
+     * condition, as it gives the paragraphs of its tables their text formatting. Word goes by the
+     * style's *name*: a style named "Normal Table" is Word's built-in, which gives text nothing
+     * whatever its own definition says, so the walk up the chain ends below it; every other style
+     * applies as written, the default table style included.
+     *
+     * Cached per id, and shared: read it, do not change it. An empty style for undefined, for a
+     * missing style, and for a chain which is "Normal Table" all the way down.
+     */
+    getTableStyleChain(styleId) {
+        if (styleId === undefined)
+            return NO_TABLE_STYLE;
+        const cached = this.tableStyleChains.get(styleId);
+        if (cached !== undefined)
+            return cached;
+        const chain = this.ancestry(styleId);
+        let start = 0;
+        for (let i = chain.length - 1; i >= 0; i--) {
+            if (isNamedNormalTable(chain[i])) {
+                start = i + 1;
+                break;
+            }
+        }
+        let merged;
+        for (let i = start; i < chain.length; i++) {
+            const layer = chain[i];
+            // docx4j apply(Style, null): an empty layer leaves the destination as it is, null included
+            if (isEmptyStyle(layer))
+                continue;
+            merged = applyStyle(layer, merged !== null && merged !== void 0 ? merged : { TYPE_NAME: 'org_docx4j_wml.Style' });
+        }
+        const result = merged !== null && merged !== void 0 ? merged : NO_TABLE_STYLE;
+        this.tableStyleChains.set(styleId, result);
+        return result;
+    }
+    /**
+     * The context of a table, for the paragraphs in it: build one per table and hold it while
+     * walking the table (the resolver keeps none, since it reads the table's content).
+     */
+    tableContext(tbl) {
+        return new TableContext(tbl, this);
+    }
+    /**
+     * The table context of one paragraph, found through its `PARENT` pointers: the nearest
+     * enclosing cell, its row and its table, through whatever lies between (`w:sdt`,
+     * `w:customXml`, `w:smartTag`). Undefined where the paragraph is in no table, where a story
+     * begins before a cell is reached (a text box, a footnote, endnote or comment, a header, a
+     * footer, the body), or where the pointers are not there (unmarshalled content, and content
+     * the content API inserted, has them: `linkParents`).
+     *
+     * Each call builds a {@link TableContext}, a walk of the table's rows. That is right for "what
+     * formatting does this paragraph have"; code resolving every paragraph of a document walks it
+     * with a `TableContextTracker` instead, since calling this for each paragraph of a large table
+     * is quadratic.
+     */
+    cellContextOf(p) {
+        const found = enclosingCellOf(p);
+        return found === undefined ? undefined : this.tableContext(found.tbl).forParagraph(found.tr, found.tc, p.pPr);
+    }
+    clearTableCaches() {
+        this.tableStyleChains.clear();
+        this.composedPPrCache.clear();
+        this.composedRPrCache.clear();
+    }
+    /** The table level's `w:pPr`: the style's own, then its conditional formats'; undefined if none. */
+    tableLevelPPr(ctx) {
+        let out = applyPPr(ctx.tableStyle.pPr, undefined);
+        for (const pr of ctx.textConditions)
+            out = applyPPr(pr.pPr, out);
+        return out;
+    }
+    /** The table level's `w:rPr`: the style's own, then its conditional formats'; undefined if none. */
+    tableLevelRPr(ctx) {
+        let out = applyRPr(ctx.tableStyle.rPr, undefined);
+        for (const pr of ctx.textConditions)
+            out = applyRPr(pr.rPr, out);
+        return out;
+    }
+    /*
+     * The composition: document defaults, the table level over them, the paragraph style's chain
+     * over that (for the run properties a level of its own, the toggles combined), then the
+     * [MS-DOCX] exception. Cached per (paragraph style, table level).
+     */
+    composedPPr(styleId, ctx) {
+        const cached = this.composedPPrCache.get(styleId, ctx.key);
+        if (cached !== undefined)
+            return cached;
+        const tableLevel = this.tableLevelPPr(ctx);
+        const composed = deepCopy(this.documentDefaultPPr);
+        if (tableLevel !== undefined)
+            applyPPr(tableLevel, composed);
+        this.applyPPrLayer(this.getChainPPr(styleId), composed);
+        if (this.tableStyleSizeJcException && (tableLevel === null || tableLevel === void 0 ? void 0 : tableLevel.jc) !== undefined
+            && this.paragraphStyleGivesWay(styleId, false)) {
+            composed.jc = deepCopy(tableLevel.jc);
+        }
+        this.composedPPrCache.set(styleId, ctx.key, composed);
+        return composed;
+    }
+    composedRPr(styleId, ctx) {
+        const cached = this.composedRPrCache.get(styleId, ctx.key);
+        if (cached !== undefined)
+            return cached;
+        const tableOnly = this.tableLevelRPr(ctx);
+        const tableLevel = deepCopy(this.documentDefaultRPr);
+        if (tableOnly !== undefined)
+            applyRPr(tableOnly, tableLevel);
+        const paragraphLevel = this.getChainRPr(styleId);
+        const composed = deepCopy(tableLevel);
+        applyRPr(paragraphLevel, composed);
+        // 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
+            && this.paragraphStyleGivesWay(styleId, true)) {
+            composed.sz = deepCopy(tableOnly.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.
+     */
+    paragraphStyleGivesWay(styleId, size) {
+        var _a, _b, _c, _d;
+        const isDefault = styleId === undefined || styleId === this.defaultParagraphStyleId;
+        const express = this.getLiveStyle(styleId);
+        if (!isDefault && express !== undefined) {
+            if (size && ((_a = express.rPr) === null || _a === void 0 ? void 0 : _a.sz) !== undefined)
+                return false;
+            if (!size && ((_b = express.pPr) === null || _b === void 0 ? void 0 : _b.jc) !== undefined)
+                return false;
+        }
+        if (size) {
+            const effective = styleId === undefined ? undefined : this.effectiveRPrOfStyle(styleId);
+            return ((_c = effective === null || effective === void 0 ? void 0 : effective.sz) === null || _c === void 0 ? void 0 : _c.val) === 24;
+        }
+        return ((_d = this.effectivePPrOfStyle(styleId).jc) === null || _d === void 0 ? void 0 : _d.val) === 'left';
     }
     /** Word's built-in Normal Table, as a style: what it applies whatever the document's own definition says. */
     builtInTableNormal() {
@@ -502,6 +765,7 @@ export class PropertyResolver {
         this.chainRPrCache.clear();
         this.effectivePPrByStyle.clear();
         this.effectiveRPrByStyle.clear();
+        this.clearTableCaches();
         let ok = true;
         const basedOn = (_b = style.basedOn) === null || _b === void 0 ? void 0 : _b.val;
         if (basedOn !== undefined)
@@ -515,6 +779,11 @@ export class PropertyResolver {
 function twips(w) {
     return { TYPE_NAME: 'org_docx4j_wml.TblWidth', type: 'dxa', w };
 }
+/** Google Docs (Nov 2014) writes table styles without a `w:name`. */
+function isNamedNormalTable(style) {
+    var _a;
+    return ((_a = style.name) === null || _a === void 0 ? void 0 : _a.val) === 'Normal Table';
+}
 function emptyTableStyle() {
     return {
         TYPE_NAME: 'org_docx4j_wml.Style',

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

@@ -1,4 +1,7 @@
 export { type Property, type RunProps, type Merge, RUN, PARAGRAPH, TABLE, CELL, TOGGLES, TOGGLE_NAMES, IND, RUN_EXCLUDED, PARAGRAPH_EXCLUDED, TABLE_EXCLUDED, CELL_EXCLUDED, namedProperty, isEmptyOf, hasDirectFormattingOf, applyCatalogue, applyProperty, unsetCatalogue, copyLeaf, } from './catalogue.mjs';
 export * from './styleUtil.mjs';
 export { PropertyResolver, headingLevelByName, WORD_DEFAULT_CELL_MARGIN_TWIPS, type ResolverSource, } from './PropertyResolver.mjs';
+export * as TableStyleConditions from './tableStyleConditions.mjs';
+export { type Condition, type Look } from './tableStyleConditions.mjs';
+export { type TableStyleSource, type TableContextSource, CellContextKey, CellContext, TableContext, TableContextTracker, enclosingCellOf, } from './table.mjs';
 export { setLogger, type Logger } from './log.mjs';

package/dist/model/properties/index.mjs

@@ -6,4 +6,6 @@
 export { RUN, PARAGRAPH, TABLE, CELL, TOGGLES, TOGGLE_NAMES, IND, RUN_EXCLUDED, PARAGRAPH_EXCLUDED, TABLE_EXCLUDED, CELL_EXCLUDED, namedProperty, isEmptyOf, hasDirectFormattingOf, applyCatalogue, applyProperty, unsetCatalogue, copyLeaf, } from './catalogue.mjs';
 export * from './styleUtil.mjs';
 export { PropertyResolver, headingLevelByName, WORD_DEFAULT_CELL_MARGIN_TWIPS, } from './PropertyResolver.mjs';
+export * as TableStyleConditions from './tableStyleConditions.mjs';
+export { CellContextKey, CellContext, TableContext, TableContextTracker, enclosingCellOf, } from './table.mjs';
 export { setLogger } from './log.mjs';