@cj-tech-master/excelts 9.6.1 → 10.0.0

package/dist/browser/modules/word/layout/layout-full.js

@@ -14,9 +14,10 @@
  * guard — adding a new body variant without a matching layout function
  * is a build error, never a silent drop.
  */
-import { measureTextWidth, mapToStandardFont } from "../../../utils/font-metrics.js";
+import { measureTextWidth, mapToStandardFont, styledFontVariant } from "../../../utils/font-metrics.js";
 import { ommlToMathML } from "../advanced/math-convert.js";
 import { extractMathText, isHyperlink, isRun } from "../core/text-utils.js";
+import { resolveStyle } from "../query/style-resolve.js";
 import { EMU_PER_POINT } from "../units.js";
 import { layoutDocument } from "./layout.js";
 import { DEFAULT_PAGE_HEIGHT_TWIPS, DEFAULT_PAGE_MARGIN_TWIPS, DEFAULT_PAGE_WIDTH_TWIPS } from "./layout-constants.js";
@@ -30,6 +31,33 @@ import { DEFAULT_PAGE_HEIGHT_TWIPS, DEFAULT_PAGE_MARGIN_TWIPS, DEFAULT_PAGE_WIDT
 export function layoutDocumentFull(doc, options) {
     // First pass: get page assignments via the existing lightweight layout
     const layoutResult = layoutDocument(doc, options);
+    // Resolve list markers once over the whole document so ordered-list
+    // counters increment correctly across pages. Stored in a module-level
+    // context so that every `layoutParagraph` call — including those reached
+    // through tables, text boxes, SDTs, footnotes, etc. — can render markers
+    // without threading the map through every container function. Layout runs
+    // fully synchronously (no `await`), so a single shared slot is safe.
+    const listMarkers = computeListMarkers(doc);
+    activeListMarkers = listMarkers;
+    activeDoc = doc;
+    try {
+        return layoutDocumentFullInner(doc, options, layoutResult, listMarkers);
+    }
+    finally {
+        activeListMarkers = undefined;
+        activeDoc = undefined;
+    }
+}
+/** Active list-marker map for the in-flight layout (see layoutDocumentFull). */
+let activeListMarkers;
+/**
+ * Active document for the in-flight layout, so `layoutParagraph` can resolve
+ * paragraph-style run properties (size/color/font) via `resolveStyle` without
+ * threading `doc` through every container function. Layout is synchronous so a
+ * single shared slot is safe.
+ */
+let activeDoc;
+function layoutDocumentFullInner(doc, options, layoutResult, listMarkers) {
     // Second pass: compute precise positions for each page. Footnote
     // ids that don't fit on a given page are carried over to the next
     // (a later page may still have room thanks to less body content
@@ -38,7 +66,7 @@ export function layoutDocumentFull(doc, options) {
     const bodyPageCount = layoutResult.pageCount;
     let pendingFootnoteIds = [];
     for (let pageNum = 1; pageNum <= bodyPageCount; pageNum++) {
-        const result = buildPage(doc, pageNum, layoutResult, options, pendingFootnoteIds);
+        const result = buildPage(doc, pageNum, layoutResult, options, pendingFootnoteIds, listMarkers);
         pages.push(result.page);
         pendingFootnoteIds = result.deferredFootnoteIds;
     }
@@ -52,7 +80,7 @@ export function layoutDocumentFull(doc, options) {
         // entries for already-placed body items still point at earlier
         // pages, so the synthetic page won't pick up extra body
         // content; only the carried footnote queue renders.
-        layoutResult, options, pendingFootnoteIds);
+        layoutResult, options, pendingFootnoteIds, listMarkers);
         pages.push(overflowResult.page);
     }
     return {
@@ -170,7 +198,7 @@ function availableSlotForLine(ctx, lineY, lineHeight) {
 function twipsToPt(twips) {
     return twips / 20;
 }
-function buildPage(doc, pageNumber, layout, options, pendingFootnoteIds) {
+function buildPage(doc, pageNumber, layout, options, pendingFootnoteIds, listMarkers) {
     const sectionProps = doc.sectionProperties;
     const geometry = computePageGeometry(sectionProps, options?.pageGeometry);
     const content = [];
@@ -205,7 +233,7 @@ function buildPage(doc, pageNumber, layout, options, pendingFootnoteIds) {
         };
         switch (item.type) {
             case "paragraph": {
-                const laid = layoutParagraph(item, cursorY, geometry.contentWidth, options, pageContext, imageMap);
+                const laid = layoutParagraph(item, cursorY, geometry.contentWidth, options, pageContext, imageMap, listMarkers);
                 content.push({ ...laid, sourceIndex: i });
                 cursorY = laid.rect.y + laid.rect.height;
                 break;
@@ -698,13 +726,219 @@ function computeSectionBreaks(layout) {
     }
     return breaks;
 }
-// =============================================================================
-// Internal: Paragraph Layout
-// =============================================================================
-function layoutParagraph(para, startY, contentWidth, options, pageContext, imageMap) {
+/**
+ * Resolve list markers for every numbered / bulleted paragraph in the
+ * document, in reading order, so ordered-list counters increment correctly
+ * across paragraphs (and reset when a lower level reappears). Returns a map
+ * keyed by the paragraph object.
+ *
+ * Markers are derived from `paragraph.properties.numbering` → the matching
+ * `NumberingInstance` → its `AbstractNumbering` level definition. Bullet
+ * levels emit their symbol; ordered levels emit a counter formatted per the
+ * level's `NumberFormat` (decimal / lower-upper letter / lower-upper roman),
+ * falling back to decimal for formats we don't render numerically.
+ */
+function computeListMarkers(doc) {
+    const markers = new Map();
+    const instances = doc.numberingInstances;
+    const abstracts = doc.abstractNumberings;
+    if (!instances || !abstracts || instances.length === 0 || abstracts.length === 0) {
+        return markers;
+    }
+    const instById = new Map(instances.map(n => [n.numId, n]));
+    const absById = new Map(abstracts.map(a => [a.abstractNumId, a]));
+    // Per (numId) counters, one slot per level. Counters reset at deeper
+    // levels when a shallower level advances.
+    const counters = new Map();
+    // numIds whose list was interrupted by non-list content since their last
+    // item; the next item with that numId restarts its numbering. This makes
+    // two visually separate ordered lists (sharing a numId, separated by a
+    // plain paragraph) each start at 1 — matching user expectation rather than
+    // running a single continuous sequence.
+    const interrupted = new Set();
+    // numIds seen at least once, so we know which to mark interrupted.
+    const seenNumIds = new Set();
+    // Flatten paragraphs into document reading order (descending into tables),
+    // so list continuity is judged across the whole body, not per-cell.
+    const orderedParagraphs = [];
+    const walk = (items) => {
+        for (const item of items) {
+            if (item.type === "paragraph") {
+                orderedParagraphs.push(item);
+            }
+            else if (item.type === "table") {
+                for (const row of item.rows) {
+                    for (const cell of row.cells) {
+                        walk(cell.content);
+                    }
+                }
+            }
+        }
+    };
+    const resolveParagraphMarker = (para) => {
+        const numbering = para.properties?.numbering;
+        if (!numbering) {
+            // Non-list paragraph: any list seen so far is now interrupted, so a
+            // later paragraph reusing the same numId restarts its sequence.
+            for (const id of seenNumIds) {
+                interrupted.add(id);
+            }
+            return;
+        }
+        const inst = instById.get(numbering.numId);
+        if (!inst) {
+            return;
+        }
+        const abs = absById.get(inst.abstractNumId);
+        if (!abs) {
+            return;
+        }
+        const level = numbering.level ?? 0;
+        const levelDef = inst.overrides?.find(o => o.level === level)?.levelDef ??
+            abs.levels.find(l => l.level === level);
+        if (!levelDef) {
+            return;
+        }
+        seenNumIds.add(numbering.numId);
+        const indentPt = (level + 1) * 36; // 0.5" per level
+        if (levelDef.format === "bullet") {
+            // Bullet symbol. Word authors bullets with Symbol/Wingdings private-use
+            // code points (e.g. U+F0B7 ·, U+F0A7 ▪) that PDF standard fonts can't
+            // render. Normalize the common ones to WinAnsi-renderable equivalents;
+            // fall back to a round bullet when empty or unknown.
+            const symbol = normalizeBulletGlyph(levelDef.text);
+            markers.set(para, { text: `${symbol}  `, indentPt });
+            // A bullet item does not clear the interruption flag for ordered
+            // siblings, but it is itself a list item — keep it out of `interrupted`.
+            interrupted.delete(numbering.numId);
+            return;
+        }
+        // Ordered list: advance this level's counter and reset deeper levels.
+        let levelCounts = counters.get(numbering.numId);
+        if (!levelCounts) {
+            levelCounts = [];
+            counters.set(numbering.numId, levelCounts);
+        }
+        // If this numId's run was interrupted by non-list content, restart it.
+        if (interrupted.has(numbering.numId)) {
+            levelCounts.length = 0;
+            interrupted.delete(numbering.numId);
+        }
+        const startOverride = inst.overrides?.find(o => o.level === level)?.startOverride;
+        const start = startOverride ?? levelDef.start ?? 1;
+        if (levelCounts[level] === undefined) {
+            levelCounts[level] = start;
+        }
+        else {
+            levelCounts[level] += 1;
+        }
+        // Reset any deeper levels.
+        for (let l = level + 1; l < levelCounts.length; l++) {
+            levelCounts[l] = undefined;
+        }
+        const counter = levelCounts[level];
+        const numeral = formatListCounter(counter, levelDef.format);
+        // Honour the level's `text` template (e.g. "%1.") when present; else
+        // fall back to "<n>.".
+        const text = levelDef.text ? levelDef.text.replace(/%\d+/g, numeral) : `${numeral}.`;
+        markers.set(para, { text: `${text}  `, indentPt });
+    };
+    walk(doc.body);
+    for (const para of orderedParagraphs) {
+        resolveParagraphMarker(para);
+    }
+    return markers;
+}
+/** Normalize a Word bullet glyph to a WinAnsi-renderable equivalent. */
+function normalizeBulletGlyph(text) {
+    if (!text || text.length === 0) {
+        return "\u2022"; // round bullet
+    }
+    const cp = text.codePointAt(0);
+    switch (cp) {
+        // Symbol-font private-use code points Word emits for default bullets.
+        case 0xf0b7: // Symbol "·" → round bullet
+        case 0x00b7: // middle dot
+            return "\u2022";
+        case 0xf0a7: // Symbol filled small square
+        case 0xf0a8:
+            return "\u25aa";
+        case 0xf0fc: // Wingdings check
+            return "\u2713";
+        default:
+            // Already a renderable glyph (e.g. "o", "-", "•") — keep it.
+            return text;
+    }
+}
+/** Format an ordered-list counter per its OOXML number format. */
+function formatListCounter(n, format) {
+    switch (format) {
+        case "lowerLetter":
+            return toAlpha(n).toLowerCase();
+        case "upperLetter":
+            return toAlpha(n).toUpperCase();
+        case "lowerRoman":
+            return toRoman(n).toLowerCase();
+        case "upperRoman":
+            return toRoman(n).toUpperCase();
+        case "decimalZero":
+            return n < 10 ? `0${n}` : String(n);
+        default:
+            // decimal and any non-numeric/locale formats we don't render.
+            return String(n);
+    }
+}
+/** 1 → "A", 26 → "Z", 27 → "AA" (spreadsheet-style alpha). */
+function toAlpha(n) {
+    let s = "";
+    let v = n;
+    while (v > 0) {
+        const rem = (v - 1) % 26;
+        s = String.fromCharCode(65 + rem) + s;
+        v = Math.floor((v - 1) / 26);
+    }
+    return s || "A";
+}
+/** Convert a positive integer to a Roman numeral (uppercase). */
+function toRoman(n) {
+    if (n <= 0) {
+        return String(n);
+    }
+    const table = [
+        [1000, "M"],
+        [900, "CM"],
+        [500, "D"],
+        [400, "CD"],
+        [100, "C"],
+        [90, "XC"],
+        [50, "L"],
+        [40, "XL"],
+        [10, "X"],
+        [9, "IX"],
+        [5, "V"],
+        [4, "IV"],
+        [1, "I"]
+    ];
+    let v = n;
+    let s = "";
+    for (const [val, sym] of table) {
+        while (v >= val) {
+            s += sym;
+            v -= val;
+        }
+    }
+    return s;
+}
+function layoutParagraph(para, startY, contentWidth, options, pageContext, imageMap, listMarkers) {
     const props = para.properties;
     const spacing = props?.spacing;
-    const headingScale = getHeadingFontScale(getHeadingLevel(props));
+    // Resolve effective run properties from the paragraph's style chain. When
+    // the style supplies a concrete font size we honour it; only when it does
+    // not do we fall back to the heuristic heading scale so headings stay
+    // distinct in documents lacking a styles table.
+    const styleRunProps = activeDoc ? resolveStyle(activeDoc, para).runProperties : undefined;
+    const styleHasSize = styleRunProps?.size != null;
+    const headingScale = styleHasSize ? 1 : getHeadingFontScale(getHeadingLevel(props));
     // Space before
     let spaceBefore = 0;
     if (spacing?.beforeAutoSpacing) {
@@ -714,7 +948,15 @@ function layoutParagraph(para, startY, contentWidth, options, pageContext, image
         spaceBefore = twipsToPt(spacing.before);
     }
     const indent = props?.indent;
-    const leftIndentPt = indent?.left ? twipsToPt(indent.left) : 0;
+    // Prefer an explicitly threaded map; fall back to the active layout's
+    // shared map so list markers also render inside tables, text boxes, SDTs,
+    // footnotes, etc. (whose layoutParagraph calls don't thread it through).
+    const marker = (listMarkers ?? activeListMarkers)?.get(para);
+    // List paragraphs are indented by their numbering level; the marker text
+    // is injected as a leading run below. An explicit paragraph indent (rare on
+    // list items) still wins when larger.
+    const markerIndentPt = marker ? marker.indentPt : 0;
+    const leftIndentPt = Math.max(indent?.left ? twipsToPt(indent.left) : 0, markerIndentPt);
     const firstLineIndentPt = indent?.firstLine ? twipsToPt(indent.firstLine) : 0;
     const alignment = props?.alignment ?? "left";
     // Line height
@@ -735,7 +977,20 @@ function layoutParagraph(para, startY, contentWidth, options, pageContext, image
     }
     lineHeightPt *= headingScale;
     // Collect runs
-    const segments = collectParagraphSegments(para);
+    const segments = mergeStyleRunProps(collectParagraphSegments(para), styleRunProps);
+    // Inject the list marker (bullet / number) as a leading text run so it
+    // renders inline at the start of the first line, inheriting the first
+    // text run's formatting (font / size) for visual consistency.
+    if (marker) {
+        let firstRunProps;
+        for (const s of segments) {
+            if (!("type" in s) || s.type === undefined) {
+                firstRunProps = s.properties;
+                break;
+            }
+        }
+        segments.unshift({ text: marker.text, properties: firstRunProps });
+    }
     const fullAvailableWidth = contentWidth - leftIndentPt;
     // When a page has wrap exclusions (square / tight / through floats)
     // we wrap line-by-line, asking the page context for the widest free
@@ -784,7 +1039,7 @@ function layoutParagraph(para, startY, contentWidth, options, pageContext, image
             }
             else {
                 const fontSize = getRunFontSizePt(seg.properties) * headingScale;
-                const fontName = mapToStandardFont(resolveRunFontName(seg.properties));
+                const fontName = styledFontVariant(resolveRunFontName(seg.properties), seg.properties?.bold, seg.properties?.italic);
                 lineWidth += measureTextWidth(seg.text, fontName, fontSize);
             }
         }
@@ -815,7 +1070,7 @@ function layoutParagraph(para, startY, contentWidth, options, pageContext, image
             }
             const fontSize = getRunFontSizePt(seg.properties) * headingScale;
             const fontName = resolveRunFontName(seg.properties);
-            const measuredFont = mapToStandardFont(fontName);
+            const measuredFont = styledFontVariant(fontName, seg.properties?.bold, seg.properties?.italic);
             const segWidth = measureTextWidth(seg.text, measuredFont, fontSize);
             runs.push({
                 text: seg.text,
@@ -933,7 +1188,8 @@ function layoutTable(table, startY, contentWidth, sourceIndex, options, imageMap
                 rect: { x: cellX, y: startY + cursorY, width: cellWidth, height: cellHeight },
                 row: ri,
                 col: ci,
-                content: cellContent
+                content: cellContent,
+                borders: resolveCellBorders(table.properties?.borders, cell.properties?.borders, ri === 0, ri === table.rows.length - 1, startCol === 0, endCol >= colWidths.length)
             });
             gridCol += span;
         }
@@ -952,6 +1208,38 @@ function layoutTable(table, startY, contentWidth, sourceIndex, options, imageMap
         sourceIndex
     };
 }
+/**
+ * Resolve the four visible borders of a table cell into layout-model form
+ * (`{ width: pt, color: hex }`). A cell's own border wins; otherwise the
+ * table-level border applies — outer edges use `top/left/bottom/right`, inner
+ * edges use `insideH/insideV`. OOXML border `size` is in eighths of a point.
+ */
+function resolveCellBorders(tableBorders, cellBorders, isTopRow, isBottomRow, isLeftCol, isRightCol) {
+    const edge = (cellEdge, outerEdge, innerEdge, isOuter) => {
+        const b = cellEdge ?? (isOuter ? outerEdge : innerEdge);
+        if (!b || b.style === "none" || b.style === "nil") {
+            return undefined;
+        }
+        // `size` is in eighths of a point; default to a hairline (0.5pt) when
+        // a border is declared without an explicit size.
+        const width = b.size != null ? b.size / 8 : 0.5;
+        const color = !b.color || b.color === "auto" ? "000000" : b.color;
+        return { width: Math.max(0.25, width), color };
+    };
+    const top = edge(cellBorders?.top, tableBorders?.top, tableBorders?.insideH, isTopRow);
+    const bottom = edge(cellBorders?.bottom, tableBorders?.bottom, tableBorders?.insideH, isBottomRow);
+    const left = edge(cellBorders?.left, tableBorders?.left, tableBorders?.insideV, isLeftCol);
+    const right = edge(cellBorders?.right, tableBorders?.right, tableBorders?.insideV, isRightCol);
+    if (!top && !bottom && !left && !right) {
+        return undefined;
+    }
+    return {
+        ...(top ? { top } : {}),
+        ...(bottom ? { bottom } : {}),
+        ...(left ? { left } : {}),
+        ...(right ? { right } : {})
+    };
+}
 /**
  * Resolve a table's per-column widths in points.
  *
@@ -1001,6 +1289,21 @@ function collectParagraphSegments(para) {
     }
     return segments;
 }
+/**
+ * Overlay resolved paragraph-style run properties under each segment's own
+ * (inline) properties, so style-defined size/color/font apply when a run does
+ * not override them. Inline run properties always win.
+ */
+function mergeStyleRunProps(segments, styleRunProps) {
+    if (!styleRunProps) {
+        return segments;
+    }
+    return segments.map(seg => {
+        const own = seg.properties;
+        const merged = own ? { ...styleRunProps, ...own } : styleRunProps;
+        return { ...seg, properties: merged };
+    });
+}
 /**
  * Emit `ParagraphSegment` tokens for a single run, preserving the
  * relative order of text fragments and inline images. Consecutive
@@ -1056,7 +1359,7 @@ function wrapSegmentsToLinesWithExclusions(segments, leftIndentPt, firstLineInde
             continue;
         }
         const fontSize = getRunFontSizePt(seg.properties) * headingScale;
-        const fontName = mapToStandardFont(resolveRunFontName(seg.properties));
+        const fontName = styledFontVariant(resolveRunFontName(seg.properties), seg.properties?.bold, seg.properties?.italic);
         // Split on runs of whitespace, keeping the whitespace tokens so
         // wrapping can decide whether to drop trailing space at line end.
         const tokens = seg.text.split(/(\s+)/);
@@ -1211,14 +1514,18 @@ function wrapSegmentsToLines(segments, availableWidth, firstLineIndent, headingS
         }
         const text = segment.text;
         const fontSize = getRunFontSizePt(segment.properties) * headingScale;
-        const fontName = mapToStandardFont(resolveRunFontName(segment.properties));
+        const fontName = styledFontVariant(resolveRunFontName(segment.properties), segment.properties?.bold, segment.properties?.italic);
         const segmentWidth = measureTextWidth(text, fontName, fontSize);
-        if (currentLineWidth + segmentWidth <= effectiveWidth || currentLine.length === 0) {
+        if (currentLineWidth + segmentWidth <= effectiveWidth) {
+            // Whole segment fits on the current line — fast path.
             currentLine.push(segment);
             currentLineWidth += segmentWidth;
         }
         else {
-            // Word-level splitting
+            // Segment does not fit — split it into words and wrap. The inner
+            // loop's `currentLine.length === 0 && bufferedText.length === 0`
+            // guard guarantees at least one word per line (preventing a dead
+            // loop when even a single word is wider than the line).
             const words = text.split(/(\s+)/);
             let bufferedText = "";
             let bufferedWidth = 0;

package/dist/browser/modules/word/layout/render-page.js

@@ -10,6 +10,7 @@
 import { measureTextWidth, mapToStandardFont } from "../../../utils/font-metrics.js";
 import { xmlEncode, xmlEncodeAttr } from "../../xml/encode.js";
 import { isHyperlink, isRun } from "../core/text-utils.js";
+import { resolveStyle } from "../query/style-resolve.js";
 import { EMU_PER_POINT } from "../units.js";
 import { layoutDocument } from "./layout.js";
 import { DEFAULT_PAGE_HEIGHT_TWIPS, DEFAULT_PAGE_MARGIN_TWIPS, DEFAULT_PAGE_WIDTH_TWIPS } from "./layout-constants.js";
@@ -189,7 +190,18 @@ function renderParagraph(para, state) {
     const props = para.properties;
     const spacing = props?.spacing;
     const headingLevel = getHeadingLevel(props);
-    const headingScale = getHeadingFontScale(headingLevel);
+    // Resolve the paragraph's effective run properties from the style chain
+    // (Heading1 → … → docDefaults). When the style provides a concrete font
+    // size we honour it directly; only when no style size is available do we
+    // fall back to the heuristic heading scale so headings still look distinct
+    // in documents that lack a styles table.
+    const styleRunProps = resolveStyle(state.doc, para).runProperties;
+    const styleHasSize = styleRunProps.size != null;
+    const fallbackScale = getHeadingFontScale(headingLevel);
+    const headingScale = styleHasSize ? 1 : fallbackScale;
+    // Synthesise bold for headings only in fallback mode (no real style size);
+    // otherwise the style's own bold flag governs.
+    const synthesizeHeadingBold = headingLevel > 0 && !styleHasSize;
     // Space before
     let spaceBefore = 0;
     if (spacing?.beforeAutoSpacing) {
@@ -231,7 +243,7 @@ function renderParagraph(para, state) {
     // Apply heading scale to line height
     lineHeightPt *= headingScale;
     // Collect runs and render as text spans on lines
-    const runs = collectParagraphRuns(para);
+    const runs = collectParagraphRuns(para, styleRunProps);
     if (runs.length === 0) {
         // Empty paragraph — advance by line height
         state.cursorY += lineHeightPt;
@@ -261,7 +273,7 @@ function renderParagraph(para, state) {
             for (const segment of line) {
                 const fontSize = getRunFontSizePt(segment.properties) * headingScale;
                 const fontFamily = resolveFontFamily(getRunFontName({ properties: segment.properties, content: [] }), state.fontsMap);
-                const isBold = segment.properties?.bold || headingLevel > 0;
+                const isBold = segment.properties?.bold || synthesizeHeadingBold;
                 const isItalic = segment.properties?.italic;
                 const color = resolveColor(segment.properties?.color);
                 const underline = segment.properties?.underline;
@@ -313,20 +325,32 @@ function renderParagraph(para, state) {
     state.cursorY += spaceAfter;
 }
 /** Collect all text segments from a paragraph's children. */
-function collectParagraphRuns(para) {
+function collectParagraphRuns(para, styleRunProps) {
+    // Merge the resolved paragraph-style run properties as a fallback under each
+    // run's own (inline) properties, so style-defined size/color/font apply when
+    // the run does not override them.
+    const merge = (own) => {
+        if (!styleRunProps) {
+            return own;
+        }
+        if (!own) {
+            return styleRunProps;
+        }
+        return { ...styleRunProps, ...own };
+    };
     const segments = [];
     for (const child of para.children) {
         if (isRun(child)) {
             const text = getRunText(child);
             if (text.length > 0) {
-                segments.push({ text, properties: child.properties });
+                segments.push({ text, properties: merge(child.properties) });
             }
         }
         else if (isHyperlink(child)) {
             for (const run of child.children) {
                 const text = getRunText(run);
                 if (text.length > 0) {
-                    segments.push({ text, properties: run.properties });
+                    segments.push({ text, properties: merge(run.properties) });
                 }
             }
         }
@@ -518,8 +542,11 @@ function renderTable(table, state) {
             let cellCursorY = rowStartY + cellPadding;
             for (const content of cell.content) {
                 if (content.type === "paragraph") {
-                    // Simplified: render first run of each paragraph
-                    const runs = collectParagraphRuns(content);
+                    // Simplified: render first run of each paragraph, with the
+                    // paragraph style's run properties as a fallback so styled cell
+                    // text (e.g. a heading paragraph) honours its size/colour/font.
+                    const cellStyleRunProps = resolveStyle(state.doc, content).runProperties;
+                    const runs = collectParagraphRuns(content, cellStyleRunProps);
                     if (runs.length > 0) {
                         const allText = runs.map(r => r.text).join("");
                         const firstRun = runs[0];

package/dist/browser/modules/word/markdown.d.ts

@@ -11,4 +11,4 @@
  * ```
  */
 export { renderToMarkdown, markdownToDocx, markdownToDocxBody } from "./convert/markdown/markdown.js";
-export type { MarkdownRenderOptions, MarkdownImportOptions, MarkdownImageData } from "./convert/markdown/markdown.js";
+export type { MarkdownRenderOptions, MarkdownImportOptions, MarkdownImageData, MarkdownBodyResult } from "./convert/markdown/markdown.js";

package/dist/browser/modules/word/query/compat.d.ts

@@ -9,8 +9,12 @@ export type CompatibilityMode = 11 | 12 | 14 | 15;
 /**
  * Get the compatibility mode of a document.
  *
- * Looks at the `compatSetting` named "compatibilityMode" in document settings.
- * Returns 15 (Word 2013+) by default if not found.
+ * The mode is stored in `settings.compatibilityMode` (the canonical scalar
+ * field populated by the reader). For backward compatibility we also honour an
+ * explicit `compatibilityMode` entry in `settings.compatSettings` if present,
+ * since the writer accepts that advanced-override path.
+ *
+ * Returns 15 (Word 2013+) by default if nothing is stored.
  *
  * @param doc - The document to inspect.
  * @returns The compatibility mode version number.
@@ -19,6 +23,10 @@ export declare function getCompatibilityMode(doc: DocxDocument): CompatibilityMo
 /**
  * Set the compatibility mode of a document (mutates settings in place).
  *
+ * Writes the canonical `settings.compatibilityMode` scalar field and removes
+ * any stale `compatibilityMode` override entry from `settings.compatSettings`
+ * so the two sources never disagree.
+ *
  * @param doc - The document to modify (mutated in place).
  * @param mode - The target compatibility mode (11=Word 2003, 12=Word 2007, 14=Word 2010, 15=Word 2013+).
  */

package/dist/browser/modules/word/query/compat.js

@@ -10,21 +10,29 @@ import {} from "../core/internal-utils.js";
 /**
  * Get the compatibility mode of a document.
  *
- * Looks at the `compatSetting` named "compatibilityMode" in document settings.
- * Returns 15 (Word 2013+) by default if not found.
+ * The mode is stored in `settings.compatibilityMode` (the canonical scalar
+ * field populated by the reader). For backward compatibility we also honour an
+ * explicit `compatibilityMode` entry in `settings.compatSettings` if present,
+ * since the writer accepts that advanced-override path.
+ *
+ * Returns 15 (Word 2013+) by default if nothing is stored.
  *
  * @param doc - The document to inspect.
  * @returns The compatibility mode version number.
  */
 export function getCompatibilityMode(doc) {
-    if (!doc.settings?.compatSettings) {
+    const settings = doc.settings;
+    if (!settings) {
         return 15;
     }
-    const modeSetting = doc.settings.compatSettings.find(s => s.name === "compatibilityMode");
-    if (!modeSetting?.val) {
+    // Prefer an explicit override entry in compatSettings (advanced path) so a
+    // hand-authored value wins, then fall back to the canonical scalar field.
+    const overrideEntry = settings.compatSettings?.find(s => s.name === "compatibilityMode");
+    const raw = overrideEntry?.val ?? settings.compatibilityMode;
+    if (raw === undefined) {
         return 15;
     }
-    const n = parseInt(modeSetting.val, 10);
+    const n = typeof raw === "number" ? raw : parseInt(raw, 10);
     if (n === 11 || n === 12 || n === 14 || n === 15) {
         return n;
     }
@@ -33,26 +41,26 @@ export function getCompatibilityMode(doc) {
 /**
  * Set the compatibility mode of a document (mutates settings in place).
  *
+ * Writes the canonical `settings.compatibilityMode` scalar field and removes
+ * any stale `compatibilityMode` override entry from `settings.compatSettings`
+ * so the two sources never disagree.
+ *
  * @param doc - The document to modify (mutated in place).
  * @param mode - The target compatibility mode (11=Word 2003, 12=Word 2007, 14=Word 2010, 15=Word 2013+).
  */
 export function setCompatibilityMode(doc, mode) {
     const settings = doc.settings ? { ...doc.settings } : {};
-    const compatSettings = settings.compatSettings
-        ? [...settings.compatSettings]
-        : [];
-    const idx = compatSettings.findIndex(s => s.name === "compatibilityMode");
-    const entry = {
-        name: "compatibilityMode",
-        uri: "http://schemas.microsoft.com/office/word",
-        val: String(mode)
-    };
-    if (idx >= 0) {
-        compatSettings[idx] = entry;
-    }
-    else {
-        compatSettings.push(entry);
+    settings.compatibilityMode = mode;
+    // Drop any stale override entry so getCompatibilityMode/writer don't read a
+    // conflicting value from the array. The scalar field is now authoritative.
+    if (settings.compatSettings) {
+        const filtered = settings.compatSettings.filter(s => s.name !== "compatibilityMode");
+        if (filtered.length > 0) {
+            settings.compatSettings = filtered;
+        }
+        else {
+            delete settings.compatSettings;
+        }
     }
-    settings.compatSettings = compatSettings;
     doc.settings = settings;
 }