reamkit 1.15.4 → 1.17.0

package/dist/esm/excel/print-model.js

@@ -1,10 +1,67 @@
 import { eighthPtToPt, halfPtToPt, pt, twipsToPt } from "../core/ir/units.js";
 import { FEATURES } from "../core/ir/features.js";
+import { applyNumberFormat, generalToWidth, numberFormatColorHex } from "../core/number-format.js";
 import { parseAreaRef, parseTitleRowRange } from "./defined-name-ref.js";
-import { applyNumberFormat } from "./number-format.js";
 import "./index.js";
-import { bandedTables, computeColumnBands } from "./column-bands.js";
+import { bandedTables, computeColumnBands, withHeadingBand } from "./column-bands.js";
 import { buildConditionalFormatter } from "./conditional-format.js";
+/** The point size {@link TWIPS_PER_EXCEL_CHAR} was measured at (Excel's default). */
+var DEFAULT_FONT_PT = 11;
+/**
+* How far past the content a value-less but PAINTED cell may push the used
+* range. A legend or a colour key sits a handful of columns off the data; a
+* whole-row style reaches column XFD. The distance is what tells them apart.
+*/
+var PAINT_REACH_COLUMNS = 64;
+var PAINT_REACH_ROWS = 512;
+/** One screen pixel at 96 DPI, in twips — the unit Excel's width formula works in. */
+var TWIPS_PER_PIXEL = 15;
+/**
+* §18.3.1.13 — a `<col width>` in twips.
+*
+* The padding above is the formula for a column at least one character wide.
+* Excel documents a SEPARATE one below that: `px = Trunc(width × MDW + 0.5)`,
+* with no padding at all. It matters because the padding is a constant: on a
+* form drawn over a fine grid — tdf118668.xlsx rules 168 columns of 0.855
+* characters — 3.75pt of padding nearly doubles a 4.5pt column, and the sheet
+* came out 1384pt wide against the reference's 754, so it paginated across two
+* pages where every reader prints one.
+*
+* @param chars     The declared width in characters.
+* @param charTwips The Maximum Digit Width, in twips.
+* @returns The rendered column width in twips.
+*/
+function columnTwips(chars, charTwips) {
+	return columnTwipsOf(chars, charTwips);
+}
+/**
+* §18.3.1.81 — the DEFAULT column, in twips, from whichever of the two the
+* sheet declares.
+*
+* The two are not the same number. `defaultColWidth` "includes margin padding
+* and extra padding for gridlines"; `baseColWidth` is the bare character count
+* and explicitly excludes them, so deriving a default from it adds the padding
+* once to reach a defaultColWidth and once more to render it. 47668.xlsx says
+* `baseColWidth="10"` and caches its picture's extent at 9753600 EMU = 768pt
+* over 12 columns plus 48pt — 60pt, or 80px, a column. Padding it once gives
+* 75px and squeezed that picture by 6%. LibreOffice measures ~79px here, so
+* both references agree against us.
+*
+* @param worksheet     The sheet.
+* @param charTwips     The Maximum Digit Width, in twips.
+* @param fallbackChars The width to use when the sheet declares neither.
+* @returns The default column width in twips.
+*/
+function defaultColumnTwips(worksheet, charTwips, fallbackChars) {
+	if (worksheet.defaultColWidthChars !== void 0) return columnTwipsOf(worksheet.defaultColWidthChars, charTwips);
+	if (worksheet.baseColWidthChars !== void 0) return columnTwipsOf(worksheet.baseColWidthChars, charTwips) + 150;
+	return columnTwipsOf(fallbackChars, charTwips);
+}
+function columnTwipsOf(chars, charTwips) {
+	const mdwPx = charTwips / TWIPS_PER_PIXEL;
+	if (chars >= 1 && mdwPx > 0) return Math.trunc((256 * chars + Math.trunc(128 / mdwPx)) / 256 * mdwPx) * TWIPS_PER_PIXEL;
+	return Math.trunc(chars * charTwips / TWIPS_PER_PIXEL + .5) * TWIPS_PER_PIXEL;
+}
 /**
 * Excel insets a cell's text by ~2 px each side (1.5 pt at 96 DPI). The layout
 * engine's default is a word processor's 108 twips (5.4 pt), which is nearly
@@ -12,12 +69,106 @@ import { buildConditionalFormatter } from "./conditional-format.js";
 */
 var EXCEL_CELL_INSET_PT = 1.5;
 /**
+* The width behind {@link DEFAULT_COL_TWIPS}, for a non-Calibri unit.
+*
+* In the STORED unit, which is what {@link columnTwips} reads: Excel's default
+* column is "8.43 characters" in its own interface and `width="9.140625"` in
+* every file that writes it out, because the stored form carries the padding.
+*/
+var DEFAULT_COL_CHARS = 9.140625;
+/**
+* The column-width unit in twips: the Maximum Digit Width of the font the
+* document is rendered in (§18.3.1.13), or Excel's own 7 px when the caller has
+* not measured one.
+*/
+/**
+* The digit advance, as a fraction of the em, of the faces a spreadsheet names
+* for its normal style.
+*
+* Read off each face's `hmtx` for `0`–`9`; the metric-compatible substitutes
+* are listed beside their originals because a file naming one is measured in
+* the other's unit by every reader that has to substitute.
+*
+* Every entry here is measured. The CJK defaults are deliberately absent: the
+* evidence says ＭＳ Ｐゴシック 11 is 8px — Japanese Excel's default column is
+* 72px, and §18.3.1.13's forward formula turns that into exactly the
+* `width="9"` 54524.xlsx writes for its default band — but I have no copy of
+* the face to measure, and fitting 0.55 to it moved 50299.xlsx from 16 pages
+* to 22 against LibreOffice's 17. A face we cannot measure keeps the old 7px.
+*/
+var DIGIT_EM = [
+	[/^(calibri|carlito)$/i, 1063 / 2048],
+	[/^(arial|helvetica|liberation sans|arimo|arial unicode ms)$/i, 1139 / 2048],
+	[/^(times new roman|liberation serif|tinos)$/i, 1024 / 2048],
+	[/^(tahoma)$/i, 1118 / 2048],
+	[/^(verdana|dejavu sans)$/i, 1303 / 2048]
+];
+/**
+* §18.3.1.13 — the Maximum Digit Width, in twips, of the normal style's font.
+*
+* "The number of characters of the maximum digit width of the numbers 0, 1,
+* 2, …, 9 **as rendered in the normal style's font**" — the unit is bound to
+* that face at that size, and Excel takes it in whole screen pixels. This used
+* to test only whether the file NAMED a font and hand every named one Excel's
+* 7px: right for the Calibri 11 and Arial 10 the note below cites, wrong for
+* anything else. 55850.xlsx and 55927.xlsx are Arial ELEVEN, whose digit is
+* 8px, so their columns came out 14% narrow and both files lost the last
+* character of every date. A face we do not know keeps the old 7px rather than
+* a guess.
+*
+* @param name   The normal style's font name.
+* @param sizePt Its size in points; 11 when the file omits one.
+* @returns The Maximum Digit Width in twips.
+*/
+function maximumDigitTwips(name, sizePt) {
+	const size = sizePt !== void 0 && Number.isFinite(sizePt) && sizePt > 0 ? sizePt : 11;
+	const em = DIGIT_EM.find(([re]) => re.test(name.trim()))?.[1];
+	if (em === void 0) return 105;
+	const px = Math.trunc(em * size * (96 / 72));
+	return px > 0 ? px * TWIPS_PER_PIXEL : 105;
+}
+function digitTwips(digitWidthPt) {
+	if (digitWidthPt === void 0 || !Number.isFinite(digitWidthPt) || digitWidthPt <= 0) return 105;
+	return digitWidthPt * TWIPS_PER_POINT;
+}
+/**
 * ECMA-376 §18.3.1.81 — the row height Excel uses when a sheet declares no
 * `<sheetFormatPr defaultRowHeight>`: 15pt, the line height of its default
 * theme font (Calibri 11). Independent of whatever font we end up rendering
 * with — the height belongs to the document, not to the typesetter.
 */
 var EXCEL_DEFAULT_ROW_HEIGHT_PT = 15;
