@usejunior/docx-core 0.22.1 → 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,7 +121,12 @@ export function parseThemeXml(themeDoc) {
 export function parseStylesXml(stylesDoc) {
     const byId = new Map();
     if (!stylesDoc)
-        return { byId };
+        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');
@@ -86,20 +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;
-        byId.set(id, {
+        const def = {
             styleId: id,
-            styleType: getWAttr(st, 'type'),
+            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 };
+    return { byId, docDefaultsRPr: docDefaultsRPr ?? null, defaultTableStyleId, tableStyleRPrs };
 }
 function resolveStyleChain(model, styleId) {
     const chain = [];
@@ -219,28 +295,328 @@ function parseBoolProp(parent, tagLocal) {
     return true;
 }
 /**
- * Evaluate a toggle property in hierarchy order. Style-level true values
- * invert the accumulated state while style-level false values preserve it;
- * direct formatting sets an absolute value.
+ * Evaluate a toggle property in hierarchy order. Document defaults seed the
+ * starting value; style-level true values invert the accumulated state while
+ * style-level false values preserve it; direct formatting sets an absolute
+ * value.
+ *
+ * Microsoft's ISO/IEC 29500 implementation note for §17.7.3 says Word falls
+ * back to the document defaults when a hierarchy level supplies no value and
+ * treats the document-default value as the base for subsequent parity.
+ * MS-OE376 §2.7.7 documents a separate Word deviation for paragraph styles but
+ * does not make `w:docDefaults` another toggling style level. So defaults seed
+ * the state rather than invert it.
  *
  * @conformance ECMA-376 edition 5, Part 1 § 17.7.3
  * @see https://github.com/UseJunior/safe-docx/issues/737
+ * @see https://github.com/UseJunior/safe-docx/issues/753
+ * @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) {
     let effective = 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 === 'direct') {
-            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 (declaration) {
-            effective = !effective;
+        else {
+            effective = declaration;
         }
     }
     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,
+    };
+}
+/**
+ * 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.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;
@@ -324,13 +700,60 @@ function parseHighlightVal(parent) {
         return null;
     return v;
 }
+/**
+ * Marks a layer that *does* declare a property whose value cannot be
+ * established — a theme colour or theme font with no theme to resolve it
+ * against. Resolution stops at that layer (a lower layer must not show
+ * through) and the property is reported as unresolved.
+ */
+const DECLARED_UNRESOLVED = Symbol('declared-unresolved');
+/**
+ * `'auto'` for a declared automatic colour, the hex otherwise, `null` if
+ * undeclared, {@link DECLARED_UNRESOLVED} for a theme colour reference that
+ * resolves neither through the theme nor through an explicit hex `w:val`.
+ */
+function parseEffectiveColorHex(parent, theme) {
+    if (!parent)
+        return null;
+    const el = getFirstChild(parent, OOXML.W_NS, W.color);
+    if (!el)
+        return null;
+    const hex = parseColorHex(parent, theme);
+    if (hex !== null)
+        return hex;
+    return getWAttr(el, 'themeColor') ? DECLARED_UNRESOLVED : 'auto';
+}
+/**
+ * The font name, `null` if `w:rFonts` names none, or {@link DECLARED_UNRESOLVED}
+ * when it names the Latin font only through a theme reference that does not
+ * resolve and carries no explicit `w:ascii` / `w:hAnsi` fallback.
+ */
+function parseEffectiveFontName(parent, theme) {
+    const name = parseFontName(parent, theme);
+    if (name !== null || !parent)
+        return name;
+    const el = getFirstChild(parent, OOXML.W_NS, W.rFonts);
+    if (!el)
+        return null;
+    return getWAttr(el, 'asciiTheme') || getWAttr(el, 'hAnsiTheme') ? DECLARED_UNRESOLVED : null;
+}
+/** `false` for a declared `none`, the value otherwise, `null` if undeclared. */
+function parseEffectiveHighlightVal(parent) {
+    if (!parent)
+        return null;
+    const el = getFirstChild(parent, OOXML.W_NS, W.highlight);
+    if (!el)
+        return null;
+    return parseHighlightVal(parent) ?? false;
+}
 /**
  * Resolve the run formatting a reader actually sees, not merely the formatting
  * 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. A property specified
- * nowhere resolves to the neutral value (`false`, `''`, `0`, or `null`).
+ * `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.
@@ -342,9 +765,24 @@ function parseHighlightVal(parent) {
  * `w:caps`, `w:smallCaps`, `w:strike`, `w:emboss`, `w:imprint`, `w:outline`,
  * `w:shadow`, and `w:vanish`.
  *
- * Not resolved: `w:docDefaults`, table-style run properties, and
- * numbering-level `rPr`. A formatting change confined to one of those layers
- * is invisible to this resolver.
+ * Document defaults seed toggle evaluation as an absolute base value rather
+ * than acting as another parity level (see {@link resolveToggleProperty}).
+ *
+ * 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
@@ -359,8 +797,14 @@ function parseHighlightVal(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;
@@ -373,44 +817,90 @@ 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. 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 sources = [
+    // 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),
         pRPr,
         ...paragraphStyleChain.map((s) => s.rPr),
     ];
-    const resolve = (parse) => firstNonNull(sources.map(parse));
-    // Apply from the least specific style ancestor to direct run formatting.
+    const docDefaultsRPr = styles.docDefaultsRPr ?? null;
+    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' },
     ];
+    const toggle = (tagLocal) => resolveToggleProperty(toggleSteps, tagLocal);
+    const sources = [...sourcesAboveDefaults, ...tableLayers];
+    /**
+     * Nearest declaration above the document defaults (table style
+     * included); otherwise the document default, otherwise `ooxmlDefault`
+     * (`null` for a property with no OOXML default).
+     */
+    const resolveLayered = (parse, ooxmlDefault) => {
+        const value = firstNonNull(sources.map(parse)) ?? parse(docDefaultsRPr) ?? ooxmlDefault;
+        return value === DECLARED_UNRESOLVED ? null : value;
+    };
+    return {
+        bold: toggle(W.b),
+        italic: toggle(W.i),
+        caps: toggle(W.caps),
+        smallCaps: toggle(W.smallCaps),
+        strike: toggle(W.strike),
+        emboss: toggle(W.emboss),
+        imprint: toggle(W.imprint),
+        outline: toggle(W.outline),
+        shadow: toggle(W.shadow),
+        vanish: toggle(W.vanish),
+        underline: resolveLayered(parseUnderline, false),
+        highlightVal: resolveLayered(parseEffectiveHighlightVal, false),
+        // No OOXML default: the rendered font and size are application-defined
+        // when nothing declares them, so an undeclared value stays unresolved.
+        fontName: resolveLayered((el) => parseEffectiveFontName(el, theme), null),
+        fontSizePt: resolveLayered(parseFontSizePt, null),
+        colorHex: resolveLayered((el) => parseEffectiveColorHex(el, theme), 'auto'),
+    };
+}
+/**
+ * Effective run formatting for annotation bodies (comments, footnotes), whose
+ * `tagged_text` is emitted in `full` mode and read back by docx-markdoc.
+ * Toggles, underline and highlight resolve through every layer, document
+ * defaults included. Colour, size and font are reported only when a layer
+ * above `w:docDefaults` declares them, otherwise as not declared (`'auto'` /
+ * `null`), so the inherited document font is not tagged as `face` on every run
+ * and a direct value that restates the document default is still emitted
+ * over a character style that would otherwise show through on import.
+ *
+ * @see https://github.com/UseJunior/safe-docx/issues/753
+ */
+export function extractAnnotationRunFormatting(params) {
+    const effective = extractEffectiveRunFormatting(params);
+    const declared = extractEffectiveRunFormatting({
+        ...params,
+        styles: { ...params.styles, docDefaultsRPr: null },
+    });
     return {
-        bold: resolveToggleProperty(toggleSteps, W.b),
-        italic: resolveToggleProperty(toggleSteps, W.i),
-        caps: resolveToggleProperty(toggleSteps, W.caps),
-        smallCaps: resolveToggleProperty(toggleSteps, W.smallCaps),
-        strike: resolveToggleProperty(toggleSteps, W.strike),
-        emboss: resolveToggleProperty(toggleSteps, W.emboss),
-        imprint: resolveToggleProperty(toggleSteps, W.imprint),
-        outline: resolveToggleProperty(toggleSteps, W.outline),
-        shadow: resolveToggleProperty(toggleSteps, W.shadow),
-        vanish: resolveToggleProperty(toggleSteps, W.vanish),
-        underline: resolve(parseUnderline) ?? false,
-        highlightVal: resolve(parseHighlightVal),
-        fontName: resolve((el) => parseFontName(el, theme)) ?? '',
-        fontSizePt: resolve(parseFontSizePt) ?? 0,
-        colorHex: resolve((el) => parseColorHex(el, theme)),
+        ...effective,
+        colorHex: declared.colorHex,
+        fontSizePt: declared.fontSizePt,
+        fontName: declared.fontName,
     };
 }
 //# sourceMappingURL=styles.js.map