reamkit 1.15.3 → 1.16.0

package/dist/esm/layout/styled-layout.js

@@ -17,7 +17,7 @@ import "../core/style-cascade/index.js";
 import { PathBuilder, flipTransform } from "../core/vector.js";
 import { buildSparkline } from "../core/drawingml/sparkline-geometry.js";
 import { arcPoint, arcToBeziers } from "../core/arc-to-bezier.js";
-import { buildChartScene } from "../core/drawingml/chart-geometry.js";
+import { buildChartScene, legendSeriesName } from "../core/drawingml/chart-geometry.js";
 import { layoutMath, mathGlyphSegments, variantStyle } from "./math-layout.js";
 import { rectPath } from "../core/drawingml/preset-geometry.js";
 import { buildShapePaths, buildShapeTransform, buildStroke, gradientToSolid } from "../core/drawingml/shape-render.js";
@@ -400,16 +400,18 @@ function buildSectionContext(section, options, headersFooters, fontResources) {
 	const headerSet = layoutHeaderSet(section.properties, headersFooters, options, fontResources, contentWidth, dims.marginLeft, dims.pageHeight, dims.headerOffsetPt);
 	const footerSet = layoutFooterSet(section.properties, headersFooters, options, fontResources, contentWidth, dims.marginLeft, dims.pageHeight, dims.footerOffsetPt);
 	const columns = buildColumnGeometry(section.properties.columns, contentWidth);
+	const headerBottom = dims.headerOffsetPt + Math.max(headerSet.default.heightPt ?? 0, headerSet.first.heightPt ?? 0, headerSet.even.heightPt ?? 0);
+	const marginTop = Math.max(dims.marginTop, headerBottom);
 	return {
 		endIndex: section.endIndex,
 		properties: section.properties,
 		pageWidth: dims.pageWidth,
 		pageHeight: dims.pageHeight,
 		marginLeft: dims.marginLeft,
-		marginTop: dims.marginTop,
+		marginTop,
 		marginBottom: dims.marginBottom,
 		contentWidth,
-		pageContentHeight: dims.pageHeight - dims.marginTop - dims.marginBottom,
+		pageContentHeight: dims.pageHeight - marginTop - dims.marginBottom,
 		...columns ? { columns } : {},
 		headerSet,
 		footerSet,
@@ -455,14 +457,24 @@ function layoutHeaderSet(section, headersFooters, options, fontResources, conten
 		if (!ref) return { commands: [] };
 		const content = headersFooters.get(ref.relationshipId);
 		if (!content) return { commands: [] };
+		let measured = 0;
 		const render = (c) => {
-			return markPagination(drawBlocksSequentially(laidOutBlocksFor(c, options, fontResources, contentWidth), marginLeft, pageHeight - headerOffsetPt, pageHeight));
+			const blocks = laidOutBlocksFor(c, options, fontResources, contentWidth);
+			measured = blocksHeight(blocks);
+			return markPagination(drawBlocksSequentially(blocks, marginLeft, pageHeight - headerOffsetPt, pageHeight));
 		};
-		if (contentHasPageFields(content)) return {
-			commands: [],
-			renderDynamic: (n, total) => render(substitutePageFields(content, n, total))
+		if (contentHasPageFields(content)) {
+			render(substitutePageFields(content, 1, 1));
+			return {
+				commands: [],
+				heightPt: measured,
+				renderDynamic: (n, total) => render(substitutePageFields(content, n, total))
+			};
+		}
+		return {
+			commands: render(content),
+			heightPt: measured
 		};
-		return { commands: render(content) };
 	};
 	return {
 		default: band("default"),
@@ -470,6 +482,10 @@ function layoutHeaderSet(section, headersFooters, options, fontResources, conten
 		even: band("even")
 	};
 }
+/** Total laid-out height of a run of blocks, paragraph spacing included. */
+function blocksHeight(blocks) {
+	return blocks.reduce((sum, b) => sum + (b.kind === "paragraph" ? b.spacingBeforePt + b.heightPt + b.spacingAfterPt : b.heightPt), 0);
+}
 function layoutFooterSet(section, headersFooters, options, fontResources, contentWidth, marginLeft, pageHeight, footerOffsetPt) {
 	const band = (type) => {
 		const ref = refByType(section.footers, type);
@@ -586,7 +602,16 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 		for (const el of text.content) {
 			if (el.kind !== "paragraph") continue;
 			const blk = layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, innerWidth);
-			for (const line of blk.lines) {
+			const lines = blk.lines.length > 0 ? blk.lines : [{
+				tokens: [],
+				contentWidthPt: 0,
+				maxFontSizePt: el.paragraph.runs[0]?.properties.fontSizePt ?? options.styles.defaultRunProperties.fontSizePt ?? pt(11),
+				availableWidthPt: innerWidth,
+				firstLine: true,
+				resolved: blk.resolved,
+				isLastInParagraph: true
+			}];
+			for (const line of lines) {
 				textLines.push(line);
 				textHeightPt += computeLineHeight(line, blk.resolved);
 			}
@@ -601,6 +626,7 @@ function layoutShapeBlock(shape, options, fontResources, imageResources, content
 		...fillColorHex ? { fillColorHex } : {},
 		...fillGradient ? { fillGradient } : {},
 		...stroke ? { stroke } : {},
+		...shape.shadow ? { shadow: shape.shadow } : {},
 		rotation60k: t?.rotation60k ?? 0,
 		flipH: t?.flipH ?? false,
 		flipV: t?.flipV ?? false,
@@ -666,6 +692,8 @@ function buildChartLayout(chart, widthPt, heightPt, font) {
 		texts: []
 	};
 	const shapes = [];
+	if (scene.background) shapes.push(rectPrim(scene.background));
+	for (const g of scene.gridlines ?? []) shapes.push(polylinePrim(g));
 	for (const pg of scene.polygons ?? []) shapes.push(polygonPrim(pg));
 	for (const r of scene.rects) shapes.push(rectPrim(r));
 	for (const p of scene.polylines) shapes.push(polylinePrim(p));
@@ -682,7 +710,6 @@ var CF_ICON_SIZE_PT = 9;
 var CF_ICON_GUTTER_PT = 12;
 var CF_ICON_EMPTY_HEX = "BFBFBF";
 var DROPDOWN_BUTTON_PT = 11;
-var DROPDOWN_GUTTER_PT = 13;
 var DROPDOWN_FILL_HEX = "F0F0F0";
 var DROPDOWN_BORDER_HEX = "B0B0B0";
 var DROPDOWN_ARROW_HEX = "595959";
@@ -839,9 +866,16 @@ function wedgePrim(w) {
 function labelPrim(l, font) {
 	const line = makeChartLabelLine(l.text, font, l.sizePt, l.colorHex);
 	const w = line.contentWidthPt;
+	const shift = l.align === "center" ? -w / 2 : l.align === "right" ? -w : 0;
+	if (l.rotationDeg) return {
+		line,
+		x: l.x,
+		y: l.y + shift,
+		rotationDeg: l.rotationDeg
+	};
 	return {
 		line,
-		x: l.align === "center" ? l.x - w / 2 : l.align === "right" ? l.x - w : l.x,
+		x: l.x + shift,
 		y: l.y
 	};
 }
@@ -1020,7 +1054,16 @@ function collectFontResources(body, headersFooters, options) {
 			}
 			addRun(run, el.paragraph);
 		}
-		else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
+		else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) {
+			if (cell.properties.hashOnOverflow === true) for (const inner of cell.content) {
+				if (inner.kind !== "paragraph") continue;
+				for (const run of inner.paragraph.runs) addRun({
+					text: "#",
+					properties: run.properties
+				}, inner.paragraph);
+			}
+			visit(cell.content);
+		}
 		else if (el.kind === "shape") {
 			if (el.shape.text) visit(el.shape.text.content);
 		} else if (el.kind === "chart") {
@@ -1040,8 +1083,12 @@ function collectFontResources(body, headersFooters, options) {
 				};
 				if (chart.title) add(chart.title);
 				for (const c of chart.categories) add(c);
-				for (const sr of chart.series) if (sr.name) add(sr.name);
+				chart.series.forEach((sr, i) => add(legendSeriesName(sr, i)));
+				if (chart.catAxisTitle) add(chart.catAxisTitle);
+				if (chart.valAxisTitle) add(chart.valAxisTitle);
+				for (const sr of chart.series) for (const label of sr.pointLabels ?? []) add(label.text);
 				add("0123456789.,-%() ");
+				if (chart.numberFormat) add(chart.numberFormat);
 			}
 		}
 	};
@@ -1049,12 +1096,29 @@ function collectFontResources(body, headersFooters, options) {
 	for (const hf of headersFooters.values()) visit(hf);
 	for (const note of options.footnotes?.values() ?? []) visit(note);
 	for (const note of options.endnotes?.values() ?? []) visit(note);
-	for (const comment of options.comments?.values() ?? []) visit(comment.content);
+	for (const comment of options.comments?.values() ?? []) {
+		visit(comment.content);
+		visit(commentTailBlocks(comment, 1, {
+			parentN: 1,
+			depth: 1,
+			done: true
+		}));
+		visit([{
+			kind: "paragraph",
+			paragraph: {
+				properties: {},
+				runs: [{
+					text: "0123456789",
+					properties: {}
+				}]
+			}
+		}]);
+	}
 	if (used.size === 0) {
 		const regular = options.registry.resolveByStyle(false, false);
 		used.set(regular.variant, {
 			parsed: regular.parsed,
-			gids: new Set([0])
+			gids: /* @__PURE__ */ new Set()
 		});
 	}
 	const out = /* @__PURE__ */ new Map();
@@ -1098,6 +1162,16 @@ function layoutParagraphBlock(paragraph, options, fontResources, imageResources,
 		source: paragraph
 	};
 }
+/**
+* Word and Excel both draw a super/subscript at about two thirds of the base
+* size, raised a third of it or dropped a sixth. The base line height does not
+* change: a superscript inside a line of body text must not open the leading.
+*/
+var SCRIPT_SCALE = .66;
+var SCRIPT_OFFSET = {
+	superscript: 1 / 3,
+	subscript: -1 / 6
+};
 function resolveMathItems(items, fontFor) {
 	return items.map((it) => {
 		if (it.kind === "glyph") return {
@@ -1174,11 +1248,13 @@ function tokenizeParagraph(paragraph, options, fontResources, imageResources, co
 		}
 		const resolvedRun = resolveRunProperties(run.properties, paragraph.properties, options.styles);
 		const { fontKey } = runFontKeyAndParsed(options, resolvedRun.fontFamily.ascii, resolvedRun.bold, resolvedRun.italic);
+		const script = SCRIPT_OFFSET[resolvedRun.verticalAlign] ?? 0;
 		return {
 			run,
 			resolvedRun,
 			font: lookupFont(fontResources, fontKey),
-			fontSizePt: resolvedRun.fontSizePt,
+			fontSizePt: script === 0 ? resolvedRun.fontSizePt : resolvedRun.fontSizePt * SCRIPT_SCALE,
+			...script === 0 ? {} : { risePt: resolvedRun.fontSizePt * script },
 			isImage: false,
 			imageWidthPt: 0,
 			imageHeightPt: 0,
@@ -1233,6 +1309,7 @@ function tokenizePlansLtr(plans) {
 			resolvedRun: plan.resolvedRun,
 			font: plan.font,
 			fontSizePt: plan.fontSizePt,
+			...plan.risePt !== void 0 ? { risePt: plan.risePt } : {},
 			widthPt: plan.font.measure.textWidthPt(t.text, plan.fontSizePt),
 			bidiLevel: 0
 		});
@@ -1288,6 +1365,7 @@ function tokenizePlansBidi(plans, realLevels) {
 				resolvedRun: plan.resolvedRun,
 				font: plan.font,
 				fontSizePt: plan.fontSizePt,
+				...plan.risePt !== void 0 ? { risePt: plan.risePt } : {},
 				widthPt: plan.font.measure.textWidthPt(text, plan.fontSizePt),
 				bidiLevel: curLevel
 			});
@@ -1347,7 +1425,7 @@ function lastCodePoint(s) {
 	const chars = [...s];
 	return chars.length > 0 ? chars[chars.length - 1].codePointAt(0) : 0;
 }
-function paragraphItemStream(tokens, hyphenator) {
+function paragraphItemStream(tokens, hyphenator, maxLineWidthPt) {
 	const entries = [];
 	let prevBoxEndCp = null;
 	for (const tok of tokens) {
@@ -1380,6 +1458,28 @@ function paragraphItemStream(tokens, hyphenator) {
 		prevBoxEndCp = lastCodePoint(tok.text);
 		const positions = hyphenator ? hyphenator.hyphenate(tok.text) : [];
 		if (positions.length === 0) {
+			const chunks = maxLineWidthPt !== void 0 && maxLineWidthPt > 0 && tok.widthPt > maxLineWidthPt * 1.1 ? splitToWidth(tok, maxLineWidthPt) : void 0;
+			if (chunks) {
+				chunks.forEach((chunk, ci) => {
+					if (ci > 0) entries.push({
+						item: {
+							type: "penalty",
+							width: 0,
+							penalty: 0,
+							flagged: false
+						},
+						token: null
+					});
+					entries.push({
+						item: {
+							type: "box",
+							width: chunk.widthPt
+						},
+						token: chunk
+					});
+				});
+				continue;
+			}
 			entries.push({
 				item: {
 					type: "box",
@@ -1445,11 +1545,52 @@ function paragraphItemStream(tokens, hyphenator) {
 	});
 	return entries;
 }
+/**
+* Cut an unbreakable word into the widest pieces that fit `widthPt`, measured
+* with the token's own font. Each piece keeps the run's formatting, so the line
+* builder reassembles them exactly as it does hyphenation fragments.
+*
+* @param tok     The text token.
+* @param widthPt The line width to fit each piece into.
+* @returns The pieces in order, or undefined when even one character overruns
+*          (nothing can be gained by splitting then).
+*/
+function splitToWidth(tok, widthPt) {
+	if (tok.kind !== "text") return void 0;
+	const chars = [...tok.text];
+	if (tok.font.measure.textWidthPt(chars.slice(0, MIN_SPLIT_CHARS).join(""), tok.fontSizePt) > widthPt) return;
+	const out = [];
+	let start = 0;
+	while (start < chars.length) {
+		let end = start + 1;
+		let text = chars[start];
+		let width = tok.font.measure.textWidthPt(text, tok.fontSizePt);
+		if (width > widthPt && start === 0 && chars.length === 1) return void 0;
+		while (end < chars.length) {
+			const next = text + chars[end];
+			const nextWidth = tok.font.measure.textWidthPt(next, tok.fontSizePt);
+			if (nextWidth > widthPt) break;
+			text = next;
+			width = nextWidth;
+			end++;
+		}
+		out.push({
+			...tok,
+			text,
+			widthPt: width
+		});
+		start = end;
+	}
+	return out.length > 1 ? out : void 0;
+}
+/** The fewest characters a mid-word break may leave on a line. */
+var MIN_SPLIT_CHARS = 6;
 function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, resolved, profile) {
 	let st = start;
 	let et = breakIdx;
-	while (st < et && (entries[st].token === null || entries[st].token?.isSpace)) st++;
-	while (et > st && (entries[et - 1].token === null || entries[et - 1].token?.isSpace)) et--;
+	while (st < et && (entries[st].token === null || !isFirst && entries[st].token?.isSpace === true)) st++;
+	const paints = (t) => t !== null && t !== void 0 && t.kind === "text" && (t.resolvedRun.underline !== "none" || t.resolvedRun.strike);
+	while (et > st && (entries[et - 1].token === null || entries[et - 1].token?.isSpace === true && !paints(entries[et - 1].token))) et--;
 	if (st >= et) return null;
 	const lineTokens = [];
 	for (let i = st; i < et; i++) {
@@ -1509,20 +1650,29 @@ function lineFromRange(entries, start, breakIdx, availableWidthPt, isFirst, reso
 function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, profile, lineWidths) {
 	if (tokens.length === 0) return [];
 	const widths = lineWidths ?? [firstLineWidth, otherWidth];
-	const entries = paragraphItemStream(tokens, hyphenator);
+	const entries = paragraphItemStream(tokens, hyphenator, Math.max(0, ...widths));
 	const items = entries.map((e) => e.item);
 	const breaks = profile === "ream" ? breakLines(items, widths).breaks : greedyBreakLines(items, widths);
-	const lines = [];
-	let start = 0;
-	let isFirst = true;
-	let lineIdx = 0;
-	for (const breakIdx of breaks) {
-		const width = lineIdx < widths.length ? widths[lineIdx] : widths[widths.length - 1];
-		const line = lineFromRange(entries, start, breakIdx, width, isFirst, resolved, profile);
-		if (line) lines.push(line);
-		start = breakIdx + 1;
-		isFirst = false;
-		lineIdx++;
+	const buildLines = (at) => {
+		const out = [];
+		let start = 0;
+		let isFirst = true;
+		let lineIdx = 0;
+		for (const breakIdx of at) {
+			const width = lineIdx < widths.length ? widths[lineIdx] : widths[widths.length - 1];
+			const line = lineFromRange(entries, start, breakIdx, width, isFirst, resolved, profile);
+			if (line) out.push(line);
+			start = breakIdx + 1;
+			isFirst = false;
+			lineIdx++;
+		}
+		return out;
+	};
+	let lines = buildLines(breaks);
+	const spill = (ls) => Math.max(0, ...ls.map((l) => l.contentWidthPt - l.availableWidthPt));
+	if (profile === "ream" && lines.length === 1 && spill(lines) > .01) {
+		const greedy = buildLines(greedyBreakLines(items, widths));
+		if (greedy.length > 1 && spill(greedy) < spill(lines) - .01) lines = greedy;
 	}
 	if (lines.length > 0) lines[lines.length - 1].isLastInParagraph = true;
 	return lines;
@@ -1683,6 +1833,30 @@ function measureSingleLine(paragraph, options, fontResources) {
 	}
 	return total;
 }
+/**
+* The above-neighbour a cell resolves its top edge against.
+*
+* A spanning cell covers several columns and paints ONE top across all of them,
+* so taking the first column's neighbour throws away any rule the others
+* declare. tdf100034.xlsx rules the bottom of its two header cells, and a label
+* overflowing from two columns to their left spanned over both and wiped that
+* rule off the page. Take the heaviest bottom under the span instead — it is
+* the one edge the span can draw, so it should be the strongest claim on it.
+*/
+function aboveOfSpan(aboveBordersByCol, colIdx, span) {
+	const first = aboveBordersByCol[colIdx];
+	if (span <= 1) return first;
+	let bottom = first?.bottom;
+	for (let k = 1; k < span; k++) {
+		const b = aboveBordersByCol[colIdx + k]?.bottom;
+		if (heavierBorder(bottom, b) === b) bottom = b;
+	}
+	if (bottom === first?.bottom) return first;
+	return {
+		...first,
+		...bottom ? { bottom } : {}
+	};
+}
 function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidthsPt, options, fontResources, imageResources, rowMergeRoles, aboveBordersByCol) {
 	const cells = [];
 	const columnXOffsets = [];
@@ -1693,18 +1867,32 @@ function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidth
 		const span = Math.max(1, cell.properties.colSpan ?? 1);
 		let widthPt = 0;
 		for (let k = 0; k < span && colIdx + k < columnWidthsPt.length; k++) widthPt += columnWidthsPt[colIdx + k];
+		const paintSpan = Math.min(span, Math.max(1, cell.properties.paintColumns ?? span));
+		let paintWidthPt = 0;
+		for (let k = 0; k < paintSpan && colIdx + k < columnWidthsPt.length; k++) paintWidthPt += columnWidthsPt[colIdx + k];
 		columnXOffsets.push(cursorX);
 		const mergeRole = rowMergeRoles[cellIdx] ?? "standalone";
 		const leftNeighbor = cellIdx > 0 ? row.cells[cellIdx - 1].properties.borders : void 0;
-		const cellLayout = layoutTableCell(cell, tableProps, widthPt, options, fontResources, imageResources, rowIdx, colIdx, span, rowCount, colCount, mergeRole, leftNeighbor, aboveBordersByCol[colIdx]);
-		cells.push(cellLayout);
+		const cellLayout = layoutTableCell(cell, tableProps, widthPt, options, fontResources, imageResources, rowIdx, colIdx, span, rowCount, colCount, mergeRole, leftNeighbor, aboveOfSpan(aboveBordersByCol, colIdx, span));
+		cells.push(paintWidthPt < widthPt ? {
+			...cellLayout,
+			paintWidthPt
+		} : cellLayout);
 		cursorX += widthPt;
 		colIdx += span;
 	}
 	let heightPt = 0;
 	for (const c of cells) if (c.totalHeightPt > heightPt) heightPt = c.totalHeightPt;
-	if (row.properties.height && row.properties.heightRule === "exact") heightPt = row.properties.height;
-	else if (row.properties.height && row.properties.heightRule === "atLeast") heightPt = Math.max(heightPt, row.properties.height);
+	if (row.properties.height && row.properties.heightRule === "exact") {
+		heightPt = row.properties.height;
+		return {
+			heightPt,
+			cells: cells.map((c) => clipCellToHeight(c, heightPt)),
+			columnXOffsets,
+			rowIdx,
+			rowCount
+		};
+	} else if (row.properties.height && row.properties.heightRule === "atLeast") heightPt = Math.max(heightPt, row.properties.height);
 	return {
 		heightPt,
 		cells,
@@ -1713,6 +1901,35 @@ function layoutTableRow(row, rowIdx, rowCount, colCount, tableProps, columnWidth
 		rowCount
 	};
 }
+/**
+* A cell with only the lines that fit inside `heightPt`.
+*
+* Whole lines only: half a line of text reads as a rendering fault, where a
+* missing one reads as the clipping it is. A cell that already fits, or whose
+* first line does not, is returned untouched — the first line always draws, as
+* it does in Excel.
+*
+* @param cell     The laid-out cell.
+* @param heightPt The row's pinned height.
+* @returns The cell, clipped.
+*/
+function clipCellToHeight(cell, heightPt) {
+	const room = heightPt - cell.padTopPt - cell.padBottomPt;
+	if (cell.lines.length <= 1 || cell.contentHeightPt <= room) return cell;
+	const kept = [];
+	let used = 0;
+	for (const line of cell.lines) {
+		const h = computeLineHeight(line, line.resolved);
+		if (kept.length > 0 && used + h > room) break;
+		kept.push(line);
+		used += h;
+	}
+	return {
+		...cell,
+		lines: kept,
+		contentHeightPt: used
+	};
+}
 function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imageResources, rowIdx, colStart, colSpan, rowCount, colCount, mergeRole, leftNeighborBorders, aboveNeighborBorders) {
 	const cellMar = cell.properties.margins;
 	const tableMar = tableProps.defaultCellMargins;
@@ -1721,15 +1938,20 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 	const padLeftBase = cellMar?.left ?? tableMar?.left ?? DEFAULT_CELL_PADDING_TWIPS * TWIP_TO_PT;
 	const padRightBase = cellMar?.right ?? tableMar?.right ?? DEFAULT_CELL_PADDING_TWIPS * TWIP_TO_PT;
 	const padLeftPt = padLeftBase + (cell.properties.icon ? CF_ICON_GUTTER_PT : 0);
-	const padRightPt = padRightBase + (cell.properties.dropdown ? DROPDOWN_GUTTER_PT : 0);
+	const padRightPt = padRightBase;
 	const innerWidth = Math.max(1, widthPt - padLeftPt - padRightPt);
 	const lines = [];
 	const nestedTables = [];
 	let contentHeightPt = 0;
+	let clipped = false;
 	if (mergeRole !== "middle" && mergeRole !== "end") {
 		for (const el of cell.content) if (el.kind === "paragraph") {
-			const block = layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, innerWidth);
-			for (const line of block.lines) {
+			const noWrap = cell.properties.noWrap === true;
+			const block = layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, noWrap ? NO_WRAP_MEASURE_WIDTH : innerWidth);
+			const cutAt = widthPt - padLeftPt;
+			if (noWrap && (block.lines[0]?.contentWidthPt ?? 0) > cutAt) clipped = true;
+			const keep = noWrap ? clipLineToWidth(block.lines, cutAt, cell.properties.hashOnOverflow === true) : block.lines;
+			for (const line of keep) {
 				lines.push(line);
 				contentHeightPt += computeLineHeight(line, block.resolved);
 			}
@@ -1754,14 +1976,15 @@ function layoutTableCell(cell, tableProps, widthPt, options, fontResources, imag
 		...cell.properties.dataBar ? { dataBar: cell.properties.dataBar } : {},
 		...cell.properties.icon ? { icon: cell.properties.icon } : {},
 		...cell.properties.sparkline ? { sparkline: cell.properties.sparkline } : {},
-		...cell.properties.dropdown ? { dropdown: true } : {},
 		lines,
 		...nestedTables.length > 0 ? { nestedTables } : {},
 		contentHeightPt,
 		totalHeightPt,
+		...cell.properties.verticalAlign ? { verticalAlign: cell.properties.verticalAlign } : {},
 		colStart,
 		colSpan,
-		mergeRole
+		mergeRole,
+		...clipped ? { clipped: true } : {}
 	};
 }
 var BORDER_STYLE_RANK = {
@@ -1769,6 +1992,8 @@ var BORDER_STYLE_RANK = {
 	thick: 4,
 	single: 3,
 	dashed: 2,
+	dashDot: 2,
+	dashDotDot: 2,
 	dotted: 1,
 	none: 0
 };
@@ -1929,6 +2154,14 @@ var PageAssembler = class {
 	* Consumed space counts as use, whether or not any ink went with it.
 	*/
 	colHasContent = () => this.current.length > this.colStartLen || this.cursorY < this.colStartY;
+	/**
+	* Whether this page has ANYTHING on it — including drawings, which is the
+	* whole point: a page carrying only floats has an empty `current`, so a page
+	* break asked for after it was silently dropped and the next band's drawings
+	* landed on top of the first's. tdf111980_radioButtons.xlsx has no cells at
+	* all and eleven controls wider than its page.
+	*/
+	pageHasContent = () => this.current.length > 0 || this.floatsBehind.length > 0 || this.floatsFront.length > 0;
 	/** Overflow step: next column on this page, or a fresh page after the last. */
 	advanceColumn = () => {
 		if (this.ctx.columns && this.colIdx + 1 < this.ctx.columns.length) {
@@ -2114,7 +2347,7 @@ var PageAssembler = class {
 	*              guarantee one page for a header/footer-only document).
 	*/
 	flushPage = (force = false) => {
-		if (this.current.length === 0 && this.cursorY >= this.colStartY && !force) return;
+		if (!this.pageHasContent() && this.cursorY >= this.colStartY && !force) return;
 		const band = bandForPage(this.pageInSection, this.globalPageIdx, this.ctx.titlePg, this.ctx.evenAndOddHeaders);
 		const header = pickBand(this.ctx.headerSet, band);
 		const footer = pickBand(this.ctx.footerSet, band);
@@ -2174,7 +2407,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 		}
 		if (builder && !(block.kind === "paragraph" && block.list)) asm.listStack.length = 0;
 		if (block.kind === "paragraph") {
-			if (block.resolved.pageBreakBefore && asm.current.length > 0) asm.flushPage();
+			if (block.resolved.pageBreakBefore && asm.pageHasContent()) asm.flushPage();
 			asm.cursorY -= block.spacingBeforePt;
 			let pb = block;
 			if (reflowParagraph && pb.source && asm.exclusions.length > 0) {
@@ -2310,6 +2543,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 						...block.fillColorHex ? { fillColorHex: block.fillColorHex } : {},
 						...block.fillGradient ? { fillGradient: block.fillGradient } : {},
 						...block.stroke ? { stroke: block.stroke } : {},
+						...block.shadow ? { shadow: block.shadow } : {},
 						transform
 					},
 					...figId !== void 0 ? { structId: figId } : {}
@@ -2380,6 +2614,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 					line: t.line,
 					originX: pt(x + t.x),
 					baselineY: pt(asm.ctx.pageHeight - (bottomYUp + t.y)),
+					...t.rotationDeg ? { rotationDeg: t.rotationDeg } : {},
 					...fig
 				});
 			};
@@ -2439,8 +2674,16 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 							asm.cursorY -= hr.heightPt;
 						}
 					}
-					emitRowChunk(asm.current, chunk, tableX, asm.cursorY, asm.ctx.pageHeight, colCount, cellStructIds);
+					const mergedHeights = chunks.length === 1 && row.cells.some((c) => c.mergeRole === "start") ? row.cells.map((c) => c.mergeRole === "start" ? mergedBoxHeightPt(block.rows, ri, c.colStart, asm.cursorY - asm.bottomLimit()) : void 0) : void 0;
+					emitRowChunk(asm.current, chunk, tableX, asm.cursorY, asm.ctx.pageHeight, colCount, cellStructIds, mergedHeights);
 					asm.cursorY -= chunk.heightPt;
+					if (ci === chunks.length - 1 && ri < block.rows.length - 1) {
+						const next = block.rows[ri + 1];
+						const nextHeight = Math.min(next.heightPt, asm.ctx.pageContentHeight);
+						const nextForced = next.breakBefore && ri + 1 >= headerRows.length && asm.current.length > 0;
+						const nextOverflow = asm.cursorY - nextHeight < asm.bottomLimit() && asm.colHasContent();
+						if (nextForced || nextOverflow) emitRowBottomEdge(asm.current, chunk, tableX, asm.cursorY, asm.ctx.pageHeight);
+					}
 				}
 			}
 		}
@@ -2453,8 +2696,44 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 		if (d.position === "header") page.commands.unshift(...cmds);
 		else page.commands.push(...cmds);
 	}
+	for (const page of asm.pages) coalesceVerticalFills(page.commands);
 	return asm.pages;
 }
+function coalesceVerticalFills(commands) {
+	const touching = (a, b) => Math.abs(a.x - b.x) < .01 && Math.abs(a.width - b.width) < .01 && a.fillColorHex === b.fillColorHex && Math.min(a.y + a.height, b.y + b.height) >= Math.max(a.y, b.y) - .01;
+	const open = /* @__PURE__ */ new Map();
+	const dead = /* @__PURE__ */ new Set();
+	for (const item of commands) {
+		if (item.type !== "fill") continue;
+		const fill = item;
+		const k = `${fill.x.toFixed(2)}|${fill.width.toFixed(2)}|${fill.fillColorHex}`;
+		const prev = open.get(k);
+		if (prev && touching(prev, fill)) {
+			const top = Math.max(prev.y + prev.height, fill.y + fill.height);
+			const bottom = Math.min(prev.y, fill.y);
+			prev.y = pt(bottom);
+			prev.height = pt(top - bottom);
+			dead.add(item);
+			continue;
+		}
+		open.set(k, fill);
+	}
+	if (dead.size === 0) return;
+	const kept = commands.filter((c) => !dead.has(c));
+	commands.length = 0;
+	commands.push(...kept);
+}
+function mergedBoxHeightPt(rows, startRowIdx, colStart, availablePt) {
+	let height = rows[startRowIdx].heightPt;
+	for (let r = startRowIdx + 1; r < rows.length; r++) {
+		const cont = rows[r].cells.find((c) => c.colStart === colStart && (c.mergeRole === "middle" || c.mergeRole === "end"));
+		if (!cont) break;
+		if (height + rows[r].heightPt > availablePt) break;
+		height += rows[r].heightPt;
+		if (cont.mergeRole === "end") break;
+	}
+	return height;
+}
 function tableCellRowSpan(rows, startRowIdx, colStart) {
 	let span = 1;
 	for (let r = startRowIdx + 1; r < rows.length; r++) {
@@ -2465,32 +2744,74 @@ function tableCellRowSpan(rows, startRowIdx, colStart) {
 	}
 	return span;
 }
-function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellStructIds) {
+function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellStructIds, mergedHeights) {
 	const rowTop = cursorY;
 	const rowBottom = cursorY - row.heightPt;
+	{
+		let i = 0;
+		while (i < row.cells.length) {
+			const cell = row.cells[i];
+			if (!cell.shadingColorHex) {
+				i++;
+				continue;
+			}
+			let width = cell.paintWidthPt ?? cell.widthPt;
+			let j = i + 1;
+			while (j < row.cells.length && cell.paintWidthPt === void 0) {
+				const next = row.cells[j];
+				if (next.mergeRole === "middle" || next.mergeRole === "end") break;
+				if (next.shadingColorHex !== cell.shadingColorHex) break;
+				width += next.paintWidthPt ?? next.widthPt;
+				j++;
+			}
+			out.push({
+				type: "fill",
+				x: pt(marginLeft + (row.columnXOffsets[i] ?? 0)),
+				y: pt(pageHeight - rowBottom - row.heightPt - FILL_SEAM_PT),
+				width: pt(width),
+				height: pt(row.heightPt + FILL_SEAM_PT),
+				fillColorHex: cell.shadingColorHex
+			});
+			i = j;
+		}
+	}
 	for (let i = 0; i < row.cells.length; i++) {
 		const cell = row.cells[i];
 		const cellX = marginLeft + (row.columnXOffsets[i] ?? 0);
 		const structId = cellStructIds?.[i];
-		if (cell.shadingColorHex && cell.mergeRole !== "middle" && cell.mergeRole !== "end") out.push({
-			type: "fill",
-			x: pt(cellX),
-			y: pt(pageHeight - rowBottom - row.heightPt),
-			width: pt(cell.widthPt),
-			height: pt(row.heightPt),
-			fillColorHex: cell.shadingColorHex
-		});
 		if (cell.dataBar && cell.mergeRole !== "middle" && cell.mergeRole !== "end") {
 			const start = Math.max(0, Math.min(1, cell.dataBar.startFraction ?? 0));
 			const barWidth = cell.widthPt * Math.max(0, Math.min(1, cell.dataBar.fraction));
-			if (barWidth > 0) out.push({
-				type: "fill",
-				x: pt(cellX + cell.widthPt * start),
-				y: pt(pageHeight - rowBottom - row.heightPt),
-				width: pt(barWidth),
-				height: pt(row.heightPt),
-				fillColorHex: cell.dataBar.colorHex
-			});
+			if (barWidth > 0) {
+				const barX = cellX + cell.widthPt * start;
+				const barBottomYUp = rowBottom;
+				out.push({
+					type: "shape",
+					shape: {
+						paths: [rectAtPath(0, 0, barWidth, row.heightPt)],
+						fillColorHex: cell.dataBar.colorHex,
+						fillGradient: {
+							kind: "linear",
+							angle: cell.dataBar.negative ? 180 : 0,
+							stops: [{
+								offset: 0,
+								colorHex: cell.dataBar.colorHex
+							}, {
+								offset: 1,
+								colorHex: "FFFFFF"
+							}]
+						},
+						transform: flipTransform([
+							1,
+							0,
+							0,
+							1,
+							barX,
+							barBottomYUp
+						], pageHeight)
+					}
+				});
+			}
 		}
 		if (cell.icon && cell.mergeRole !== "middle" && cell.mergeRole !== "end") {
 			const iconSize = Math.min(CF_ICON_SIZE_PT, Math.max(0, row.heightPt - 1));
@@ -2592,16 +2913,26 @@ function emitRowChunk(out, row, marginLeft, cursorY, pageHeight, colCount, cellS
 			if (diagUp) pushDiagonal(diagUp, 0, h);
 		}
 		if (cell.mergeRole === "middle" || cell.mergeRole === "end") continue;
-		let textY = rowTop - cell.padTopPt;
+		const boxHeightPt = mergedHeights?.[i] ?? row.heightPt;
+		const slack = cell.verticalAlign !== void 0 ? boxHeightPt - cell.padTopPt - cell.contentHeightPt - cell.padBottomPt : 0;
+		const vOffset = slack <= 0 ? 0 : cell.verticalAlign === "bottom" ? slack : cell.verticalAlign === "center" ? slack / 2 : 0;
+		let textY = rowTop - cell.padTopPt - vOffset;
 		for (const line of cell.lines) {
 			const h = computeLineHeight(line, line.resolved);
 			textY -= h;
 			const offset = alignmentOffset(line.resolved.alignment, line.contentWidthPt, cell.widthPt - cell.padLeftPt - cell.padRightPt);
+			const indentLeft = line.resolved.indentLeft + (line.firstLine ? line.resolved.indentFirstLine : 0);
 			out.push({
 				type: "line",
 				line,
-				originX: pt(cellX + cell.padLeftPt + offset),
+				originX: pt(cellX + cell.padLeftPt + indentLeft + offset),
 				baselineY: pt(pageHeight - (textY + lineDescent(line))),
+				...cell.clipped ? { clip: {
+					x: pt(cellX),
+					y: pt(pageHeight - rowTop),
+					width: pt(cell.widthPt),
+					height: pt(boxHeightPt)
+				} } : {},
 				...structId !== void 0 ? { structId } : {}
 			});
 		}
@@ -2697,6 +3028,7 @@ function splitRowIntoChunks(row, capacity) {
 	}
 	return out.length > 0 ? out : [row];
 }
+var FILL_SEAM_PT = .07;
 function emitCellBorders(out, cell, cellX, cellY, rowHeight, pageHeight, rowIdx, rowCount, colCount) {
 	const pushSide = (side, border) => {
 		if (!border || border.style === "none") return;
@@ -2706,10 +3038,11 @@ function emitCellBorders(out, cell, cellX, cellY, rowHeight, pageHeight, rowIdx,
 			side,
 			x: pt(cellX),
 			y: pt(pageHeight - cellY - rowHeight),
-			width: pt(cell.widthPt),
+			width: pt(cell.paintWidthPt ?? cell.widthPt),
 			height: pt(rowHeight),
 			borderSizePt: sz,
-			borderColorHex: border.colorHex ?? "000000"
+			borderColorHex: border.colorHex ?? "000000",
+			...border.style !== "single" ? { borderStyle: border.style } : {}
 		});
 	};
 	pushSide("top", cell.borders.top);
@@ -2717,5 +3050,101 @@ function emitCellBorders(out, cell, cellX, cellY, rowHeight, pageHeight, rowIdx,
 	if (rowIdx === rowCount - 1) pushSide("bottom", cell.borders.bottom);
 	if (cell.colStart + cell.colSpan - 1 === colCount - 1) pushSide("right", cell.borders.right);
 }
+var NO_WRAP_MEASURE_WIDTH = 1e6;
+/**
+* One line, trimmed to the glyph that STRADDLES `widthPt` — what a non-wrapping
+* spreadsheet cell shows. Excel and LibreOffice paint that glyph and cut it
+* through the middle, and so do we now: the caller marks the cell and the
+* emitters clip the line to its box (TextLineItem.clip). Stopping at the last
+* glyph that wholly fits is what dropped a character off every cut cell.
+*/
+function clipLineToWidth(lines, widthPt, hashOnOverflow = false) {
+	const line = lines[0];
+	if (!line) return [];
+	if (line.contentWidthPt <= widthPt) return [line];
+	if (hashOnOverflow) return [hashFill(line, widthPt)];
+	const tokens = [];
+	let used = 0;
+	for (const token of line.tokens) {
+		const advance = token.widthPt;
+		if (used + advance <= widthPt) {
+			tokens.push(token);
+			used += advance;
+			continue;
+		}
+		if (token.kind === "text") {
+			const room = widthPt - used;
+			let text = "";
+			let textWidth = 0;
+			for (const ch of token.text) {
+				if (textWidth >= room) break;
+				text += ch;
+				textWidth = token.font.measure.textWidthPt(text, token.fontSizePt);
+			}
+			if (text.length > 0) {
+				tokens.push({
+					...token,
+					text,
+					widthPt: textWidth
+				});
+				used += textWidth;
+			}
+		}
+		break;
+	}
+	return [{
+		...line,
+		tokens,
+		contentWidthPt: used
+	}];
+}
+/**
+* The line as a row of `#` filling `widthPt` — what Excel and LibreOffice put in
+* a cell whose number does not fit. At least one, so the cell is never blank:
+* a column too narrow even for a single `#` still has to say something.
+*/
+function hashFill(line, widthPt) {
+	const first = line.tokens.find((t) => t.kind === "text");
+	if (!first) return line;
+	const one = first.font.measure.textWidthPt("#", first.fontSizePt);
+	const count = one > 0 ? Math.max(1, Math.floor(widthPt / one)) : 1;
+	const text = "#".repeat(count);
+	const token = {
+		...first,
+		text,
+		widthPt: first.font.measure.textWidthPt(text, first.fontSizePt)
+	};
+	return {
+		...line,
+		tokens: [token],
+		contentWidthPt: token.widthPt
+	};
+}
+/**
+* The bottom edge of a row that ends a page — the rule the row below it owed it
+* and drew on the next page instead. See the call site: a table that spills over
+* a break is closed on both sides of it, the way Excel and Word print one.
+*
+* A cell whose bottom is suppressed (a vertical merge continuing past the break)
+* stays open; inventing an edge there would cut the merge in half.
+*/
+function emitRowBottomEdge(out, row, marginLeft, rowBottom, pageHeight) {
+	for (let i = 0; i < row.cells.length; i++) {
+		const cell = row.cells[i];
+		const border = cell.borders.bottom;
+		if (!border || border.style === "none") continue;
+		out.push({
+			type: "border",
+			side: "bottom",
+			x: pt(marginLeft + (row.columnXOffsets[i] ?? 0)),
+			y: pt(pageHeight - rowBottom - row.heightPt),
+			width: pt(cell.widthPt),
+			height: pt(row.heightPt),
+			borderSizePt: border.width ?? DEFAULT_BORDER_SIZE_EIGHTH * EIGHTH_PT,
+			borderColorHex: border.colorHex ?? "000000",
+			...border.style !== "single" ? { borderStyle: border.style } : {}
+		});
+	}
+}
 //#endregion
 export { layoutStyledDocument };