@usejunior/docx-core 0.23.0 → 0.23.1

package/dist/primitives/styles.js

@@ -5,6 +5,49 @@ function getWAttr(el, localName) {
     // when attributes were written without a real namespace binding.
     return getAttributeSafe(el, OOXML.W_NS, localName, 'w', { emptyIsMissing: true });
 }
+function isOnValue(v) {
+    return v !== '0' && v !== 'false' && v !== 'off';
+}
+function childElements(parent, localName) {
+    const out = [];
+    for (let c = parent.firstChild; c; c = c.nextSibling) {
+        if (c.nodeType !== 1)
+            continue;
+        const el = c;
+        if (el.localName === localName && el.namespaceURI === OOXML.W_NS)
+            out.push(el);
+    }
+    return out;
+}
+/**
+ * The first direct `w:` child named `localName`. Unlike getFirstChild (a
+ * descendant search) it never reaches into a nested `w:tblPrChange` /
+ * `w:trPrChange` (the previous state) or a nested table.
+ */
+function ownChild(parent, localName) {
+    for (let c = parent.firstChild; c; c = c.nextSibling) {
+        if (c.nodeType !== 1)
+            continue;
+        const el = c;
+        if (el.localName === localName && el.namespaceURI === OOXML.W_NS)
+            return el;
+    }
+    return null;
+}
+/**
+ * A table-style `w:rPr` without its `w:rPrChange`, which records the
+ * previous state of a tracked formatting change. The property readers search
+ * descendants, so the change record would otherwise read as current. The
+ * copy is detached and only ever read.
+ */
+function currentRPr(rPr) {
+    if (!rPr || !ownChild(rPr, 'rPrChange'))
+        return rPr;
+    const copy = rPr.cloneNode(true);
+    for (const change of childElements(copy, 'rPrChange'))
+        copy.removeChild(change);
+    return copy;
+}
 const THEME_COLOR_ELEMENT_BY_REFERENCE = {
     dark1: 'dk1',
     light1: 'lt1',
@@ -78,11 +121,12 @@ export function parseThemeXml(themeDoc) {
 export function parseStylesXml(stylesDoc) {
     const byId = new Map();
     if (!stylesDoc)
-        return { byId, docDefaultsRPr: null, tableStyleRPrs: [] };
+        return { byId, docDefaultsRPr: null, defaultTableStyleId: null, tableStyleRPrs: [] };
     const docDefaults = stylesDoc.getElementsByTagNameNS(OOXML.W_NS, W.docDefaults).item(0);
     const rPrDefault = docDefaults ? getFirstChild(docDefaults, OOXML.W_NS, W.rPrDefault) : null;
     const docDefaultsRPr = rPrDefault ? getFirstChild(rPrDefault, OOXML.W_NS, W.rPr) : null;
     const tableStyleRPrs = [];
+    let defaultTableStyleId = null;
     const styles = Array.from(stylesDoc.getElementsByTagNameNS(OOXML.W_NS, W.style));
     for (const st of styles) {
         const id = getWAttr(st, 'styleId');
@@ -90,30 +134,48 @@ export function parseStylesXml(stylesDoc) {
             continue;
         const nameEl = getFirstChild(st, OOXML.W_NS, W.name);
         const basedOnEl = getFirstChild(st, OOXML.W_NS, W.basedOn);
-        const pPr = getFirstChild(st, OOXML.W_NS, W.pPr);
-        const rPr = getFirstChild(st, OOXML.W_NS, W.rPr);
+        const styleType = getWAttr(st, 'type');
+        // getFirstChild searches descendants. A table style nests further pPr /
+        // rPr / tblPr inside each w:tblStylePr, so its own properties must be read
+        // from direct children, or a style without its own rPr would take the
+        // first conditional's as if it applied to the whole table.
+        const styleChild = (localName) => styleType === 'table' ? ownChild(st, localName) : getFirstChild(st, OOXML.W_NS, localName);
+        const pPr = styleChild(W.pPr);
+        const rPr = styleChild(W.rPr);
         const name = nameEl ? (getWAttr(nameEl, 'val') ?? id) : id;
         const basedOn = basedOnEl ? (getWAttr(basedOnEl, 'val') ?? null) : null;
-        const styleType = getWAttr(st, 'type');
-        if (styleType === 'table') {
-            if (rPr)
-                tableStyleRPrs.push(rPr);
-            for (const conditional of Array.from(st.getElementsByTagNameNS(OOXML.W_NS, 'tblStylePr'))) {
-                const conditionalRPr = getFirstChild(conditional, OOXML.W_NS, W.rPr);
-                if (conditionalRPr)
-                    tableStyleRPrs.push(conditionalRPr);
-            }
-        }
-        byId.set(id, {
+        const def = {
             styleId: id,
             styleType,
             name,
             basedOn,
             pPr: pPr ?? null,
-            rPr: rPr ?? null,
-        });
+            rPr: (styleType === 'table' ? currentRPr(rPr) : rPr) ?? null,
+        };
+        if (styleType === 'table') {
+            if (def.rPr)
+                tableStyleRPrs.push(def.rPr);
+            const conditionalRPrs = new Map();
+            for (const conditional of childElements(st, 'tblStylePr')) {
+                const type = getWAttr(conditional, 'type');
+                const conditionalRPr = currentRPr(ownChild(conditional, W.rPr));
+                if (!conditionalRPr)
+                    continue;
+                tableStyleRPrs.push(conditionalRPr);
+                // The first block of a type wins, matching getFirstChild elsewhere.
+                if (type && !conditionalRPrs.has(type))
+                    conditionalRPrs.set(type, conditionalRPr);
+            }
+            def.tblPr = styleChild(W.tblPr);
+            def.conditionalRPrs = conditionalRPrs;
+            const isDefault = getWAttr(st, 'default');
+            // The last default style of a type wins (§ 17.7.4.17).
+            if (isDefault !== null && isOnValue(isDefault))
+                defaultTableStyleId = id;
+        }
+        byId.set(id, def);
     }
-    return { byId, docDefaultsRPr: docDefaultsRPr ?? null, tableStyleRPrs };
+    return { byId, docDefaultsRPr: docDefaultsRPr ?? null, defaultTableStyleId, tableStyleRPrs };
 }
 function resolveStyleChain(model, styleId) {
     const chain = [];
@@ -251,46 +313,310 @@ function parseBoolProp(parent, tagLocal) {
  * @see https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oi29500/f7130225-2368-48f3-acae-a9d278d0fb25
  * @see https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oe376/f936abaf-a9cb-439b-923d-7f688d9202e9
  */
-function resolveToggleProperty(steps, tagLocal, unreadLayerTurnsOn) {
+function resolveToggleProperty(steps, tagLocal) {
     let effective = false;
-    // Once a direct step sets an absolute value, the base the hierarchy started
-    // from no longer affects the result.
-    let absolute = false;
-    for (const { rPr, kind } of steps) {
-        const declaration = parseBoolProp(rPr, tagLocal);
+    for (const { rPr, declare, kind } of steps) {
+        const declaration = declare ? declare(tagLocal) : parseBoolProp(rPr ?? null, tagLocal);
         if (declaration === null)
             continue;
-        if (kind === 'default') {
-            // The seed sits below every unread layer (table styles), so it does not
-            // make the result absolute.
-            effective = declaration;
+        // A table style resets the toggle to its declared value (Word; see the
+        // MS-OI29500 note on § 17.7.6), like the default and direct levels.
+        if (kind === 'style') {
+            if (declaration)
+                effective = !effective;
         }
-        else if (kind === 'direct') {
+        else {
             effective = declaration;
-            absolute = true;
-        }
-        else if (declaration) {
-            effective = !effective;
         }
     }
-    // The walk starts from the document default (or `false`, the OOXML
-    // default). Table styles sit between that seed and the paragraph style and
-    // are not read, so a table style that turns the toggle on leaves the result
-    // depending on a layer the resolver does not read.
-    if (absolute || !unreadLayerTurnsOn)
-        return effective;
-    return null;
+    return effective;
+}
+/**
+ * Conditional formatting types (ST_TblStyleOverrideType, § 17.18.89) in the
+ * order Word applies them; each later type overrides the ones before it.
+ * `wholeTable` is not among them: Word neither applies nor keeps a
+ * `wholeTable` conditional (MS-OI29500 note on § 17.18.89), and the style's
+ * own `w:rPr` is the whole-table formatting.
+ *
+ * ECMA-376 § 17.7.6 lists whole table, column bands, row bands, first/last
+ * row, first/last column, then the corner cells. Microsoft's implementation
+ * note for § 17.7.6.6 records that Office instead applies row bands, column
+ * bands, first/last column, first/last row, then the corners. This follows
+ * Office, the renderer whose output the resolver is meant to report.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.7.6
+ * @see https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oi29500/2ac331d4-cf1e-4fa0-8bca-6da74411e284
+ */
+const CONDITIONAL_ORDER = [
+    'band1Horz',
+    'band2Horz',
+    'band1Vert',
+    'band2Vert',
+    'firstCol',
+    'lastCol',
+    'firstRow',
+    'lastRow',
+    'nwCell',
+    'neCell',
+    'swCell',
+    'seCell',
+];
+const WORD_DEFAULT_TABLE_LOOK = 0x04a0;
+function tableLookFromBits(bits) {
+    return {
+        firstRow: (bits & 0x0020) !== 0,
+        lastRow: (bits & 0x0040) !== 0,
+        firstColumn: (bits & 0x0080) !== 0,
+        lastColumn: (bits & 0x0100) !== 0,
+        hBand: (bits & 0x0200) === 0,
+        vBand: (bits & 0x0400) === 0,
+    };
 }
-function isInsideTable(node) {
+/**
+ * Read `w:tblLook`. The explicit attributes win; the transitional `w:val`
+ * hex bitmask is read only when none of them is present (0x0020 first row,
+ * 0x0040 last row, 0x0080 first column, 0x0100 last column, 0x0200 no
+ * horizontal banding, 0x0400 no vertical banding). An absent attribute is
+ * off.
+ *
+ * When the table has no `w:tblLook`, the standard assumes 0x0000 but Word
+ * assumes 0x04A0 (first row, first column, no vertical banding); this
+ * follows Word, the renderer whose output the resolver reports.
+ *
+ * @see https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oi29500/90f075ce-b16d-422a-b1b0-39c9777a594e
+ */
+function parseTableLook(el) {
+    if (!el)
+        return tableLookFromBits(WORD_DEFAULT_TABLE_LOOK);
+    const named = ['firstRow', 'lastRow', 'firstColumn', 'lastColumn', 'noHBand', 'noVBand'].map((a) => getWAttr(el, a));
+    if (named.some((v) => v !== null)) {
+        const on = (v) => v !== null && isOnValue(v);
+        const [firstRow, lastRow, firstColumn, lastColumn, noHBand, noVBand] = named;
+        return {
+            firstRow: on(firstRow),
+            lastRow: on(lastRow),
+            firstColumn: on(firstColumn),
+            lastColumn: on(lastColumn),
+            hBand: !on(noHBand),
+            vBand: !on(noVBand),
+        };
+    }
+    const raw = getWAttr(el, 'val');
+    return tableLookFromBits(raw && /^[0-9A-Fa-f]{1,4}$/u.test(raw) ? Number.parseInt(raw, 16) : 0);
+}
+function nearestAncestor(node, localName, stopAt = null) {
     for (let cur = node.parentNode; cur; cur = cur.parentNode) {
         if (cur.nodeType !== 1)
             continue;
         const el = cur;
-        if (el.localName === W.tbl && el.namespaceURI === OOXML.W_NS)
-            return true;
+        if (el.namespaceURI !== OOXML.W_NS)
+            continue;
+        if (el.localName === localName)
+            return el;
+        if (stopAt && el.localName === stopAt)
+            return null;
+    }
+    return null;
+}
+/**
+ * Visit the `w:tr` rows of a table (or `w:tc` cells of a row) in document
+ * order, or in reverse with `fromEnd`, looking through the content-control
+ * and custom-XML wrappers that may enclose them. Stops early when `visit`
+ * returns true.
+ */
+function walkTableChildren(parent, localName, visit, fromEnd = false) {
+    for (let c = fromEnd ? parent.lastChild : parent.firstChild; c; c = fromEnd ? c.previousSibling : c.nextSibling) {
+        if (c.nodeType !== 1 || c.namespaceURI !== OOXML.W_NS)
+            continue;
+        const child = c;
+        if (child.localName === localName) {
+            if (visit(child))
+                return true;
+        }
+        else if (child.localName === 'sdt') {
+            const content = ownChild(child, 'sdtContent');
+            if (content && walkTableChildren(content, localName, visit, fromEnd))
+                return true;
+        }
+        else if (child.localName === 'customXml') {
+            if (walkTableChildren(child, localName, visit, fromEnd))
+                return true;
+        }
     }
     return false;
 }
+function edgeTableChild(parent, localName, fromEnd) {
+    let found = null;
+    walkTableChildren(parent, localName, (el) => {
+        found = el;
+        return true;
+    }, fromEnd);
+    return found;
+}
+function tableChildIndex(parent, localName, target) {
+    let index = 0;
+    let found = -1;
+    walkTableChildren(parent, localName, (el) => {
+        if (el === target) {
+            found = index;
+            return true;
+        }
+        index++;
+        return false;
+    });
+    return found;
+}
+function intVal(parent, localName, fallback) {
+    const el = parent ? ownChild(parent, localName) : null;
+    const v = el ? Number.parseInt(getWAttr(el, 'val') ?? '', 10) : Number.NaN;
+    return Number.isSafeInteger(v) && v >= 0 ? v : fallback;
+}
+function bandSize(sources, localName) {
+    for (const tblPr of sources) {
+        const v = intVal(tblPr, localName, 0);
+        if (v > 0)
+            return v;
+    }
+    return 1;
+}
+/**
+ * The cell's span of table grid columns. A row's `w:gridBefore` skips grid
+ * columns before its first cell (§ 17.4.15) and each cell covers
+ * `w:gridSpan` columns, so the first physical cell is not always the first
+ * column. The grid width is the table's `w:tblGrid`, or the row's own extent
+ * when the table has none.
+ */
+function cellGridSpan(tbl, tr, tc) {
+    const trPr = ownChild(tr, W.trPr);
+    let col = intVal(trPr, 'gridBefore', 0);
+    let start = -1;
+    let end = -1;
+    walkTableChildren(tr, 'tc', (cell) => {
+        const span = Math.max(1, intVal(ownChild(cell, W.tcPr), 'gridSpan', 1));
+        if (cell === tc) {
+            start = col;
+            end = col + span;
+        }
+        col += span;
+    });
+    const grid = ownChild(tbl, W.tblGrid);
+    const gridCols = grid ? childElements(grid, 'gridCol').length : 0;
+    const gridCount = gridCols > 0 ? gridCols : col + intVal(trPr, 'gridAfter', 0);
+    return { start, end, gridCount };
+}
+/**
+ * Which conditional types apply to a cell, given the `w:tblLook` in force
+ * for its row. Corner types need both of their edges switched on (MS-OI29500
+ * note on § 17.7.6). Banding counts rows (grid columns) after the header row
+ * (first column) when that is switched on, in groups of
+ * `w:tblStyleRowBandSize` (`w:tblStyleColBandSize`). `rowBandsUsed` skips
+ * the row-index walk when the style has no row-band conditional.
+ */
+function applicableConditionals(pos, look, rowBandsUsed) {
+    const out = new Set();
+    const isFirstCol = pos.colStart === 0;
+    if (look.hBand && rowBandsUsed) {
+        const idx = pos.rowIndex() - (look.firstRow ? 1 : 0);
+        if (idx >= 0)
+            out.add(Math.floor(idx / pos.rowBandSize) % 2 === 0 ? 'band1Horz' : 'band2Horz');
+    }
+    if (look.vBand) {
+        const idx = pos.colStart - (look.firstColumn ? 1 : 0);
+        if (idx >= 0)
+            out.add(Math.floor(idx / pos.colBandSize) % 2 === 0 ? 'band1Vert' : 'band2Vert');
+    }
+    if (look.firstColumn && isFirstCol)
+        out.add('firstCol');
+    if (look.lastColumn && pos.isLastCol)
+        out.add('lastCol');
+    if (look.firstRow && pos.isFirstRow)
+        out.add('firstRow');
+    if (look.lastRow && pos.isLastRow)
+        out.add('lastRow');
+    if (look.firstRow && look.firstColumn && pos.isFirstRow && isFirstCol)
+        out.add('nwCell');
+    if (look.firstRow && look.lastColumn && pos.isFirstRow && pos.isLastCol)
+        out.add('neCell');
+    if (look.lastRow && look.firstColumn && pos.isLastRow && isFirstCol)
+        out.add('swCell');
+    if (look.lastRow && look.lastColumn && pos.isLastRow && pos.isLastCol)
+        out.add('seCell');
+    return out;
+}
+/**
+ * The table-style `w:rPr` layers for one set of applicable conditionals,
+ * highest precedence first: the applied conditional types from last to first
+ * in {@link CONDITIONAL_ORDER}, then the style's own `w:rPr`. Within each,
+ * the derived style precedes its `basedOn` ancestors.
+ *
+ * @see https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oi29500/3359ff85-c423-4b9d-be78-d1cf96f79486
+ */
+function tableStyleLayers(chain, applied) {
+    const layers = [];
+    const types = [...CONDITIONAL_ORDER].filter((t) => applied.has(t)).reverse();
+    for (const type of types) {
+        for (const style of chain) {
+            const rPr = style.conditionalRPrs?.get(type);
+            if (rPr)
+                layers.push(rPr);
+        }
+    }
+    for (const style of chain)
+        if (style.rPr)
+            layers.push(style.rPr);
+    return layers;
+}
+/**
+ * The table-style layers for a run, highest precedence first (see
+ * {@link tableStyleLayers}); empty when the run is not in a table or the
+ * table has no style.
+ *
+ * The table style is the table's `w:tblStyle`, or the default table style
+ * when it names none (or names one that does not exist). The innermost
+ * table governs a run in a nested table. Which conditionals apply is
+ * computed from the cell's position and the table's `w:tblLook`. The
+ * `w:cnfStyle` elements on paragraphs, rows and cells are not consulted: the
+ * standard describes them as an optimization that records the outcome, and
+ * the position and `w:tblLook` determine it.
+ *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.7.2
+ * @conformance ECMA-376 edition 5, Part 1 § 17.7.6
+ * @see https://github.com/UseJunior/safe-docx/issues/1159
+ */
+function tableStyleLayersForRun(run, styles) {
+    const tc = nearestAncestor(run, W.tc, W.tbl);
+    const tr = tc ? nearestAncestor(tc, W.tr, W.tbl) : null;
+    const tbl = tr ? nearestAncestor(tr, W.tbl) : null;
+    if (!tc || !tr || !tbl)
+        return [];
+    // Direct children only: a nested w:tblPrChange holds the previous state.
+    const tblPr = ownChild(tbl, W.tblPr);
+    const tblStyleEl = tblPr ? ownChild(tblPr, 'tblStyle') : null;
+    const named = tblStyleEl ? getWAttr(tblStyleEl, 'val') : null;
+    const styleId = named && styles.byId.get(named)?.styleType === 'table' ? named : (styles.defaultTableStyleId ?? null);
+    const chain = resolveStyleChain(styles, styleId).filter((st) => st.styleType === 'table');
+    if (chain.length === 0)
+        return [];
+    if (!chain.some((st) => st.conditionalRPrs && st.conditionalRPrs.size > 0)) {
+        return tableStyleLayers(chain, new Set());
+    }
+    // A row's w:tblPrEx/w:tblLook overrides the table's for that row (§ 17.4.54).
+    const tblPrEx = ownChild(tr, 'tblPrEx');
+    const lookEl = (tblPrEx ? ownChild(tblPrEx, 'tblLook') : null) ?? (tblPr ? ownChild(tblPr, 'tblLook') : null);
+    const bandSources = [tblPr, ...chain.map((st) => st.tblPr ?? null)];
+    const { start, end, gridCount } = cellGridSpan(tbl, tr, tc);
+    const pos = {
+        isFirstRow: edgeTableChild(tbl, 'tr', false) === tr,
+        isLastRow: edgeTableChild(tbl, 'tr', true) === tr,
+        rowIndex: () => tableChildIndex(tbl, 'tr', tr),
+        colStart: start,
+        isLastCol: end === gridCount,
+        rowBandSize: bandSize(bandSources, 'tblStyleRowBandSize'),
+        colBandSize: bandSize(bandSources, 'tblStyleColBandSize'),
+    };
+    const rowBandsUsed = chain.some((st) => st.conditionalRPrs?.has('band1Horz') || st.conditionalRPrs?.has('band2Horz'));
+    return tableStyleLayers(chain, applicableConditionals(pos, parseTableLook(lookEl), rowBandsUsed));
+}
 function parseUnderline(parent) {
     if (!parent)
         return null;
@@ -425,8 +751,9 @@ function parseEffectiveHighlightVal(parent) {
  * the run declares. Ordinary properties are taken from the first layer that
  * specifies them: direct `w:rPr` on the run, then the `w:rStyle`
  * character-style `basedOn` chain, then the paragraph mark's `w:rPr` inside
- * `pPr`, then the paragraph style's `basedOn` chain, and finally the
- * document defaults (`w:docDefaults/w:rPrDefault/w:rPr`).
+ * `pPr`, then the paragraph style's `basedOn` chain, then — for a run inside
+ * a table — the table style, and finally the document defaults
+ * (`w:docDefaults/w:rPrDefault/w:rPr`).
  *
  * Each property is resolved independently down the chain — a style that
  * specifies only color does not mask an ancestor's bold.
@@ -441,14 +768,21 @@ function parseEffectiveHighlightVal(parent) {
  * Document defaults seed toggle evaluation as an absolute base value rather
  * than acting as another parity level (see {@link resolveToggleProperty}).
  *
- * Not read: table-style run properties. For a run inside a table, when a
- * property is declared nowhere above the document defaults and a table style
- * declares a value that would change it (for a toggle: turns it on), the
- * result is `null` (unresolved) rather than a guess; when no layer declares it
- * at all, the result is the OOXML default (see {@link RunFormatting}). A
- * toggle that a direct layer sets absolutely is resolved regardless of table
- * styles. Numbering-level `rPr` formats only the list label (`w:lvlText`),
- * never the paragraph's runs, so it is out of scope.
+ * Table styles (#1159): the table context is read from the run's ancestors —
+ * the innermost `w:tbl`, its `w:tblStyle` (or the default table style), the
+ * `basedOn` chain, `w:tblLook`, and the cell's row and column. The style's
+ * `w:rPr` and every conditional `w:tblStylePr/w:rPr` that applies to the
+ * cell merge into one layer between the document defaults and the paragraph
+ * style (see {@link tableStyleLayers} for the order). For toggles the
+ * merged layer's nearest declaration resets the value rather than toggling
+ * it: the standard says a table style toggles like any other style, but Word
+ * assigns the declared value (MS-OI29500 note on § 17.7.6), and this follows
+ * Word.
+ *
+ * @see https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oi29500/14452bbe-be4d-4dbb-90e6-3d23ae9361bc
+ *
+ * Numbering-level `rPr` formats only the list label (`w:lvlText`), never the
+ * paragraph's runs, so it is out of scope.
  *
  * Part of docx-core's public surface (see `src/index.ts`) so external
  * diagnostics — `scripts/check_docx_formatting_loss.mjs` today, the planned
@@ -463,11 +797,14 @@ function parseEffectiveHighlightVal(parent) {
  * @param params.theme the model produced by {@link parseThemeXml}; when
  *   omitted, direct font/color fallbacks retain their previous behavior
  *
+ * @conformance ECMA-376 edition 5, Part 1 § 17.7.2
  * @conformance ECMA-376 edition 5, Part 1 § 17.7.3
  * @conformance ECMA-376 edition 5, Part 1 § 17.7.5.1
+ * @conformance ECMA-376 edition 5, Part 1 § 17.7.6
  * @see https://github.com/UseJunior/safe-docx/issues/737
  * @see https://github.com/UseJunior/safe-docx/issues/752
  * @see https://github.com/UseJunior/safe-docx/issues/753
+ * @see https://github.com/UseJunior/safe-docx/issues/1159
  */
 export function extractEffectiveRunFormatting(params) {
     const { run, paragraphPPr, paragraphStyleId, styles, theme = null } = params;
@@ -480,11 +817,12 @@ export function extractEffectiveRunFormatting(params) {
     const rStyleChain = resolveStyleChain(styles, rStyleId);
     const paragraphStyleChain = resolveStyleChain(styles, paragraphStyleId);
     // Priority: direct rPr → rStyle chain rPrs → paragraph mark rPr → paragraph
-    // style chain rPrs → document defaults. Each property resolves
-    // independently down this list: a chain member that specifies only color
-    // must not mask an ancestor's bold, so the sources are the individual rPr
-    // containers, never "the first chain member that has an rPr" (peer review
-    // on #684; extractStyleRunFormatting above already resolved per property).
+    // style chain rPrs → table style (when in a table) → document defaults.
+    // Each property resolves independently down this list: a chain member that
+    // specifies only color must not mask an ancestor's bold, so the sources are
+    // the individual rPr containers, never "the first chain member that has an
+    // rPr" (peer review on #684; extractStyleRunFormatting above already
+    // resolved per property).
     const sourcesAboveDefaults = [
         rPr,
         ...rStyleChain.map((s) => s.rPr),
@@ -492,48 +830,33 @@ export function extractEffectiveRunFormatting(params) {
         ...paragraphStyleChain.map((s) => s.rPr),
     ];
     const docDefaultsRPr = styles.docDefaultsRPr ?? null;
-    // Apply from the document defaults through the least specific style
-    // ancestor to direct run formatting. Paragraph-mark rPr is direct
-    // formatting at its hierarchy level; a character style can still contribute
-    // above it before the run's own rPr supplies the final absolute override.
+    const tableLayers = tableStyleLayersForRun(run, styles);
+    // Apply from the document defaults through the table style and the least
+    // specific paragraph-style ancestor to direct run formatting.
+    // Paragraph-mark rPr is direct formatting at its hierarchy level; a
+    // character style can still contribute above it before the run's own rPr
+    // supplies the final absolute override.
     const toggleSteps = [
         { rPr: docDefaultsRPr, kind: 'default' },
+        {
+            declare: (tagLocal) => firstNonNull(tableLayers.map((layer) => parseBoolProp(layer, tagLocal))),
+            kind: 'table',
+        },
         ...[...paragraphStyleChain].reverse().map((style) => ({ rPr: style.rPr, kind: 'style' })),
         { rPr: pRPr, kind: 'direct' },
         ...[...rStyleChain].reverse().map((style) => ({ rPr: style.rPr, kind: 'style' })),
         { rPr, kind: 'direct' },
     ];
-    // Table styles are the one layer this resolver does not read. They sit
-    // between the document defaults and the paragraph style, so for a property
-    // declared nowhere above the document defaults, a table-style declaration
-    // that differs from the base below it makes the property unresolved. A
-    // declaration that restates that base cannot change the outcome.
-    const tableLayers = styles.tableStyleRPrs && styles.tableStyleRPrs.length > 0 && isInsideTable(run)
-        ? styles.tableStyleRPrs
-        : [];
-    const toggle = (tagLocal) => resolveToggleProperty(toggleSteps, tagLocal, tableLayers.some((layer) => parseBoolProp(layer, tagLocal) === true));
+    const toggle = (tagLocal) => resolveToggleProperty(toggleSteps, tagLocal);
+    const sources = [...sourcesAboveDefaults, ...tableLayers];
     /**
-     * Nearest declaration above the document defaults; otherwise the document
-     * default, otherwise `ooxmlDefault` (`null` for a property with no OOXML
-     * default), unless an unread table style could change that base.
+     * Nearest declaration above the document defaults (table style
+     * included); otherwise the document default, otherwise `ooxmlDefault`
+     * (`null` for a property with no OOXML default).
      */
-    // Hex colours and font names compare case-insensitively: `abcdef` restates
-    // `ABCDEF`.
-    const sameValue = (a, b) => typeof a === 'string' && typeof b === 'string' ? a.toUpperCase() === b.toUpperCase() : a === b;
     const resolveLayered = (parse, ooxmlDefault) => {
-        const above = firstNonNull(sourcesAboveDefaults.map(parse));
-        if (above === DECLARED_UNRESOLVED)
-            return null;
-        if (above !== null)
-            return above;
-        const base = parse(docDefaultsRPr) ?? ooxmlDefault;
-        if (tableLayers.some((layer) => {
-            const declared = parse(layer);
-            return declared !== null && !sameValue(declared, base);
-        })) {
-            return null;
-        }
-        return base === DECLARED_UNRESOLVED ? null : base;
+        const value = firstNonNull(sources.map(parse)) ?? parse(docDefaultsRPr) ?? ooxmlDefault;
+        return value === DECLARED_UNRESOLVED ? null : value;
     };
     return {
         bold: toggle(W.b),