+/**
+* The same height for a workbook whose Normal style names another size —
+* Excel's own table, which is not proportional because the height is a line
+* height and a font's leading is not proportional to its body.
+*
+* A workbook written before Calibri says Arial 10 and no `defaultRowHeight`,
+* and every one of its rows is 12.75pt: tdf100709.xlsx fits twenty of them on
+* the page where our 15pt fitted fourteen and pushed the rest onto a second.
+*/
+var EXCEL_ROW_HEIGHT_BY_FONT_PT = new Map([
+	[8, 11],
+	[9, 12],
+	[10, 12.75],
+	[11, 15],
+	[12, 15.75],
+	[14, 18]
+]);
+/**
+* The row height a sheet that declares none inherits from the workbook's
+* Normal font. Sizes outside Excel's table scale from its 10pt entry and snap
+* up to the 0.75pt grid row heights are stored on (one pixel at 96 dpi).
+*
+* @param fontPt The Normal style's font size, or undefined if unknown.
+* @returns The default row height in points.
+*/
+function defaultRowHeightPtFor(fontPt) {
+	if (fontPt === void 0 || !Number.isFinite(fontPt) || fontPt <= 0) return EXCEL_DEFAULT_ROW_HEIGHT_PT;
+	const known = EXCEL_ROW_HEIGHT_BY_FONT_PT.get(fontPt);
+	if (known !== void 0) return known;
+	return Math.ceil(fontPt * 12.75 / 10 / .75) * .75;
+}
 var TWIPS_PER_POINT = 20;
 var TWIPS_PER_INCH = 1440;
 var PAPER_SIZES_TWIPS = new Map([
@@ -29,7 +180,7 @@ var PAPER_SIZES_TWIPS = new Map([
 	[11, [8392, 11906]],
 	[70, [5953, 8392]]
 ]);
-var DEFAULT_PAPER_TWIPS = [11906, 16838];
+var DEFAULT_PAPER_TWIPS = [11900, 16840];
 /**
 * Build the page section (paper size + margins) from a worksheet's `<pageSetup>`
 * / `<pageMargins>`.
@@ -102,6 +253,57 @@ function resolvePrintTitleRows(definedNames, sheetIdx) {
 	for (const dn of definedNames) if (dn.name === PRINT_TITLES_NAME && dn.localSheetId === sheetIdx) return parseTitleRowRange(dn.value);
 }
 var MIN_PRINT_SCALE = .1;
+/**
+* The width one page has for content: the sheet's paper (declared or the A4
+* default) less its left and right margins, in points. The same measure the
+* column bands are packed into — a drawing layer banded on any other width
+* would not line up with the grid beside it.
+*/
+function printableWidthPt(worksheet) {
+	return sheetContentWidthTwips(worksheet) / TWIPS_PER_POINT;
+}
+/**
+* Whether a sheet paginates ACROSS its columns.
+*
+* Fit-to-ONE-page does not: the whole grid is squeezed onto a single page
+* width, and Excel lets that override even a manual column break. An explicit
+* `<pageSetup scale>` is a different thing entirely — §18.3.1.63 makes it a
+* plain zoom, and Excel paginates AFTER applying it. Treating the two alike
+* left 47737.xlsx (`scale="63"`, still 583pt wide) as one 583pt table on a
+* 487pt page: its last column fell off the paper and its "Heading" with it.
+*
+* @param worksheet The sheet.
+* @param fitWide   `fitToWidth`, or 1 when the sheet is not fit-to-page.
+* @returns True when the grid should be split into column bands.
+*/
+function bandsAcross(worksheet, fitWide) {
+	return !worksheet.fitToPage || fitWide > 1;
+}
+/**
+* The manual breaks (§18.3.1.74/§18.3.1.14) that still apply on one axis.
+*
+* Fit-to-page and a manual break are two answers to the same question, and
+* Excel takes the scaling one: turn on "fit to N pages" and the breaks drawn
+* into the sheet stop dividing it. Honouring both asks for the impossible —
+* a break costs a page at EVERY scale, so `fitToHeight="1"` beside one of them
+* can never be satisfied, and the fit search would shrink toward its floor
+* chasing a page count it will never reach. sheet-fit-breaks.xlsx says fit on
+* one page and breaks after row 20; the reference prints all forty rows on one
+* page and we printed two.
+*
+* An explicit `0` on the axis means "as many pages as it takes" — nothing is
+* being fitted there, so the breaks on it stand.
+*
+* @param worksheet The sheet, for its `fitToPage` flag and page setup.
+* @param axis      Which axis's breaks are wanted.
+* @returns The break indices to honour; empty when fit-to-page overrides them.
+*/
+function honouredBreaks(worksheet, axis) {
+	const breaks = (axis === "rows" ? worksheet.rowBreaks : worksheet.colBreaks) ?? [];
+	if (!worksheet.fitToPage) return breaks;
+	const setup = worksheet.pageSetup;
+	return ((axis === "rows" ? setup?.fitToHeight : setup?.fitToWidth) ?? 1) >= 1 ? [] : breaks;
+}
 function sheetContentWidthTwips(worksheet) {
 	const pageSize = pageSizeFromSetup(worksheet.pageSetup);
 	const pageWidthTwips = pageSize ? Math.round(pageSize.width * 20) : DEFAULT_PAPER_TWIPS[0];
@@ -110,6 +312,17 @@ function sheetContentWidthTwips(worksheet) {
 	const right = Math.round(margins.right * 20);
 	return Math.max(TWIPS_PER_INCH / 2, pageWidthTwips - left - right);
 }
+/**
+* The printable HEIGHT of one page of this sheet, in points — its paper height
+* less its own top and bottom margins. The vertical twin of
+* {@link printableWidthPt}.
+*
+* @param worksheet The parsed worksheet (paper + margins).
+* @returns The height a page of this sheet has for content, in points.
+*/
+function printableHeightPt(worksheet) {
+	return sheetContentHeightTwips(worksheet) / TWIPS_PER_POINT;
+}
 function sheetContentHeightTwips(worksheet) {
 	const pageSize = pageSizeFromSetup(worksheet.pageSetup);
 	const pageHeightTwips = pageSize ? Math.round(pageSize.height * 20) : DEFAULT_PAPER_TWIPS[1];
@@ -118,27 +331,73 @@ function sheetContentHeightTwips(worksheet) {
 	const bottom = Math.round(margins.bottom * 20);
 	return Math.max(TWIPS_PER_INCH / 2, pageHeightTwips - top - bottom);
 }
-function computePrintScale(worksheet, totalGridTwips, contentWidthTwips, totalGridHeightTwips, contentHeightTwips) {
+/**
+* How many pages the grid ACTUALLY paginates into at a given scale — the same
+* greedy fill the layout performs, run over one axis.
+*
+* A row does not split, so the closed form `contentHeight × fitToHeight / total`
+* is a lower bound and not an answer: whatever height the last row that will not
+* fit leaves unused is a page's worth of slack the formula never accounts for,
+* and print titles make it worse by consuming their height again on every page.
+*/
+function pageCountAtScale(extents, forcedBreaks, repeatTwips, limitTwips, scale) {
+	let pages = 1;
+	let used = 0;
+	for (let i = 0; i < extents.length; i++) {
+		const extent = extents[i] * scale;
+		if (used > 0 && (forcedBreaks.has(i) || used + extent > limitTwips)) {
+			pages++;
+			used = repeatTwips * scale;
+		}
+		used += extent;
+	}
+	return pages;
+}
+/**
+* The largest whole percentage at or below `closed` that paginates into at most
+* `maxPages` pages. Whole percentages because that is the unit Excel searches in
+* and stores the answer in (`<pageSetup scale="51">`), so the two agree exactly.
+* Monotone — shrinking never adds a page — so a binary search is enough.
+*/
+function searchFitScale(closed, maxPages, pageCount) {
+	const floor = Math.round(MIN_PRINT_SCALE * 100);
+	let hi = Math.min(100, Math.floor(closed * 100));
+	if (hi <= floor) return Math.max(MIN_PRINT_SCALE, closed);
+	if (pageCount(hi / 100) <= maxPages) return hi / 100;
+	let lo = floor;
+	if (pageCount(lo / 100) > maxPages) return closed;
+	while (lo < hi) {
+		const mid = Math.ceil((lo + hi) / 2);
+		if (pageCount(mid / 100) <= maxPages) lo = mid;
+		else hi = mid - 1;
+	}
+	return lo / 100;
+}
+function computePrintScale(worksheet, totalGridTwips, contentWidthTwips, totalGridHeightTwips, contentHeightTwips, geometry) {
 	const setup = worksheet.pageSetup;
 	let s = 1;
 	if (worksheet.fitToPage) {
 		const fitW = setup?.fitToWidth ?? 1;
+		const fitH = setup?.fitToHeight ?? 1;
 		let sW = 1;
 		let sH = 1;
 		if (fitW >= 1 && totalGridTwips > 0) sW = contentWidthTwips * fitW / totalGridTwips;
-		const fitH = setup?.fitToHeight;
-		if (fitH !== void 0 && fitH >= 1 && totalGridHeightTwips > 0) sH = contentHeightTwips * fitH / totalGridHeightTwips;
+		if (fitH >= 1 && totalGridHeightTwips > 0) sH = contentHeightTwips * fitH / totalGridHeightTwips;
+		if (fitW >= 1 && geometry.colTwips.length > 0) sW = searchFitScale(sW, fitW, (scale) => pageCountAtScale(geometry.colTwips, geometry.colBreaks, 0, contentWidthTwips, scale));
+		if (fitH >= 1 && geometry.rowTwips.length > 0) sH = searchFitScale(sH, fitH, (scale) => pageCountAtScale(geometry.rowTwips, geometry.rowBreaks, geometry.titleTwips, contentHeightTwips, scale));
 		s = Math.min(sW, sH);
 	} else if (setup?.scale !== void 0 && setup.scale > 0) s = setup.scale / 100;
 	return Math.min(1, Math.max(MIN_PRINT_SCALE, s));
 }
 function scaleRunFont(props, scale) {
-	const hp = props.fontSizePt !== void 0 ? Math.round(props.fontSizePt * 2) : 22;
+	const base = props.fontSizePt ?? DEFAULT_FONT_PT;
 	return {
 		...props,
-		fontSizePt: halfPtToPt(Math.max(2, Math.round(hp * scale)))
+		fontSizePt: pt(Math.max(1, base * scale))
 	};
 }
+var PRINT_GRIDLINE_HEX = "C0C0C0";
+var CF_NUMBER_FORMAT_ID = 1000001;
 var MAX_SHEET_TEXT_CHARS = 1e6;
 /**
 * Project one worksheet's grid into Flow body elements — a single {@link Table}
@@ -158,6 +417,16 @@ var MAX_SHEET_TEXT_CHARS = 1e6;
 */
 function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 	if (worksheet.maxRow < 0 || worksheet.maxColumn < 0) return [];
+	const charTwipsUnit = styles.fonts[0]?.name === void 0 ? digitTwips(print.digitWidthPt) : maximumDigitTwips(styles.fonts[0].name, styles.fonts[0].sizePt);
+	const textTwipsUnit = 105;
+	const rowStyleAt = /* @__PURE__ */ new Map();
+	for (const r of worksheet.rowStyles ?? []) rowStyleAt.set(r.row, r.styleIndex);
+	const columnStyles = worksheet.columnStyles ?? [];
+	const defaultStyleAt = (row, col, cellXfs) => {
+		const fromRow = rowStyleAt.get(row);
+		if (fromRow !== void 0) return cellXfs[fromRow];
+		for (const cs of columnStyles) if (col + 1 >= cs.min && col + 1 <= cs.max) return cellXfs[cs.styleIndex];
+	};
 	let usedRow = -1;
 	let usedCol = -1;
 	const contentAt = /* @__PURE__ */ new Set();
@@ -177,7 +446,61 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 		if (host.startRow > usedRow) usedRow = host.startRow;
 		if (host.startColumn > usedCol) usedCol = host.startColumn;
 	}
-	if (usedRow < 0 || usedCol < 0) return [];
+	if (usedRow >= 0 && usedCol >= 0 && print.drawingExtentPt) {
+		const wantTwips = Math.round(print.drawingExtentPt.widthPt * TWIPS_PER_POINT);
+		const defTwips = defaultColumnTwips(worksheet, charTwipsUnit, DEFAULT_COL_CHARS);
+		const widthAt = (abs) => {
+			for (const col of worksheet.columns) {
+				if (abs < col.min - 1 || abs > col.max - 1) continue;
+				return col.hidden ? 0 : columnTwips(col.widthChars, charTwipsUnit);
+			}
+			return defTwips;
+		};
+		let acc = 0;
+		for (let col = 0; col < 16384 && acc < wantTwips; col++) {
+			acc += widthAt(col);
+			if (col > usedCol) usedCol = col;
+		}
+	}
+	if (usedRow >= 0 && usedCol >= 0) {
+		const colReach = usedCol + PAINT_REACH_COLUMNS;
+		const rowReach = usedRow + PAINT_REACH_ROWS;
+		for (const c of worksheet.cells) {
+			if (c.column > colReach || c.row > rowReach) continue;
+			if (c.column <= usedCol && c.row <= usedRow) continue;
+			if (!cellPaintsSomething(c, styles)) continue;
+			if (c.row > usedRow) usedRow = c.row;
+			if (c.column > usedCol) usedCol = c.column;
+		}
+	}
+	if (usedRow < 0 && usedCol < 0) {
+		const pageTwips = sheetContentWidthTwips(worksheet);
+		const defTwips = defaultColumnTwips(worksheet, charTwipsUnit, DEFAULT_COL_CHARS);
+		let acc = 0;
+		let colLimit = 0;
+		while (colLimit < PAINT_REACH_COLUMNS && acc < pageTwips) {
+			const col = worksheet.columns.find((cc) => colLimit >= cc.min - 1 && colLimit <= cc.max - 1);
+			acc += col ? col.hidden ? 0 : columnTwips(col.widthChars, charTwipsUnit) : defTwips;
+			colLimit++;
+		}
+		for (const c of worksheet.cells) {
+			if (c.column >= colLimit || c.row >= PAINT_REACH_ROWS) continue;
+			if (!cellPaintsVisibly(c, styles)) continue;
+			if (c.row > usedRow) usedRow = c.row;
+			if (c.column > usedCol) usedCol = c.column;
+		}
+	}
+	if (usedRow < 0 || usedCol < 0) {
+		if (print.scaleSink) print.scaleSink.value = computePrintScale(worksheet, Math.round((print.drawingExtentPt?.widthPt ?? 0) * TWIPS_PER_POINT), sheetContentWidthTwips(worksheet), Math.round((print.drawingExtentPt?.heightPt ?? 0) * TWIPS_PER_POINT), sheetContentHeightTwips(worksheet), {
+			rowTwips: [],
+			rowBreaks: /* @__PURE__ */ new Set(),
+			titleTwips: 0,
+			colTwips: [],
+			colBreaks: /* @__PURE__ */ new Set()
+		});
+		return [];
+	}
+	usedCol += overflowColumnsPastUsedRange(worksheet, usedCol, sharedStrings, styles, date1904, charTwipsUnit);
 	let rowStart = 0;
 	let colStart = 0;
 	let rowEnd = usedRow;
@@ -190,6 +513,7 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 	}
 	if (rowEnd < rowStart || colEnd < colStart) return [];
 	const MAX_GRID_COLS = 16384;
+	const SHEET_MAX_ROWS = 1048576;
 	const MAX_GRID_ROWS = 5e4;
 	const MAX_GRID_CELLS = 1e6;
 	const wantRows = rowEnd - rowStart + 1;
@@ -198,21 +522,22 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 	let rowCount = Math.max(1, Math.min(wantRows, MAX_GRID_ROWS, Math.floor(MAX_GRID_CELLS / colCount)));
 	if (rowCount < wantRows) rowCount = Math.max(1, lastContentRow(worksheet, rowStart, rowCount, colStart, colCount) + 1);
 	if (colCount < wantCols) colCount = Math.max(1, lastContentColumn(worksheet, rowStart, rowCount, colStart, colCount) + 1);
+	const reason = (want, limit, unit, last) => want > limit ? `the sheet declares cells past ${unit} ${last}, the last SpreadsheetML defines` : "memory guard";
 	if (rowCount < wantRows) print.losses?.push({
 		severity: "dropped",
 		feature: FEATURES.tables,
-		detail: `grid clipped to the first ${rowCount} rows of ${wantRows} in the used range (memory guard)`,
+		detail: `grid clipped to the first ${rowCount} rows of ${wantRows} in the used range (${reason(rowStart + wantRows, SHEET_MAX_ROWS, "row", String(SHEET_MAX_ROWS))})`,
 		...print.sheetName ? { where: `sheet "${print.sheetName}"` } : {}
 	});
 	if (colCount < wantCols) print.losses?.push({
 		severity: "dropped",
 		feature: FEATURES.tables,
-		detail: `grid clipped to the first ${colCount} columns of ${wantCols} in the used range (memory guard)`,
+		detail: `grid clipped to the first ${colCount} columns of ${wantCols} in the used range (${reason(colStart + wantCols, MAX_GRID_COLS, "column", "XFD")})`,
 		...print.sheetName ? { where: `sheet "${print.sheetName}"` } : {}
 	});
 	const rowWindowEnd = rowStart + rowCount - 1;
 	const colWindowEnd = colStart + colCount - 1;
-	const defaultRowTwips = Math.round((worksheet.defaultRowHeightPt ?? EXCEL_DEFAULT_ROW_HEIGHT_PT) * TWIPS_PER_POINT);
+	const defaultRowTwips = Math.round((worksheet.defaultRowHeightPt ?? defaultRowHeightPtFor(print.defaultFontPt)) * TWIPS_PER_POINT);
 	const rowHeightMap = /* @__PURE__ */ new Map();
 	for (let r = 0; r < rowCount; r++) rowHeightMap.set(r, {
 		heightTwips: defaultRowTwips,
@@ -224,7 +549,7 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 		const heightTwips = Math.round(h.heightPt * TWIPS_PER_POINT);
 		rowHeightMap.set(local, {
 			heightTwips,
-			heightRule: "atLeast"
+			heightRule: h.customHeight ? "exact" : "atLeast"
 		});
 	}
 	const cellMatrix = Array.from({ length: rowCount }, () => new Array(colCount));
@@ -243,22 +568,54 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 		const cEnd = Math.min(m.endColumn, colWindowEnd);
 		for (let r = Math.max(m.startRow, rowStart); r <= rEnd; r++) for (let c = Math.max(m.startColumn, colStart); c <= cEnd; c++) if (!(r === m.startRow && c === m.startColumn)) insideMerge.add(key(r, c));
 	}
-	const defaultColChars = worksheet.defaultColWidthChars ?? worksheet.baseColWidthChars;
-	const defaultColTwips = defaultColChars !== void 0 ? Math.round(defaultColChars * 105 + 75) : 960;
+	const defaultColTwips = defaultColumnTwips(worksheet, charTwipsUnit, DEFAULT_COL_CHARS);
 	const columnWidths = new Array(colCount).fill(defaultColTwips);
+	const hiddenCols = /* @__PURE__ */ new Set();
 	for (const col of worksheet.columns) {
-		const twips = Math.round(col.widthChars * 105 + 75);
+		const twips = columnTwips(col.widthChars, charTwipsUnit);
 		for (let abs = col.min - 1; abs <= col.max - 1; abs++) {
 			const i = abs - colStart;
-			if (i >= 0 && i < colCount) columnWidths[i] = twips;
+			if (i < 0 || i >= colCount) continue;
+			columnWidths[i] = twips;
+			if (col.hidden) hiddenCols.add(i);
 		}
 	}
-	const totalGridTwips = columnWidths.reduce((sum, w) => sum + w, 0);
+	const hiddenRows = /* @__PURE__ */ new Set();
+	for (const h of worksheet.rowHeights) if (h.hidden) hiddenRows.add(h.row - rowStart);
+	const visibleCols = [];
+	for (let c = 0; c < colCount; c++) if (!hiddenCols.has(c)) visibleCols.push(c);
+	const visibleWidths = visibleCols.map((c) => columnWidths[c]);
+	const totalGridTwips = visibleWidths.reduce((sum, w) => sum + w, 0);
 	let totalGridHeightTwips = 0;
-	for (let r = 0; r < rowCount; r++) totalGridHeightTwips += rowHeightMap.get(r)?.heightTwips ?? 300;
-	const printScale = computePrintScale(worksheet, totalGridTwips, sheetContentWidthTwips(worksheet), totalGridHeightTwips, sheetContentHeightTwips(worksheet));
+	const fitRowTwips = [];
+	const fitRowBreaks = /* @__PURE__ */ new Set();
+	const manualRowBreaks = new Set(honouredBreaks(worksheet, "rows"));
+	let fitTitleTwips = 0;
+	for (let r = 0; r < rowCount; r++) {
+		if (hiddenRows.has(r)) continue;
+		const twips = rowHeightMap.get(r)?.heightTwips ?? 300;
+		totalGridHeightTwips += twips;
+		const abs = r + rowStart;
+		if (manualRowBreaks.has(abs)) fitRowBreaks.add(fitRowTwips.length);
+		if (print.titleRows && abs >= print.titleRows.startRow && abs <= print.titleRows.endRow) fitTitleTwips += twips;
+		fitRowTwips.push(twips);
+	}
+	const manualColBreaks = new Set(honouredBreaks(worksheet, "cols"));
+	const fitColBreaks = /* @__PURE__ */ new Set();
+	visibleCols.forEach((c, i) => {
+		if (manualColBreaks.has(c + colStart)) fitColBreaks.add(i);
+	});
+	const drawing = print.drawingExtentPt;
+	const printScale = computePrintScale(worksheet, Math.max(totalGridTwips, Math.round((drawing?.widthPt ?? 0) * TWIPS_PER_POINT)), sheetContentWidthTwips(worksheet), Math.max(totalGridHeightTwips, Math.round((drawing?.heightPt ?? 0) * TWIPS_PER_POINT)), sheetContentHeightTwips(worksheet), {
+		rowTwips: fitRowTwips,
+		rowBreaks: fitRowBreaks,
+		titleTwips: fitTitleTwips,
+		colTwips: visibleWidths,
+		colBreaks: fitColBreaks
+	});
 	const scaled = printScale < .999;
-	const breakRows = new Set(worksheet.rowBreaks ?? []);
+	if (print.scaleSink) print.scaleSink.value = printScale;
+	const breakRows = new Set(honouredBreaks(worksheet, "rows"));
 	let textBudget = MAX_SHEET_TEXT_CHARS;
 	let textBudgetReported = false;
 	const runPropsByXf = /* @__PURE__ */ new Map();
@@ -284,22 +641,57 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 	const sparklineByCell = buildSparklineLookup(worksheet, print);
 	const tableFormatByCell = buildTableFormatLookup(worksheet);
 	const dropdownRanges = listDropdownRanges(worksheet.dataValidations);
+	const bandEndOfCol = /* @__PURE__ */ new Map();
+	{
+		const widthsForBands = scaledColumnWidths(visibleWidths, printScale, scaled);
+		const total = widthsForBands.reduce((sum, w) => sum + w, 0);
+		const breaks = /* @__PURE__ */ new Set();
+		for (const brk of worksheet.colBreaks ?? []) {
+			const local = brk - colStart;
+			if (local > 0 && local < colCount) breaks.add(local);
+		}
+		const wide = worksheet.fitToPage ? worksheet.pageSetup?.fitToWidth ?? 1 : 1;
+		const width = sheetContentWidthTwips(worksheet);
+		if (colCount > 1 && bandsAcross(worksheet, wide) && (total > width || breaks.size > 0)) for (const band of computeColumnBands(widthsForBands, width, breaks)) for (let i = band.start; i <= band.end; i++) bandEndOfCol.set(visibleCols[i] ?? i, visibleCols[band.end] ?? band.end);
+	}
 	const rows = [];
+	const rowNumbers = [];
+	let titleRowIndex = -1;
 	for (let r = 0; r < rowCount; r++) {
+		if (hiddenRows.has(r)) continue;
 		const absR = r + rowStart;
 		const cells = [];
 		const overflowed = /* @__PURE__ */ new Set();
+		const cellColumns = [];
+		const leftOverflow = [];
 		for (let c = 0; c < colCount; c++) {
-			if (overflowed.has(c)) continue;
+			if (hiddenCols.has(c) || overflowed.has(c)) continue;
 			const absC = c + colStart;
 			const merge = mergeOrigins.get(key(absR, absC));
 			if (insideMerge.has(key(absR, absC)) && !merge) {
 				const verticalParent = verticalMergeParent(worksheet.merges, absR, absC);
-				if (verticalParent && absC === verticalParent.startColumn) cells.push(makeVerticalContinuation(verticalParent, colWindowEnd, absR, rowWindowEnd));
+				if (verticalParent && absC === verticalParent.startColumn) {
+					const originCell = cellMatrix[verticalParent.startRow - rowStart]?.[verticalParent.startColumn - colStart];
+					const originXf = originCell ? styles.cellXfs[originCell.styleIndex ?? 0] : void 0;
+					const own = cellMatrix[r]?.[c];
+					const ownXf = own ? styles.cellXfs[own.styleIndex ?? 0] : void 0;
+					cells.push(makeVerticalContinuation(verticalParent, colWindowEnd, absR, rowWindowEnd, {
+						shading: originXf ? shadingFromXf(originXf, styles) : void 0,
+						borders: (ownXf ? bordersFromXf(ownXf, styles) : void 0) ?? (originXf ? bordersFromXf(originXf, styles) : void 0)
+					}));
+				}
 				continue;
 			}
 			const ws = cellMatrix[r]?.[c];
 			let text = ws ? resolveCellText(ws, sharedStrings, styles, date1904) : "";
+			if (ws?.type === "n" && ws.rawValue.length > 0 && (styles.cellXfs[ws.styleIndex ?? 0]?.numFmtId ?? 0) === 0) {
+				const unit = charTwips(styles.cellXfs[ws.styleIndex ?? 0], styles, textTwipsUnit);
+				const digit = charWidthUnits("0");
+				if (unit > 0 && digit > 0) {
+					const room = columnWidths[c] / unit;
+					text = generalToWidth(ws.rawValue, (candidate) => estimateChars(candidate) / digit <= room);
+				}
+			}
 			const cfText = text.length > 0 ? text : void 0;
 			if (text.length > textBudget) {
 				text = text.slice(0, Math.max(0, textBudget));
@@ -314,8 +706,15 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 				}
 			}
 			textBudget -= text.length;
-			const xf = ws && ws.styleIndex !== void 0 ? styles.cellXfs[ws.styleIndex] : void 0;
+			const xf = ws ? styles.cellXfs[ws.styleIndex ?? 0] : defaultStyleAt(absR, absC, styles.cellXfs);
 			let runProps = cellRunProps(xf);
+			if (ws?.type === "n" && xf?.numFmtId) {
+				const fmtColor = numberFormatColorHex(ws.rawValue, xf.numFmtId, styles.numFmts);
+				if (fmtColor !== void 0 && fmtColor !== runProps.colorHex) runProps = {
+					...runProps,
+					colorHex: fmtColor
+				};
+			}
 			const alignment = alignmentFromXf(xf, ws?.type);
 			let shading = xf ? shadingFromXf(xf, styles) : void 0;
 			const tableFmt = tableFormatByCell.get(key(absR, absC));
@@ -324,46 +723,74 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 				...runProps,
 				colorHex: tableFmt.fontColorHex
 			};
-			const borders = xf ? bordersFromXf(xf, styles) : void 0;
+			let borders = xf ? scaleBorders(bordersFromXf(xf, styles), printScale) : void 0;
 			let dataBar;
 			let icon;
 			const sparkline = sparklineByCell.get(key(absR, absC));
 			if (cfFormatter && ws) {
-				const over = cfFormatter(absR, absC, ws.type === "n" && Number.isFinite(Number(ws.rawValue)) ? Number(ws.rawValue) : void 0, cfText);
+				const blank = ws.rawValue.length === 0 && ws.inlineText === void 0;
+				const over = cfFormatter(absR, absC, ws.type === "n" && Number.isFinite(Number(ws.rawValue)) ? Number(ws.rawValue) : void 0, cfText, blank);
 				if (over) {
 					if (over.fillHex) shading = { colorHex: over.fillHex };
 					if (over.dataBar) dataBar = over.dataBar;
+					if (over.numberFormat !== void 0 && ws.type === "n" && ws.rawValue.length > 0) text = applyNumberFormat(ws.rawValue, CF_NUMBER_FORMAT_ID, new Map([[CF_NUMBER_FORMAT_ID, over.numberFormat]]), date1904);
+					if (over.hideValue) text = "";
 					if (over.icon) icon = over.icon;
+					if (over.border) borders = {
+						...borders,
+						...mapXlsxBorder(over.border)
+					};
 					runProps = applyCfOverride(runProps, over);
 				}
 			}
 			let overflowSpan = 1;
+			let paintColumns = 1;
+			let overflowRightRule;
 			const wrapText = xf?.alignment?.wrapText === true;
 			const rotation = xf?.alignment?.textRotation;
 			const rotated = rotation !== void 0 && rotation !== 0 && text.length > 0;
 			const shrinkToFit = xf?.alignment?.shrinkToFit === true && !wrapText && !rotated;
-			if (text.length > 0 && !merge && !wrapText && !rotated && !shrinkToFit && ws && (ws.type === "s" || ws.type === "str" || ws.type === "inlineStr") && alignment === "left") {
+			if (text.length > 0 && !merge && !wrapText && !rotated && !shrinkToFit && ws && (ws.type === "s" || ws.type === "str" || ws.type === "inlineStr") && (alignment === "left" || alignment === "center") && estimateChars(text) * charTwips(xf, styles, textTwipsUnit) > columnWidths[c]) {
 				let availTwips = columnWidths[c];
 				let cc = c + 1;
-				const neighbourIsFree = (col) => !cellHasContent(cellMatrix[r]?.[col]) && !cellPaintsSomething(cellMatrix[r]?.[col], styles) && !sparklineByCell.has(key(absR, col + colStart)) && !(dropdownRanges.length > 0 && rangesCover(dropdownRanges, absR, col + colStart));
-				while (cc < colCount && neighbourIsFree(cc)) {
-					availTwips += columnWidths[cc];
+				const neighbourIsFree = (col) => !cellHasContent(cellMatrix[r]?.[col]) && !insideMerge.has(key(absR, col + colStart)) && !mergeOrigins.has(key(absR, col + colStart)) && (!cellPaintsSomething(cellMatrix[r]?.[col], styles) || spanPreservesPaint(cellMatrix[r]?.[col], styles, shading, borders)) && !sparklineByCell.has(key(absR, col + colStart)) && !(dropdownRanges.length > 0 && rangesCover(dropdownRanges, absR, col + colStart));
+				const bandEnd = bandEndOfCol.get(c) ?? colCount - 1;
+				while (cc <= bandEnd && (hiddenCols.has(cc) || neighbourIsFree(cc))) {
+					if (!hiddenCols.has(cc)) availTwips += columnWidths[cc];
 					cc++;
 				}
-				if (cc < colCount) {
-					const charsFit = Math.max(1, Math.round(availTwips / 105));
-					if (text.length > charsFit) text = text.slice(0, charsFit);
+				if (cc <= bandEnd && !cellHasContent(cellMatrix[r]?.[cc]) && !sparklineByCell.has(key(absR, cc + colStart)) && !(dropdownRanges.length > 0 && rangesCover(dropdownRanges, absR, cc + colStart))) {
+					const rule = absorbableRightRule(cellMatrix[r]?.[cc], styles, shading, borders);
+					if (rule) {
+						availTwips += columnWidths[cc];
+						overflowRightRule = rule;
+						cc++;
+					}
 				}
+				text = clipToWidth(text, availTwips * 1.1, charTwips(xf, styles, textTwipsUnit));
 				if (cc > c + 1) {
-					overflowSpan = cc - c;
+					overflowSpan = 0;
+					for (let k = c; k < cc; k++) if (!hiddenCols.has(k)) overflowSpan++;
 					for (let k = c + 1; k < cc; k++) overflowed.add(k);
+					paintColumns = 1;
+					for (let k = c + 1; k < cc; k++) {
+						if (hiddenCols.has(k)) continue;
+						if (!cellPaintsSomething(cellMatrix[r]?.[k], styles)) break;
+						paintColumns++;
+					}
 				}
+			} else if (text.length > 0 && merge && !wrapText && !rotated && !shrinkToFit) {
+				const lastCol = Math.min(merge.endColumn - colStart, bandEndOfCol.get(c) ?? colCount - 1);
+				let availTwips = 0;
+				for (let k = c; k <= lastCol; k++) if (!hiddenCols.has(k)) availTwips += columnWidths[k] ?? 0;
+				text = clipToWidth(text, availTwips * 1.1, charTwips(xf, styles, textTwipsUnit));
 			}
 			if (shrinkToFit && ws && text.length > 0) {
-				const charsFit = Math.max(1, columnWidths[c] / 105);
-				if (text.length > charsFit) {
+				const drawnTwips = estimateChars(text) / charWidthUnits("0") * charTwips(xf, styles, textTwipsUnit);
+				const room = columnWidths[c];
+				if (drawnTwips > room) {
 					const baseHalfPt = (styles.fonts[xf.fontId]?.sizePt ?? 11) * 2;
-					const scaledHalfPt = Math.max(2, Math.round(baseHalfPt * charsFit / text.length));
+					const scaledHalfPt = Math.max(2, Math.floor(baseHalfPt * room / drawnTwips));
 					runProps = {
 						...runProps,
 						fontSizePt: halfPtToPt(scaledHalfPt)
@@ -373,15 +800,28 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 			const dropdown = dropdownRanges.length > 0 && rangesCover(dropdownRanges, absR, absC);
 			const href = print.hyperlinks && print.hyperlinks.length > 0 ? hyperlinkUrlAt(print.hyperlinks, absR, absC) : void 0;
 			const visibleEndCol = merge ? Math.min(merge.endColumn, colWindowEnd) : 0;
+			let mergeSpan = 0;
+			if (merge && visibleEndCol > merge.startColumn) {
+				for (let a = merge.startColumn; a <= visibleEndCol; a++) if (!hiddenCols.has(a - colStart)) mergeSpan++;
+			}
 			const properties = {
-				...merge && visibleEndCol > merge.startColumn ? { colSpan: visibleEndCol - merge.startColumn + 1 } : overflowSpan > 1 ? { colSpan: overflowSpan } : {},
+				...mergeSpan > 1 ? { colSpan: mergeSpan } : overflowSpan > 1 ? {
+					colSpan: overflowSpan,
+					paintColumns
+				} : {},
 				...merge && Math.min(merge.endRow, rowWindowEnd) > merge.startRow ? { merge: "start" } : {},
 				...shading ? { shading } : {},
 				...dataBar ? { dataBar } : {},
 				...icon ? { icon } : {},
 				...sparkline ? { sparkline } : {},
-				...borders ? { borders } : {},
-				...dropdown ? { dropdown: true } : {}
+				...borders || overflowRightRule ? { borders: {
+					...borders,
+					...overflowRightRule ? { right: overflowRightRule } : {}
+				} } : {},
+				...dropdown ? { dropdown: true } : {},
+				...!wrapText && !rotated ? { noWrap: true } : {},
+				...!wrapText && !rotated && !shrinkToFit && !merge && ws?.type === "n" && (xf?.numFmtId ?? 0) !== 0 && text.length > 0 && tooWideToShow(text, charTwips(xf, styles, textTwipsUnit), columnWidths[c]) ? { hashOnOverflow: true } : {},
+				verticalAlign: verticalAlignOf(xf)
 			};
 			const indentLevels = xf?.alignment?.indent ?? 0;
 			const baseParaProps = cellParaProps(alignment);
@@ -399,29 +839,49 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 				properties: runProps,
 				...href ? { href } : {}
 			}] : [];
-			const content = rotated ? stackedVerticalContent(text, runProps, href) : cellRuns.length === 0 ? [] : [{
+			const content = rotated ? stackedVerticalContent(text, runProps, href) : cellRuns.length === 0 ? [] : splitCellLines(cellRuns, wrapText).map((runs) => ({
 				kind: "paragraph",
 				paragraph: {
 					properties: paragraphProps,
-					runs: cellRuns
+					runs
 				}
-			}];
+			}));
+			if (text.length > 0 && !merge && !wrapText && !rotated && !shrinkToFit && c > 0 && alignment === "right" && estimateChars(text) * charTwips(xf, styles, textTwipsUnit) > columnWidths[c]) leftOverflow.push({
+				index: cells.length,
+				column: c,
+				needTwips: estimateChars(text) * charTwips(xf, styles, textTwipsUnit) - columnWidths[c],
+				shading,
+				borders
+			});
+			cellColumns.push(c);
 			cells.push({
 				properties,
 				content
 			});
 		}
+		absorbLeftwards(cells, cellColumns, leftOverflow, styles, (col) => {
+			if (insideMerge.has(key(absR, col)) || mergeOrigins.has(key(absR, col))) return void 0;
+			if (sparklineByCell.has(key(absR, col + colStart))) return void 0;
+			if (dropdownRanges.length > 0 && rangesCover(dropdownRanges, absR, col + colStart)) return;
+			if (cellHasContent(cellMatrix[r]?.[col])) return void 0;
+			return {
+				cell: cellMatrix[r]?.[col],
+				widthTwips: columnWidths[col]
+			};
+		});
 		const baseRowProps = rowHeightMap.get(r);
 		const rowHeightTwips = scaled && baseRowProps !== void 0 ? Math.max(1, Math.round(baseRowProps.heightTwips * printScale)) : baseRowProps?.heightTwips;
 		const isTitleRow = print.titleRows !== void 0 && absR >= print.titleRows.startRow && absR <= print.titleRows.endRow;
 		const rowProps = {
 			...rowHeightTwips !== void 0 ? {
 				height: twipsToPt(rowHeightTwips),
-				heightRule: "atLeast"
+				heightRule: baseRowProps?.heightRule ?? "atLeast"
 			} : {},
 			...isTitleRow ? { isHeader: true } : {},
 			...breakRows.has(absR) ? { pageBreakBefore: true } : {}
 		};
+		if (isTitleRow && titleRowIndex < 0) titleRowIndex = rows.length;
+		rowNumbers.push(absR + 1);
 		rows.push({
 			properties: rowProps,
 			cells
@@ -429,13 +889,14 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 	}
 	const thin = {
 		style: "single",
-		width: eighthPtToPt(4)
+		width: eighthPtToPt(2),
+		colorHex: PRINT_GRIDLINE_HEX
 	};
 	const centered = worksheet.printOptions?.horizontalCentered === true;
 	const tableProperties = {
 		defaultCellMargins: {
-			left: pt(EXCEL_CELL_INSET_PT),
-			right: pt(EXCEL_CELL_INSET_PT),
+			left: pt(EXCEL_CELL_INSET_PT * printScale),
+			right: pt(EXCEL_CELL_INSET_PT * printScale),
 			top: pt(0),
 			bottom: pt(0)
 		},
@@ -457,16 +918,42 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 		if (local > 0 && local < colCount) colBreaksLocal.add(local);
 	}
 	const fitWide = worksheet.fitToPage ? worksheet.pageSetup?.fitToWidth ?? 1 : 1;
-	const bandWidths = scaled ? columnWidths.map((w) => Math.max(1, Math.floor(w * printScale))) : columnWidths;
+	const bandWidths = scaledColumnWidths(visibleWidths, printScale, scaled);
 	const bandTotal = bandWidths.reduce((sum, w) => sum + w, 0);
-	if (colCount > 1 && (!scaled || fitWide > 1) && (bandTotal > contentWidthTwips || colBreaksLocal.size > 0)) {
+	if (colCount > 1 && bandsAcross(worksheet, fitWide) && (bandTotal > contentWidthTwips || colBreaksLocal.size > 0)) {
 		const bands = computeColumnBands(bandWidths, contentWidthTwips, colBreaksLocal);
-		if (bands.length > 1) return bandedTables(rows, bandWidths, bands, tableProperties);
+		if (bands.length > 1) {
+			if (print.bandSink) print.bandSink.lefts = bands.map((band) => twipsToPt(bandWidths.slice(0, band.start).reduce((sum, w) => sum + w, 0)));
+			return bandedTables(rows, bandWidths, bands, tableProperties, titleRowIndex, Math.round((print.drawingExtentPt?.widthPt ?? 0) * TWIPS_PER_POINT * printScale), worksheet.printOptions?.headings ? {
+				colStart,
+				rowNumbers
+			} : void 0);
+		}
 	}
 	const frozen = worksheet.pane && (worksheet.pane.frozenRows > 0 || worksheet.pane.frozenCols > 0) ? {
 		rows: worksheet.pane.frozenRows,
 		cols: worksheet.pane.frozenCols
 	} : void 0;
+	if (titleRowIndex > 0 && titleRowIndex < rows.length) {
+		const titleStart = titleRowIndex;
+		const grid = bandWidths.map((w) => twipsToPt(w));
+		return [{
+			kind: "table",
+			table: {
+				properties: tableProperties,
+				grid,
+				rows: rows.slice(0, titleStart)
+			}
+		}, {
+			kind: "table",
+			table: {
+				properties: tableProperties,
+				grid,
+				rows: rows.slice(titleStart)
+			}
+		}];
+	}
+	const headed = worksheet.printOptions?.headings ? withHeadingBand(rows, bandWidths, colStart, rowNumbers) : void 0;
 	return [{
 		kind: "table",
 		table: {
@@ -474,20 +961,22 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 				...tableProperties,
 				frozen
 			} : tableProperties,
-			grid: bandWidths.map((w) => twipsToPt(w)),
-			rows
+			grid: (headed?.widths ?? bandWidths).map((w) => twipsToPt(w)),
+			rows: headed?.rows ?? rows
 		}
 	}];
 }
 function verticalMergeParent(merges, row, column) {
 	for (const m of merges) if (column >= m.startColumn && column <= m.endColumn && row > m.startRow && row <= m.endRow && m.endRow > m.startRow) return m;
 }
-function makeVerticalContinuation(merge, colWindowEnd, absR, rowWindowEnd) {
+function makeVerticalContinuation(merge, colWindowEnd, absR, rowWindowEnd, paint) {
 	const span = Math.min(merge.endColumn, colWindowEnd) - merge.startColumn + 1;
 	return {
 		properties: {
 			merge: absR < Math.min(merge.endRow, rowWindowEnd) ? "middle" : "end",
-			...span > 1 ? { colSpan: span } : {}
+			...span > 1 ? { colSpan: span } : {},
+			...paint.shading ? { shading: paint.shading } : {},
+			...paint.borders ? { borders: paint.borders } : {}
 		},
 		content: [{
 			kind: "paragraph",
@@ -518,16 +1007,17 @@ function resolveCellText(cell, sharedStrings, styles, date1904) {
 	}
 	if (cell.type === "b") return cell.rawValue === "1" ? "TRUE" : "FALSE";
 	if (cell.type === "str" || cell.type === "e" || cell.type === "d") return cell.rawValue;
-	const numFmtId = (cell.styleIndex !== void 0 ? styles.cellXfs[cell.styleIndex] : void 0)?.numFmtId ?? 0;
+	const numFmtId = styles.cellXfs[cell.styleIndex ?? 0]?.numFmtId ?? 0;
 	return applyNumberFormat(cell.rawValue, numFmtId, styles.numFmts, date1904);
 }
 function runPropsFromXf(xf, styles) {
-	if (!xf.applyFont && xf.fontId === 0) return {};
 	const font = styles.fonts[xf.fontId];
 	if (!font) return {};
 	const props = {};
 	if (font.bold) props.bold = true;
 	if (font.italic) props.italic = true;
+	if (font.underline) props.underline = "single";
+	if (font.strike) props.strike = true;
 	if (font.sizePt !== void 0) props.fontSizePt = halfPtToPt(Math.round(font.sizePt * 2));
 	if (font.colorHex) props.colorHex = font.colorHex;
 	return props;
@@ -549,9 +1039,10 @@ function stackedVerticalContent(text, runProps, href) {
 }
 function richRunProps(base, rr) {
 	const out = { ...base };
-	if (rr.bold) out.bold = true;
-	if (rr.italic) out.italic = true;
+	if (rr.bold !== void 0) out.bold = rr.bold;
+	if (rr.italic !== void 0) out.italic = rr.italic;
 	if (rr.underline) out.underline = "single";
+	if (rr.strike !== void 0) out.strike = rr.strike;
 	if (rr.colorHex) out.colorHex = rr.colorHex;
 	if (rr.sizePt !== void 0) out.fontSizePt = halfPtToPt(Math.round(rr.sizePt * 2));
 	if (rr.vertAlign) out.verticalAlign = rr.vertAlign;
@@ -562,7 +1053,8 @@ function applyCfOverride(base, o) {
 		...base,
 		...o.fontColorHex ? { colorHex: o.fontColorHex } : {},
 		...o.bold !== void 0 ? { bold: o.bold } : {},
-		...o.italic !== void 0 ? { italic: o.italic } : {}
+		...o.italic !== void 0 ? { italic: o.italic } : {},
+		...o.strike !== void 0 ? { strike: o.strike } : {}
 	};
 }
 /**
@@ -668,6 +1160,42 @@ function bordersFromXf(xf, styles) {
 	}
 	return Object.keys(out).length > 0 ? out : void 0;
 }
+/** An {@link XlsxBorder}'s four edges as {@link CellBorders} — a dxf's, or a cell's. */
+function mapXlsxBorder(border) {
+	const out = {};
+	const top = mapBorderEdge(border.top);
+	const right = mapBorderEdge(border.right);
+	const bottom = mapBorderEdge(border.bottom);
+	const left = mapBorderEdge(border.left);
+	if (top) out.top = top;
+	if (right) out.right = right;
+	if (bottom) out.bottom = bottom;
+	if (left) out.left = left;
+	return out;
+}
+/** Every edge of a cell's box, at the print scale. */
+function scaleBorders(borders, scale) {
+	if (!borders || scale >= .999) return borders;
+	const edge = (b) => b === void 0 || b.width === void 0 ? b : {
+		...b,
+		width: pt(b.width * scale)
+	};
+	const out = {};
+	for (const side of [
+		"top",
+		"right",
+		"bottom",
+		"left",
+		"insideH",
+		"insideV"
+	]) {
+		const e = edge(borders[side]);
+		if (e) out[side] = e;
+	}
+	if (borders.diagonalUp !== void 0) out.diagonalUp = borders.diagonalUp;
+	if (borders.diagonalDown !== void 0) out.diagonalDown = borders.diagonalDown;
+	return out;
+}
 function mapBorderEdge(edge) {
 	if (!edge || !edge.style || edge.style === "none") return void 0;
 	const { style, sizeEighthPt } = mapBorderStyle(edge.style);
@@ -681,41 +1209,56 @@ function mapBorderStyle(style) {
 	switch (style) {
 		case "hair": return {
 			style: "single",
-			sizeEighthPt: 2
+			sizeEighthPt: 3
 		};
 		case "thin": return {
 			style: "single",
-			sizeEighthPt: 4
+			sizeEighthPt: 6
+		};
+		case "medium": return {
+			style: "single",
+			sizeEighthPt: 12
+		};
+		case "mediumDashed": return {
+			style: "dashed",
+			sizeEighthPt: 12
 		};
-		case "medium":
-		case "mediumDashed":
 		case "mediumDashDot":
+		case "slantDashDot": return {
+			style: "dashDot",
+			sizeEighthPt: 12
+		};
 		case "mediumDashDotDot": return {
-			style: "single",
-			sizeEighthPt: 8
+			style: "dashDotDot",
+			sizeEighthPt: 12
 		};
 		case "thick": return {
 			style: "thick",
-			sizeEighthPt: 12
+			sizeEighthPt: 18
 		};
-		case "dashed":
-		case "dashDot":
-		case "dashDotDot":
-		case "slantDashDot": return {
-			style: "dashed",
-			sizeEighthPt: 4
+		case "dashed": return {
+			style: "dashSmallGap",
+			sizeEighthPt: 6
+		};
+		case "dashDot": return {
+			style: "dashDot",
+			sizeEighthPt: 6
+		};
+		case "dashDotDot": return {
+			style: "dashDotDot",
+			sizeEighthPt: 6
 		};
 		case "dotted": return {
 			style: "dotted",
-			sizeEighthPt: 4
+			sizeEighthPt: 6
 		};
 		case "double": return {
 			style: "double",
-			sizeEighthPt: 4
+			sizeEighthPt: 18
 		};
 		default: return {
 			style: "single",
-			sizeEighthPt: 4
+			sizeEighthPt: 6
 		};
 	}
 }
@@ -890,12 +1433,290 @@ function lastContentColumn(worksheet, rowStart, rowCount, colStart, colCount) {
 * Such a cell cannot be swallowed by a neighbour's overflowing text: the span
 * that gives the text its width would take the paint with it.
 */
+/**
+* Whether a cell puts anything VISIBLE on an otherwise-empty page.
+*
+* The difference from {@link cellPaintsSomething} is white: a solid fill in the
+* paper's own colour paints nothing a reader can see, and a sheet of them is a
+* blank sheet. bnc762542.xlsx is 176 such cells — `fgColor indexed="9"`, the
+* legacy palette's white — with every word it prints living in a callout, and
+* both references print the callout on a bare page. 48779.xlsx is one cell of
+* solid red, and both print the swatch.
+*
+* @param cell   The cell, or undefined.
+* @param styles The workbook's style tables.
+* @returns True when the cell draws something the eye can find.
+*/
+function cellPaintsVisibly(cell, styles) {
+	if (!cell || cell.styleIndex === void 0) return false;
+	const xf = styles.cellXfs[cell.styleIndex];
+	if (!xf) return false;
+	if (bordersFromXf(xf, styles) !== void 0) return true;
+	const shading = shadingFromXf(xf, styles);
+	return shading !== void 0 && shading.colorHex.toUpperCase() !== "FFFFFF";
+}
 function cellPaintsSomething(cell, styles) {
 	if (!cell || cell.styleIndex === void 0) return false;
 	const xf = styles.cellXfs[cell.styleIndex];
 	if (!xf) return false;
 	return shadingFromXf(xf, styles) !== void 0 || bordersFromXf(xf, styles) !== void 0;
 }
+/**
+* How many empty columns past the used range the last column's text needs to
+* run into, bounded by the printable width (Excel stops at the page edge too).
+*
+* Only the last used column can want them — anywhere else the grid already has
+* neighbours. Zero for the overwhelming majority of sheets, which keeps their
+* projection exactly as it was.
+*/
+function overflowColumnsPastUsedRange(worksheet, usedCol, sharedStrings, styles, date1904, charTwipsUnit) {
+	const defaultTwips = defaultColumnTwips(worksheet, charTwipsUnit, DEFAULT_COL_CHARS);
+	const widthOf = (abs) => {
+		for (const col of worksheet.columns) {
+			if (abs < col.min - 1 || abs > col.max - 1) continue;
+			return col.hidden ? 0 : columnTwips(col.widthChars, charTwipsUnit);
+		}
+		return defaultTwips;
+	};
+	const lastOfRow = /* @__PURE__ */ new Map();
+	for (const cell of worksheet.cells) {
+		if (!cellHasContent(cell)) continue;
+		const prev = lastOfRow.get(cell.row);
+		if (!prev || cell.column > prev.column) lastOfRow.set(cell.row, cell);
+	}
+	let needTwips = 0;
+	for (const cell of lastOfRow.values()) {
+		if (!(cell.type === "s" || cell.type === "str" || cell.type === "inlineStr")) continue;
+		const xf = styles.cellXfs[cell.styleIndex ?? 0];
+		const align = xf?.alignment;
+		if (align?.wrapText || align?.shrinkToFit || align?.textRotation) continue;
+		if (alignmentFromXf(xf, cell.type) !== "left") continue;
+		let room = 0;
+		for (let abs = cell.column; abs <= usedCol; abs++) room += widthOf(abs);
+		const text = resolveCellText(cell, sharedStrings, styles, date1904);
+		needTwips = Math.max(needTwips, estimateChars(text) * charTwips(xf, styles, 105) - room);
+	}
+	if (needTwips <= 0) return 0;
+	let gridTwips = 0;
+	for (let abs = 0; abs <= usedCol; abs++) gridTwips += widthOf(abs);
+	const limit = sheetContentWidthTwips(worksheet);
+	const MAX_OVERFLOW_COLS = 256;
+	let extra = 0;
+	while (needTwips > 0 && extra < MAX_OVERFLOW_COLS) {
+		const w = widthOf(usedCol + extra + 1);
+		if (w <= 0 || gridTwips + w > limit) break;
+		gridTwips += w;
+		needTwips -= w;
+		extra++;
+	}
+	return extra;
+}
+/** Column widths as the bands see them: shrunk by the print scale, floor-rounded. */
+function scaledColumnWidths(widths, printScale, scaled) {
+	return scaled ? widths.map((w) => Math.max(1, Math.floor(w * printScale))) : [...widths];
+}
+/**
+* Break a cell's runs at the hard line breaks inside them, or — for a cell that
+* does not wrap, and so shows one line — drop those breaks.
+*
+* Dropped, not turned into a space. A line feed is a control character with no
+* width of its own: switch wrapping off in Excel and the two lines run
+* together, which is the complaint behind every "my Alt+Enter disappeared"
+* question. preserve_space.xlsx holds a bold "123", a break and a plain "456",
+* and the reference prints "123456" where we printed "123 456" — a space the
+* document does not contain.
+*/
+function splitCellLines(runs, wrapText) {
+	if (!runs.some((r) => /[\r\n]/.test(r.text))) return [[...runs]];
+	if (!wrapText) return [runs.map((r) => ({
+		...r,
+		text: r.text.replace(/[\r\n]+/g, "")
+	}))];
+	const lines = [[]];
+	for (const run of runs) {
+		const parts = run.text.split(/\r\n|\r|\n/);
+		for (let i = 0; i < parts.length; i++) {
+			if (i > 0) lines.push([]);
+			const text = parts[i];
+			if (text.length > 0) lines[lines.length - 1].push({
+				...run,
+				text
+			});
+		}
+	}
+	return lines.some((l) => l.length > 0) ? lines : [];
+}
+/** §18.8.1 `<alignment vertical>`, defaulting to Excel's bottom. */
+function verticalAlignOf(xf) {
+	const v = xf?.alignment?.vertical;
+	if (v === "top") return "top";
+	if (v === "center") return "center";
+	if (v === "justify" || v === "distributed") return "top";
+	return "bottom";
+}
+/**
+* The width of one character of a cell's own font, in twips.
+*
+* {@link TWIPS_PER_EXCEL_CHAR} is the Maximum Digit Width of the DEFAULT 11pt
+* font, and column widths are measured in exactly those units — but the text
+* inside a cell is not necessarily written in it. Measuring a 7pt annotation by
+* the 11pt yardstick makes it read as half again as wide as it is, and the
+* overflow clip then cuts it in the middle of a word: tdf171828.xlsx lost the
+* "eff. Zins =" half of a label that fits its band perfectly well.
+*/
+function charTwips(xf, styles, unit) {
+	const sizePt = (xf ? styles.fonts[xf.fontId]?.sizePt : void 0) ?? DEFAULT_FONT_PT;
+	if (!Number.isFinite(sizePt) || sizePt <= 0) return unit;
+	return unit * sizePt / DEFAULT_FONT_PT;
+}
+var NARROW_CHARS = /* @__PURE__ */ new Set(" .,:;'\"!|il");
+var SEMI_NARROW_CHARS = /* @__PURE__ */ new Set("ftr()[]{}-/\\");
+var WIDE_CHARS = /* @__PURE__ */ new Set("MWmw@%");
+function isFullWidth(code) {
+	return code >= 4352 && code <= 4447 || code >= 11904 && code <= 12350 || code >= 12353 && code <= 13311 || code >= 13312 && code <= 19903 || code >= 19968 && code <= 40959 || code >= 40960 && code <= 42191 || code >= 43360 && code <= 43391 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65040 && code <= 65135 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 131072 && code <= 262141;
+}
+function charWidthUnits(ch) {
+	if (NARROW_CHARS.has(ch)) return .53;
+	if (SEMI_NARROW_CHARS.has(ch)) return .71;
+	if (WIDE_CHARS.has(ch)) return 1.77;
+	if (ch >= "a" && ch <= "z") return 1.12;
+	if (ch >= "A" && ch <= "Z") return 1.36;
+	const code = ch.codePointAt(0);
+	if (code !== void 0 && isFullWidth(code)) return 2;
+	return 1.18;
+}
+/**
+* Whether a number is too wide for its column to show it at all — the test
+* behind {@link CellProperties.hashOnOverflow}.
+*
+* Two corrections separate this from the clipping estimate, and both are about
+* how destructive the answer is. Filling a cell with `#` erases the value, so
+* the test has to be sure.
+*
+* `charWidthUnits` measures in the font we DRAW in, expressed in Excel's unit —
+* right for deciding what fits on the page, wrong for deciding what the
+* document itself considers too wide, since §18.3.1.13 defines that unit AS the
+* digit's width. Dividing by our own digit puts the text back in the document's
+* terms: a face 18 % wider than the workbook's would otherwise hash a column of
+* dates that every other reader shows (forum-mso-de-104083.xlsx).
+*
+* And then a tenth of headroom, because the estimate is an estimate. A value
+* that overruns by one percent is a value we should draw and let the cell clip;
+* only one that plainly cannot fit earns the hashes.
+*/
+function tooWideToShow(text, perCharTwips, columnTwips) {
+	const digit = charWidthUnits("0");
+	if (!(digit > 0) || !(perCharTwips > 0)) return false;
+	return estimateChars(text) / digit * perCharTwips > columnTwips * 1.1;
+}
+/** Width of `text` in column-width units, estimated character by character. */
+function estimateChars(text) {
+	let n = 0;
+	for (const ch of text) n += charWidthUnits(ch);
+	return n;
+}
+/** The longest prefix of `text` that fits `availTwips`, by the same estimate. */
+function clipToWidth(text, availTwips, perChar) {
+	if (perChar <= 0) return text;
+	const budget = availTwips / perChar;
+	let used = 0;
+	let i = 0;
+	for (const ch of text) {
+		const w = charWidthUnits(ch);
+		if (used + w > budget) break;
+		used += w;
+		i += ch.length;
+	}
+	return i >= text.length ? text : text.slice(0, Math.max(1, i));
+}
+/**
+* Widen each right-aligned cell that overflows leftwards over the free columns
+* before it, deleting the cells those columns produced.
+*
+* The mirror of the rightward overflow the row loop does inline, but it cannot
+* be done inline: the space a right-aligned cell needs lies behind it, in cells
+* already emitted. Same freeness rule as rightwards — nothing in the column,
+* and nothing painted there that the span would erase.
+*/
+function absorbLeftwards(cells, cellColumns, candidates, styles, neighbourAt) {
+	for (let k = candidates.length - 1; k >= 0; k--) {
+		const cand = candidates[k];
+		let need = cand.needTwips;
+		let first = cand.index;
+		while (first > 0 && need > 0) {
+			const prev = first - 1;
+			const col = cellColumns[prev];
+			if ((cells[prev].properties.colSpan ?? 1) !== 1) break;
+			if (cellColumns[first] !== col + 1) break;
+			const free = neighbourAt(col);
+			if (!free) break;
+			if (!spanPreservesPaint(free.cell, styles, cand.shading, cand.borders)) break;
+			need -= free.widthTwips;
+			first = prev;
+		}
+		if (first === cand.index) continue;
+		const span = cand.index - first + 1;
+		const cell = cells[cand.index];
+		cells.splice(first, span, {
+			...cell,
+			properties: {
+				...cell.properties,
+				colSpan: (cell.properties.colSpan ?? 1) + span - 1
+			}
+		});
+		cellColumns.splice(first, span, cellColumns[first]);
+	}
+}
+/**
+* Whether spanning a cell's overflowing text across `neighbour` would leave the
+* page looking the same as drawing over it would.
+*
+* A span paints the ORIGIN's fill and the ORIGIN's outer borders across the
+* whole run, so it is lossless exactly when the neighbour's fill already
+* matches, the neighbour carries no vertical rule of its own to erase, and its
+* horizontal edges are the ones the origin will redraw anyway. A block of empty
+* cells continuing a filled, top-ruled band — which is what a decorated
+* neighbour almost always is — passes; a differently filled or boxed cell does
+* not, and the text is clipped short of it instead.
+*/
+function spanPreservesPaint(neighbour, styles, shading, borders) {
+	if (!neighbour || neighbour.styleIndex === void 0) return true;
+	const xf = styles.cellXfs[neighbour.styleIndex];
+	if (!xf) return true;
+	if (shadingFromXf(xf, styles)?.colorHex !== shading?.colorHex) return false;
+	const nb = bordersFromXf(xf, styles);
+	if (!nb) return true;
+	if (nb.left || nb.right || nb.insideV || nb.diagonalUp || nb.diagonalDown) return false;
+	return sameBorder(nb.top, borders?.top) && sameBorder(nb.bottom, borders?.bottom);
+}
+function sameBorder(a, b) {
+	if (a === void 0 || b === void 0) return a === b;
+	return a.style === b.style && a.width === b.width && a.colorHex === b.colorHex;
+}
+/**
+* The right rule a neighbour carries when that rule is the ONLY thing standing
+* between it and the overflowing text — in which case the span can simply adopt
+* it as its own right border and nothing is lost.
+*
+* {@link spanPreservesPaint} refuses any vertical rule, which is right for a
+* rule INSIDE the run (a span erases it) but wrong for the one that closes it:
+* the last cell's right edge is the boundary of the band the origin sits in,
+* and the span's own right border lands in exactly the same place. Refusing it
+* cut five labels short on every page of tdf171828.xlsx — "ohne Sondertilgung"
+* as "ohne Sondertil" — where the reference runs each of them to that very
+* edge.
+*/
+function absorbableRightRule(neighbour, styles, shading, borders) {
+	if (!neighbour || neighbour.styleIndex === void 0) return void 0;
+	const xf = styles.cellXfs[neighbour.styleIndex];
+	if (!xf) return void 0;
+	if (shadingFromXf(xf, styles)?.colorHex !== shading?.colorHex) return void 0;
+	const nb = bordersFromXf(xf, styles);
+	if (!nb?.right) return void 0;
+	if (nb.left || nb.insideV || nb.diagonalUp || nb.diagonalDown) return void 0;
+	if (!sameBorder(nb.top, borders?.top) || !sameBorder(nb.bottom, borders?.bottom)) return;
+	return nb.right;
+}
 var SLICER_WIDTH_PT = 108;
 var SLICER_ROW_PT = 16;
 var SLICER_UNSELECTED_HEX = "F2F2F2";
@@ -910,7 +1731,8 @@ function slicerTable(slicer) {
 	const colWidthPt = SLICER_WIDTH_PT / cols;
 	const thin = {
 		style: "single",
-		width: eighthPtToPt(4)
+		width: eighthPtToPt(2),
+		colorHex: PRINT_GRIDLINE_HEX
 	};
 	const rowProps = {
 		height: pt(SLICER_ROW_PT),
@@ -979,4 +1801,4 @@ function slicerParagraph(text, runProps) {
 	};
 }
 //#endregion
-export { resolveCellText, resolvePrintArea, resolvePrintTitleRows, sectionFromWorksheet, slicerTable, worksheetToBody };
+export { cellPaintsVisibly, columnTwips, printableHeightPt, printableWidthPt, resolveCellText, resolvePrintArea, resolvePrintTitleRows, sectionFromWorksheet, slicerTable, worksheetToBody };