reamkit 1.16.0 → 1.17.0

package/dist/esm/core/numbering/state.js

@@ -1,11 +1,37 @@
 //#region src/core/numbering/state.ts
 /**
+* §17.9.27 — the levels an INSTANCE actually numbers by: its abstract
+* definition's, with any `w:lvlOverride/w:lvl` shadowing them. Cached per
+* instance, since every list paragraph asks for it.
+*
+* @param numbering The parsed numbering definitions.
+* @param instance  The `w:num` the paragraph refers to.
+* @returns The effective abstract numbering, or `undefined` when the instance
+*          names one that is not there.
+*/
+function effectiveAbstract(numbering, instance) {
+	const base = numbering.abstractNums.get(instance.abstractNumId);
+	if (!base || !instance.levelOverrides || instance.levelOverrides.size === 0) return base;
+	const hit = effectiveCache.get(instance);
+	if (hit) return hit;
+	const levels = new Map(base.levels);
+	for (const [ilvl, lvl] of instance.levelOverrides) levels.set(ilvl, lvl);
+	const merged = {
+		id: base.id,
+		levels
+	};
+	effectiveCache.set(instance, merged);
+	return merged;
+}
+var effectiveCache = /* @__PURE__ */ new WeakMap();
+/**
 * Mutable list-counter state for one numbering scope (e.g. a body or a single
 * header/footer band). Tracks a counter per list per level and advances them as
 * paragraphs are visited in order.
 */
 var NumberingState = class {
 	counters = /* @__PURE__ */ new Map();
+	restarted = /* @__PURE__ */ new Set();
 	/**
 	* Advance the counter for `ref` (resetting deeper levels) and format its
 	* marker text. The first hit at a level seeds it from the level's `start`;
@@ -19,19 +45,27 @@ var NumberingState = class {
 	resolveMarker(numbering, ref) {
 		const instance = numbering.numInstances.get(ref.numId);
 		if (!instance) return null;
-		const abstractNum = numbering.abstractNums.get(instance.abstractNumId);
+		const abstractNum = effectiveAbstract(numbering, instance);
 		if (!abstractNum) return null;
 		const level = abstractNum.levels.get(ref.ilvl);
 		if (!level) return null;
-		let arr = this.counters.get(ref.numId);
+		let arr = this.counters.get(instance.abstractNumId);
 		if (!arr) {
-			arr = new Array(9).fill(0);
-			this.counters.set(ref.numId, arr);
+			arr = new Array(9).fill(void 0);
+			this.counters.set(instance.abstractNumId, arr);
+		}
+		for (let k = ref.ilvl + 1; k < arr.length; k++) arr[k] = void 0;
+		const startAt = (i, fallback) => instance.startOverrides?.get(i) ?? fallback ?? 0;
+		const restartKey = `${ref.numId}:${String(ref.ilvl)}`;
+		const override = instance.startOverrides?.get(ref.ilvl);
+		if (override !== void 0 && !this.restarted.has(restartKey)) {
+			this.restarted.add(restartKey);
+			arr[ref.ilvl] = override;
+		} else {
+			const current = arr[ref.ilvl];
+			arr[ref.ilvl] = current === void 0 ? startAt(ref.ilvl, level.start) : current + 1;
 		}
-		for (let k = ref.ilvl + 1; k < arr.length; k++) arr[k] = 0;
-		if (arr[ref.ilvl] === 0) arr[ref.ilvl] = level.start;
-		else arr[ref.ilvl] += 1;
-		return formatLevelMarker(abstractNum, level, arr);
+		return formatLevelMarker(abstractNum, level, arr.map((n, i) => n ?? startAt(i, abstractNum.levels.get(i)?.start)));
 	}
 };
 function formatLevelMarker(abstractNum, currentLevel, counters) {
@@ -40,20 +74,227 @@ function formatLevelMarker(abstractNum, currentLevel, counters) {
 		const lvlIdx = Number(n) - 1;
 		const level = abstractNum.levels.get(lvlIdx);
 		const counter = counters[lvlIdx] ?? 0;
-		return formatCounter(level?.format ?? "decimal", counter);
+		return formatCounter(currentLevel.isLegal === true && lvlIdx !== currentLevel.ilvl ? "decimal" : level?.format ?? "decimal", counter);
 	});
 }
 function formatCounter(format, n) {
-	if (n <= 0) return "";
+	if (n < 0) return "";
 	switch (format) {
 		case "decimal": return String(n);
-		case "lowerLetter": return toLetters(n).toLowerCase();
-		case "upperLetter": return toLetters(n);
-		case "lowerRoman": return toRoman(n).toLowerCase();
-		case "upperRoman": return toRoman(n);
+		case "decimalZero": return n < 10 ? `0${String(n)}` : String(n);
+		case "decimalFullWidth": return digitByDigit(n, FULL_WIDTH_DIGITS);
+		case "ordinal": return `${String(n)}${ordinalSuffix(n)}`;
+		case "lowerLetter": return n === 0 ? "" : toLetters(n).toLowerCase();
+		case "upperLetter": return n === 0 ? "" : toLetters(n);
+		case "lowerRoman": return n === 0 ? "" : toRoman(n).toLowerCase();
+		case "upperRoman": return n === 0 ? "" : toRoman(n);
+		case "ideographTraditional": return n === 0 ? "" : n <= HEAVENLY_STEMS.length ? HEAVENLY_STEMS[n - 1] : String(n);
+		case "ideographZodiac": return n === 0 ? "" : n <= EARTHLY_BRANCHES.length ? EARTHLY_BRANCHES[n - 1] : String(n);
+		case "ideographDigital":
+		case "koreanDigital2": return digitByDigit(n, IDEOGRAPH_DIGITS);
+		case "ideographLegalTraditional": return counting(n, LEGAL_DIGITS, LEGAL_UNITS, false);
+		case "chineseCounting":
+		case "chineseCountingThousand":
+		case "japaneseCounting":
+		case "koreanCounting":
+		case "taiwaneseCounting":
+		case "taiwaneseCountingThousand": return counting(n, IDEOGRAPH_DIGITS, COUNTING_UNITS, true);
+		case "hebrew1": return n === 0 ? "" : toHebrewNumeral(n);
+		case "hebrew2": return n === 0 ? "" : HEBREW_ALPHABET[(n - 1) % HEBREW_ALPHABET.length];
+		case "decimalEnclosedCircle": return n >= 1 && n <= 20 ? String.fromCodePoint(9311 + n) : String(n);
+		case "chicago":
+			if (n < 1) return "";
+			return CHICAGO_MARKS[(n - 1) % CHICAGO_MARKS.length].repeat(Math.floor((n - 1) / CHICAGO_MARKS.length) + 1);
 		default: return "";
 	}
 }
+var HEBREW_ONES = [
+	"",
+	"א",
+	"ב",
+	"ג",
+	"ד",
+	"ה",
+	"ו",
+	"ז",
+	"ח",
+	"ט"
+];
+var HEBREW_TENS = [
+	"",
+	"י",
+	"כ",
+	"ל",
+	"מ",
+	"נ",
+	"ס",
+	"ע",
+	"פ",
+	"צ"
+];
+var HEBREW_HUNDREDS = [
+	"",
+	"ק",
+	"ר",
+	"ש",
+	"ת"
+];
+var HEBREW_ALPHABET = [
+	"א",
+	"ב",
+	"ג",
+	"ד",
+	"ה",
+	"ו",
+	"ז",
+	"ח",
+	"ט",
+	"י",
+	"כ",
+	"ל",
+	"מ",
+	"נ",
+	"ס",
+	"ע",
+	"פ",
+	"צ",
+	"ק",
+	"ר",
+	"ש",
+	"ת"
+];
+function toHebrewNumeral(n) {
+	let rest = n;
+	let out = "";
+	while (rest >= 400) {
+		out += "ת";
+		rest -= 400;
+	}
+	out += HEBREW_HUNDREDS[Math.floor(rest / 100)] ?? "";
+	rest %= 100;
+	if (rest === 15 || rest === 16) out += rest === 15 ? "טו" : "טז";
+	else {
+		out += HEBREW_TENS[Math.floor(rest / 10)] ?? "";
+		out += HEBREW_ONES[rest % 10] ?? "";
+	}
+	return out;
+}
+var CHICAGO_MARKS = [
+	"*",
+	"†",
+	"‡",
+	"§"
+];
+var IDEOGRAPH_DIGITS = [
+	"零",
+	"一",
+	"二",
+	"三",
+	"四",
+	"五",
+	"六",
+	"七",
+	"八",
+	"九"
+];
+var COUNTING_UNITS = [
+	"",
+	"十",
+	"百",
+	"千"
+];
+var LEGAL_DIGITS = [
+	"零",
+	"壹",
+	"貳",
+	"參",
+	"肆",
+	"伍",
+	"陸",
+	"柒",
+	"捌",
+	"玖"
+];
+var LEGAL_UNITS = [
+	"",
+	"拾",
+	"佰",
+	"仟"
+];
+var HEAVENLY_STEMS = [
+	"甲",
+	"乙",
+	"丙",
+	"丁",
+	"戊",
+	"己",
+	"庚",
+	"辛",
+	"壬",
+	"癸"
+];
+var EARTHLY_BRANCHES = [
+	"子",
+	"丑",
+	"寅",
+	"卯",
+	"辰",
+	"巳",
+	"午",
+	"未",
+	"申",
+	"酉",
+	"戌",
+	"亥"
+];
+var FULL_WIDTH_DIGITS = [
+	"０",
+	"１",
+	"２",
+	"３",
+	"４",
+	"５",
+	"６",
+	"７",
+	"８",
+	"９"
+];
+/** Each decimal digit as its own glyph — no units, no elision (10 → 一零). */
+function digitByDigit(n, digits) {
+	return String(n).split("").map((d) => digits[Number(d)] ?? d).join("");
+}
+/**
+* The counting systems: digits carrying place units (十百千). `elideTen` drops
+* the leading 一 of the tens place, which is what the plain counting systems do
+* (11 → 十一) and the formal one does not (11 → 壹拾壹). Above the units the
+* table covers, plain digits — a list marker never gets that far.
+*/
+function counting(n, digits, units, elideTen) {
+	if (n >= 10 ** units.length) return String(n);
+	const ds = String(n).split("").map(Number);
+	let out = "";
+	ds.forEach((d, i) => {
+		const place = ds.length - 1 - i;
+		if (d === 0) {
+			if (out.length > 0 && !out.endsWith(digits[0]) && ds.slice(i).some((x) => x > 0)) out += digits[0];
+			return;
+		}
+		const head = elideTen && d === 1 && place === 1 && i === 0 ? "" : digits[d];
+		out += head + units[place];
+	});
+	return out;
+}
+/** `1st`, `2nd`, `3rd`, `4th` — the English ordinal suffixes (§17.18.59). */
+function ordinalSuffix(n) {
+	const two = n % 100;
+	if (two >= 11 && two <= 13) return "th";
+	switch (n % 10) {
+		case 1: return "st";
+		case 2: return "nd";
+		case 3: return "rd";
+		default: return "th";
+	}
+}
 function toLetters(n) {
 	let s = "";
 	let v = n;
@@ -95,4 +336,4 @@ function normalizeBullet(lvlText) {
 	return lvlText;
 }
 //#endregion
-export { NumberingState };
+export { NumberingState, effectiveAbstract, formatLevelMarker };

package/dist/esm/core/po-helpers.js

@@ -65,7 +65,22 @@ function poIntAttr(node, name) {
 	const v = poAttr(node, name);
 	if (v === void 0) return void 0;
 	const n = Number(v);
-	return Number.isFinite(n) ? n : void 0;
+	if (Number.isFinite(n)) return n;
+	return universalMeasureTwips(v);
+}
+var MEASURE_TWIPS = new Map([
+	["pt", 20],
+	["pc", 240],
+	["pi", 240],
+	["in", 1440],
+	["cm", 1440 / 2.54],
+	["mm", 144 / 2.54]
+]);
+function universalMeasureTwips(raw) {
+	const m = /^\s*(-?[0-9]+(?:\.[0-9]+)?)(pt|pc|pi|in|cm|mm)\s*$/iu.exec(raw);
+	if (!m) return void 0;
+	const per = MEASURE_TWIPS.get(m[2].toLowerCase());
+	return per === void 0 ? void 0 : Number(m[1]) * per;
 }
 /** Shorthand for the `val` attribute (`@w:val`/…). */
 function poVal(node) {

package/dist/esm/core/style-cascade/resolver.js

@@ -38,8 +38,10 @@ function resolveRunProperties(runDirect, paragraphDirect, sheet) {
 }
 function computeRunProperties(runDirect, paragraphDirect, sheet) {
 	let acc = mergeRun(DEFAULT_RESOLVED_RUN, sheet.defaultRunProperties);
-	if (paragraphDirect.styleId) {
-		const chain = resolveStyleChain(paragraphDirect.styleId, sheet);
+	if (paragraphDirect.inheritedRun) acc = mergeRun(acc, paragraphDirect.inheritedRun);
+	const styleId = paragraphDirect.styleId ?? defaultParagraphStyleId(sheet);
+	if (styleId) {
+		const chain = resolveStyleChain(styleId, sheet);
 		acc = mergeRun(acc, chain.rPr);
 	}
 	if (runDirect.styleId) {
@@ -71,12 +73,27 @@ function resolveParagraphProperties(paragraphDirect, sheet) {
 }
 function computeParagraphProperties(paragraphDirect, sheet) {
 	let acc = mergePar(DEFAULT_RESOLVED_PARAGRAPH, sheet.defaultParagraphProperties);
-	if (paragraphDirect.styleId) {
-		const chain = resolveStyleChain(paragraphDirect.styleId, sheet);
+	if (paragraphDirect.tableStyle ?? paragraphDirect.inheritedRun) acc = mergePar(acc, {
+		...paragraphDirect.tableStyle,
+		...paragraphDirect.inheritedRun ? { runProperties: paragraphDirect.inheritedRun } : {}
+	});
+	const styleId = paragraphDirect.styleId ?? defaultParagraphStyleId(sheet);
+	if (styleId) {
+		const chain = resolveStyleChain(styleId, sheet);
 		acc = mergePar(acc, chain.pPr);
 	}
 	return mergePar(acc, paragraphDirect);
 }
+/** The id of the `w:default="1"` paragraph style, cached per sheet. */
+var defaultParagraphStyleCache = /* @__PURE__ */ new WeakMap();
+function defaultParagraphStyleId(sheet) {
+	const hit = defaultParagraphStyleCache.get(sheet);
+	if (hit !== void 0) return hit ?? void 0;
+	let found = null;
+	for (const style of sheet.styles.values()) if (style.type === "paragraph" && style.isDefault) found = style.id;
+	defaultParagraphStyleCache.set(sheet, found);
+	return found ?? void 0;
+}
 function resolveStyleChain(styleId, sheet) {
 	const chain = [];
 	const visited = /* @__PURE__ */ new Set();
@@ -108,40 +125,72 @@ function mergeRun(base, override) {
 		bold: override.bold ?? base.bold,
 		italic: override.italic ?? base.italic,
 		underline: override.underline ?? base.underline,
+		...override.underlineColorHex ?? base.underlineColorHex ? { underlineColorHex: override.underlineColorHex ?? base.underlineColorHex } : {},
 		strike: override.strike ?? base.strike,
+		caps: override.caps ?? base.caps,
+		smallCaps: override.smallCaps ?? base.smallCaps,
 		fontSizePt: override.fontSizePt ?? base.fontSizePt,
 		colorHex: override.colorHex ?? base.colorHex,
 		fontFamily: override.fontFamily ?? base.fontFamily,
 		verticalAlign: override.verticalAlign ?? base.verticalAlign,
 		rtl: override.rtl ?? base.rtl,
-		...lang !== void 0 ? { lang } : {}
+		...lang !== void 0 ? { lang } : {},
+		...(override.shadingColorHex ?? base.shadingColorHex) !== void 0 ? { shadingColorHex: override.shadingColorHex ?? base.shadingColorHex } : {},
+		...(override.letterSpacingPt ?? base.letterSpacingPt) !== void 0 ? { letterSpacingPt: override.letterSpacingPt ?? base.letterSpacingPt } : {}
 	};
 }
 function mergePar(base, override) {
 	const outlineLevel = override.outlineLevel ?? base.outlineLevel;
 	const styleId = override.styleId ?? base.styleId;
-	const numbering = override.numbering ?? base.numbering;
+	const numbering = override.numbering ?? (override.numberingLevel !== void 0 && base.numbering !== void 0 ? {
+		...base.numbering,
+		ilvl: override.numberingLevel
+	} : base.numbering);
+	const runProperties = override.runProperties ?? base.runProperties;
+	const frame = override.frame ?? base.frame;
+	const sectionBreak = override.sectionBreak ?? base.sectionBreak;
+	const textDirection = override.textDirection ?? base.textDirection;
+	const snapToGrid = override.snapToGrid ?? base.snapToGrid;
 	return {
 		alignment: override.alignment ?? base.alignment,
-		spacingBefore: override.spacingBefore ?? base.spacingBefore,
-		spacingAfter: override.spacingAfter ?? base.spacingAfter,
+		spacingBefore: override.spacingBeforeAuto ?? override.spacingBefore ?? base.spacingBefore,
+		spacingAfter: override.spacingAfterAuto ?? override.spacingAfter ?? base.spacingAfter,
 		spacingLine: override.spacingLine ?? base.spacingLine,
 		spacingLineRule: override.spacingLineRule ?? base.spacingLineRule,
 		indentLeft: override.indentLeft ?? base.indentLeft,
 		indentRight: override.indentRight ?? base.indentRight,
 		indentFirstLine: override.indentFirstLine ?? base.indentFirstLine,
 		pageBreakBefore: override.pageBreakBefore ?? base.pageBreakBefore,
+		contextualSpacing: override.contextualSpacing ?? base.contextualSpacing,
+		tabs: override.tabs ?? base.tabs,
 		bidi: override.bidi ?? base.bidi,
+		...override.borders ?? base.borders ? { borders: override.borders ?? base.borders } : {},
+		...override.shading ?? base.shading ? { shading: override.shading ?? base.shading } : {},
 		...outlineLevel !== void 0 ? { outlineLevel } : {},
 		...styleId !== void 0 ? { styleId } : {},
-		...numbering !== void 0 ? { numbering } : {}
+		...numbering !== void 0 ? { numbering } : {},
+		...runProperties !== void 0 ? { runProperties } : {},
+		...frame !== void 0 ? { frame } : {},
+		...sectionBreak !== void 0 ? { sectionBreak } : {},
+		...textDirection !== void 0 ? { textDirection } : {},
+		...snapToGrid !== void 0 ? { snapToGrid } : {}
 	};
 }
 function mergeRunPartial(base, override) {
 	return copyDefined(base, override);
 }
 function mergeParPartial(base, override) {
-	return copyDefined(base, override);
+	const out = copyDefined(base, override);
+	if (override.numbering === void 0 && override.numberingLevel !== void 0) {
+		if (base.numbering !== void 0) return {
+			...out,
+			numbering: {
+				...base.numbering,
+				ilvl: override.numberingLevel
+			}
+		};
+	}
+	return out;
 }
 function copyDefined(base, override) {
 	const out = { ...base };
@@ -188,7 +237,13 @@ function resolveBodyStyles(body, sheet) {
 	const visit = (el) => {
 		if (el.kind === "paragraph") visitParagraph(el.paragraph);
 		else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) for (const child of cell.content) visit(child);
-		else if (el.kind === "shape" && el.shape.text) for (const child of el.shape.text.content) visit(child);
+		else if (el.kind === "shape") {
+			const shapeText = (sh) => {
+				for (const child of sh.text?.content ?? []) visit(child);
+				for (const member of sh.children ?? []) shapeText(member.shape);
+			};
+			shapeText(el.shape);
+		}
 	};
 	for (const el of body) visit(el);
 	return body;

package/dist/esm/core/style-cascade/table.js

@@ -22,8 +22,10 @@ function applyTableStyle(table, sheet) {
 	const folded = foldTableStyleChain(styleId, sheet);
 	if (!folded) return;
 	const tp = table.properties;
+	const directBorders = tp.borders;
 	if (!tp.borders && folded.base.borders) tp.borders = folded.base.borders;
 	if (!tp.defaultCellMargins && folded.base.cellMargins) tp.defaultCellMargins = folded.base.cellMargins;
+	if (tp.indentPt === void 0 && folded.base.indentPt !== void 0) tp.indentPt = folded.base.indentPt;
 	const look = table.properties.look ?? {};
 	const rows = table.rows;
 	const colCount = Math.max(table.grid.length, ...rows.map((r) => r.cells.reduce((s, c) => s + (c.properties.colSpan ?? 1), 0)));
@@ -33,8 +35,8 @@ function applyTableStyle(table, sheet) {
 		for (const cell of row.cells) {
 			const span = cell.properties.colSpan ?? 1;
 			const layer = cellLayer(folded, look, {
-				firstRow: r === 0,
-				lastRow: r === rows.length - 1,
+				firstRow: r === 0 || row.properties.conditional?.firstRow === true,
+				lastRow: r === rows.length - 1 || row.properties.conditional?.lastRow === true,
 				firstCol: colStart === 0,
 				lastCol: colStart + span >= colCount,
 				rowBand: bandIndex(r, look.firstRow === true, folded.rowBandSize),
@@ -42,20 +44,34 @@ function applyTableStyle(table, sheet) {
 				noHBand: look.noHBand === true,
 				noVBand: look.noVBand === true
 			});
+			const pos = {
+				firstRow: r === 0 || row.properties.conditional?.firstRow === true,
+				lastRow: r === rows.length - 1 || row.properties.conditional?.lastRow === true,
+				firstCol: colStart === 0,
+				lastCol: colStart + span >= colCount
+			};
 			colStart += span;
 			if (!layer) continue;
-			applyLayerToCell(cell, layer);
+			applyLayerToCell(cell, layer, directBorders, pos);
 		}
 	}
 }
-function applyLayerToCell(tableCell, layer) {
+function applyLayerToCell(tableCell, layer, directBorders, pos) {
 	const cell = tableCell;
 	if (layer.shading && !cell.properties.shading) cell.properties.shading = layer.shading;
 	if (layer.cellMargins && !cell.properties.margins) cell.properties.margins = layer.cellMargins;
 	if (layer.borders) {
 		const own = cell.properties.borders ?? {};
+		const fromStyle = { ...layer.borders };
+		if (directBorders) {
+			const stated = (side, outer) => (outer ? directBorders[side] : directBorders[side === "top" || side === "bottom" ? "insideH" : "insideV"]) !== void 0;
+			if (stated("top", pos.firstRow)) delete fromStyle.top;
+			if (stated("bottom", pos.lastRow)) delete fromStyle.bottom;
+			if (stated("left", pos.firstCol)) delete fromStyle.left;
+			if (stated("right", pos.lastCol)) delete fromStyle.right;
+		}
 		const merged = {
-			...layer.borders,
+			...fromStyle,
 			...definedOnly(own)
 		};
 		cell.properties.borders = merged;
@@ -64,12 +80,18 @@ function applyLayerToCell(tableCell, layer) {
 		if (el.kind !== "paragraph") continue;
 		const p = el.paragraph;
 		if (layer.paragraphProperties) p.properties = {
-			...layer.paragraphProperties,
-			...definedOnly(p.properties)
+			...p.properties,
+			tableStyle: {
+				...p.properties.tableStyle,
+				...layer.paragraphProperties
+			}
 		};
-		if (layer.runProperties) for (const run of p.runs) run.properties = {
-			...layer.runProperties,
-			...definedOnly(run.properties)
+		if (layer.runProperties) p.properties = {
+			...p.properties,
+			inheritedRun: {
+				...p.properties.inheritedRun,
+				...layer.runProperties
+			}
 		};
 	}
 }
@@ -79,7 +101,8 @@ function bandIndex(index, skipFirst, bandSize) {
 	return Math.floor(adjusted / Math.max(1, bandSize));
 }
 function cellLayer(folded, look, pos) {
-	const layers = [folded.base];
+	const { borders: _tableWide, ...withoutBorders } = folded.base;
+	const layers = [withoutBorders];
 	const cond = (t) => folded.conditions.get(t);
 	if (!pos.noVBand && pos.colBand >= 0) layers.push(pos.colBand % 2 === 0 ? cond("band1Vert") : cond("band2Vert"));
 	if (!pos.noHBand && pos.rowBand >= 0) layers.push(pos.rowBand % 2 === 0 ? cond("band1Horz") : cond("band2Horz"));
@@ -145,6 +168,7 @@ function mergeLayer(base, override) {
 			...base.cellMargins,
 			...definedOnly(override.cellMargins ?? {})
 		} } : {},
+		...(override.indentPt ?? base.indentPt) !== void 0 ? { indentPt: override.indentPt ?? base.indentPt } : {},
 		...override.shading ?? base.shading ? { shading: override.shading ?? base.shading } : {},
 		...override.runProperties ?? base.runProperties ? { runProperties: {
 			...base.runProperties,

package/dist/esm/core/style-cascade/types.d.ts

@@ -1,4 +1,4 @@
-import { Alignment, FontFamilyMap, NumberingReference, UnderlineStyle, VerticalAlign } from '../document-model/index.js';
+import { Alignment, CellBorders, CellShading, FontFamilyMap, FrameProperties, NumberingReference, RunProperties, TabStop, UnderlineStyle, VerticalAlign } from '../document-model/index.js';
 import { Pt } from '../ir/index.js';
 /**
  * A run's fully-resolved properties: every field required because the cascade
@@ -9,7 +9,13 @@ export interface ResolvedRunProperties {
     readonly bold: boolean;
     readonly italic: boolean;
     readonly underline: UnderlineStyle;
+    /** §17.3.2.40 `w:u @w:color` — the underline's own colour; absent means the text's. */
+    readonly underlineColorHex?: string;
     readonly strike: boolean;
+    /** §17.3.2.5 `w:caps` — displayed in capitals. */
+    readonly caps: boolean;
+    /** §17.3.2.33 `w:smallCaps` — displayed in capitals, the lower case smaller. */
+    readonly smallCaps: boolean;
     readonly fontSizePt: Pt;
     readonly colorHex: string;
     readonly fontFamily: FontFamilyMap;
@@ -20,6 +26,10 @@ export interface ResolvedRunProperties {
      * specifies one; consumed by the tagged-PDF per-element `/Lang`, never layout.
      */
     readonly lang?: string;
+    /** §17.3.2.32 — the background painted behind the run's glyphs. */
+    readonly shadingColorHex?: string;
+    /** §17.3.2.35 — extra space between the run's characters, in points. */
+    readonly letterSpacingPt?: Pt;
 }
 /**
  * A paragraph's fully-resolved properties: every field required, the cascade
@@ -35,6 +45,14 @@ export interface ResolvedParagraphProperties {
     readonly indentRight: Pt;
     readonly indentFirstLine: Pt;
     readonly pageBreakBefore: boolean;
+    /** §17.3.1.9 — drop the space between this paragraph and a same-styled neighbour. */
+    readonly contextualSpacing: boolean;
+    /** §17.3.1.37 — the paragraph's tab stops, in ascending position order. */
+    readonly tabs: ReadonlyArray<TabStop>;
+    /** §17.3.1.24 `w:pBdr` — rules drawn around the paragraph. */
+    readonly borders?: CellBorders;
+    /** §17.3.1.31 `w:pPr/w:shd` — the paragraph's own background fill. */
+    readonly shading?: CellShading;
     readonly bidi: boolean;
     /**
      * ECMA-376 §17.3.1.20 — resolved outline level (0–8). Undefined = body text.
@@ -46,11 +64,34 @@ export interface ResolvedParagraphProperties {
      * detection when a style lacks an explicit outline level.
      */
     readonly styleId?: string;
+    /**
+     * §17.3.1.29 `w:pPr/w:rPr` — the formatting of the paragraph MARK. An empty
+     * paragraph is as tall as its mark, so dropping this on resolution collapsed
+     * a 36pt empty cell to a line of body text (conditionalstyles-tbllook.docx).
+     */
+    readonly runProperties?: RunProperties;
+    /** §17.3.1.11 — the paragraph floats as a text frame. */
+    readonly frame?: FrameProperties;
+    /** §17.3.1.41 — which way the paragraph's lines run (`lrTb` is not recorded). */
+    readonly textDirection?: 'btLr' | 'tbRl';
+    /** §17.3.1.32 — whether these lines stand on the section's grid. Absent ⇒ they do. */
+    readonly snapToGrid?: boolean;
+    /**
+     * §17.6.17 — the paragraph mark carries the section break, so a paragraph
+     * with no content of its own prints nothing at all.
+     */
+    readonly sectionBreak?: boolean;
     /**
      * §17.9 list reference, carried through for tagged-PDF list structure
      * (L/LI nesting) — markers themselves are materialized by `applyNumbering`.
      */
     readonly numbering?: NumberingReference;
+    /**
+     * §17.6.5 — the line pitch of the section's document grid, in points. Not a
+     * property of the paragraph at all: the section it falls in owns it, and the
+     * layout stamps it here so a line knows the grid it stands on.
+     */
+    readonly gridLinePitchPt?: Pt;
 }
 /** Word's empty-document run defaults (used when `docDefaults` is absent). */
 export declare const DEFAULT_RESOLVED_RUN: ResolvedRunProperties;

package/dist/esm/core/style-cascade/types.js

@@ -6,6 +6,8 @@ var DEFAULT_RESOLVED_RUN = {
 	italic: false,
 	underline: "none",
 	strike: false,
+	caps: false,
+	smallCaps: false,
 	fontSizePt: halfPtToPt(22),
 	colorHex: "000000",
 	fontFamily: {},
@@ -23,6 +25,8 @@ var DEFAULT_RESOLVED_PARAGRAPH = {
 	indentRight: twipsToPt(0),
 	indentFirstLine: twipsToPt(0),
 	pageBreakBefore: false,
+	contextualSpacing: false,
+	tabs: [],
 	bidi: false
 };
 //#endregion