documonster 0.7.0 → 0.8.0

package/dist/iife/documonster.pdf.iife.js

@@ -1,5 +1,5 @@
 /*!
-* documonster v0.7.0
+* documonster v0.8.0
 * Zero-dependency TypeScript toolkit for Excel, Word, PDF, CSV, Markdown, XML & ZIP — one API across Node.js, Bun & browsers.
 * (c) 2026 cjnoname
 * Released under the Apache-2.0 License
@@ -1814,34 +1814,60 @@ this.Documonster = this.Documonster || {};
 	* Write an image XObject (JPEG or PNG) to the writer.
 	* Returns the allocated object number.
 	*/
-	function writeImageXObject(writer, data, format) {
-		if (format === "png") return writePngImageXObject(writer, data);
-		return writeJpegImageXObject(writer, data);
+	function writeImageXObject(writer, data, format, grayscale = false) {
+		if (format === "png") return writePngImageXObject(writer, data, grayscale);
+		return writeJpegImageXObject(writer, data, grayscale);
 	}
 	/**
-	* Write a JPEG image using DCTDecode (raw JPEG data embedded directly).
+	* Write the PostScript calculator function that converts an RGB triple to its
+	* Rec. 601 luma, and return its object number.
+	*
+	* Used as the tint transform of a `/DeviceN` space so a JPEG can be recoloured
+	* without decoding it: the samples stay untouched and the consumer applies the
+	* transform per pixel. Unlike painting a blend on top, this cannot darken
+	* transparent areas, because it *is* the color space rather than an overlay.
 	*/
-	function writeJpegImageXObject(writer, data) {
+	function writeLumaTintTransform(writer) {
 		const objNum = writer.allocObject();
+		const dict = new PdfDict().set("FunctionType", "4").set("Domain", "[0 1 0 1 0 1]").set("Range", "[0 1]");
+		writer.addStreamObject(objNum, dict, new TextEncoder().encode("{ 0.114 mul exch 0.587 mul add exch 0.299 mul add }"));
+		return objNum;
+	}
+	/**
+	* Write a JPEG image using DCTDecode (raw JPEG data embedded directly).
+	*/
+	function writeJpegImageXObject(writer, data, grayscale = false) {
 		const dims = parseJpegDimensions(data);
-		const dict = new PdfDict().set("Type", "/XObject").set("Subtype", "/Image").set("Width", pdfNumber(dims.width)).set("Height", pdfNumber(dims.height)).set("ColorSpace", "/DeviceRGB").set("BitsPerComponent", "8").set("Filter", "/DCTDecode");
+		const tintRef = grayscale ? writeLumaTintTransform(writer) : void 0;
+		const objNum = writer.allocObject();
+		const dict = new PdfDict().set("Type", "/XObject").set("Subtype", "/Image").set("Width", pdfNumber(dims.width)).set("Height", pdfNumber(dims.height)).set("ColorSpace", tintRef === void 0 ? "/DeviceRGB" : `[/DeviceN [/C1 /C2 /C3] /DeviceGray ${pdfRef(tintRef)}]`).set("BitsPerComponent", "8").set("Filter", "/DCTDecode");
 		writer.addStreamObject(objNum, dict, data);
 		return objNum;
 	}
+	/** Rec. 601 luma of an 8-bit RGB triple. */
+	function lumaByte(r, g, b) {
+		return Math.round(.299 * r + .587 * g + .114 * b);
+	}
 	/**
 	* Write a PNG image: decode to raw RGB, create SMask for alpha if needed.
 	*/
-	function writePngImageXObject(writer, data) {
+	function writePngImageXObject(writer, data, grayscale = false) {
 		const png = decodePng(data);
 		const objNum = writer.allocObject();
-		const dict = new PdfDict().set("Type", "/XObject").set("Subtype", "/Image").set("Width", pdfNumber(png.width)).set("Height", pdfNumber(png.height)).set("ColorSpace", "/DeviceRGB").set("BitsPerComponent", pdfNumber(png.bitsPerComponent));
+		let pixels = png.pixels;
+		if (grayscale) {
+			const gray = new Uint8Array(png.width * png.height);
+			for (let i = 0, p = 0; i < gray.length; i++, p += 3) gray[i] = lumaByte(pixels[p], pixels[p + 1], pixels[p + 2]);
+			pixels = gray;
+		}
+		const dict = new PdfDict().set("Type", "/XObject").set("Subtype", "/Image").set("Width", pdfNumber(png.width)).set("Height", pdfNumber(png.height)).set("ColorSpace", grayscale ? "/DeviceGray" : "/DeviceRGB").set("BitsPerComponent", pdfNumber(png.bitsPerComponent));
 		if (png.alpha) {
 			const smaskObjNum = writer.allocObject();
 			const smaskDict = new PdfDict().set("Type", "/XObject").set("Subtype", "/Image").set("Width", pdfNumber(png.width)).set("Height", pdfNumber(png.height)).set("ColorSpace", "/DeviceGray").set("BitsPerComponent", "8");
 			writer.addStreamObject(smaskObjNum, smaskDict, png.alpha);
 			dict.set("SMask", pdfRef(smaskObjNum));
 		}
-		writer.addStreamObject(objNum, dict, png.pixels);
+		writer.addStreamObject(objNum, dict, pixels);
 		return objNum;
 	}
 	var init_image_utils = __esmMin((() => {
@@ -3821,6 +3847,7 @@ this.Documonster = this.Documonster || {};
 				const mediaBox = `[0 0 ${pdfNumber(options.width)} ${pdfNumber(options.height)}]`;
 				const contentsValue = typeof options.contentsRef === "string" ? options.contentsRef : pdfRef(options.contentsRef);
 				const dict = new PdfDict().set("Type", "/Page").set("Parent", pdfRef(options.parentRef)).set("MediaBox", mediaBox).set("Contents", contentsValue).set("Resources", pdfRef(options.resourcesRef));
+				if (options.transparencyGroup) dict.set("Group", "<< /S /Transparency /CS /DeviceRGB /I false /K false >>");
 				if (options.annotRefs && options.annotRefs.length > 0) dict.set("Annots", "[" + options.annotRefs.map((r) => pdfRef(r)).join(" ") + "]");
 				this.addObject(objNum, dict);
 				return objNum;
@@ -31020,10 +31047,488 @@ this.Documonster = this.Documonster || {};
 	}));
 	//#endregion
 	//#region src/modules/pdf/render/constants.ts
-	var LINE_HEIGHT_FACTOR, PX_TO_PT;
+	var LINE_HEIGHT_FACTOR, PX_TO_PT, HEADING_FILL, HEADING_RULE, HEADING_TEXT, FIT_MIN_SCALE, COMMENT_FILL, COMMENT_BORDER, COMMENT_MARKER_COLOR, COLUMN_FIT_EPSILON;
 	var init_constants = __esmMin((() => {
 		LINE_HEIGHT_FACTOR = 1.2;
 		PX_TO_PT = 72 / 96;
+		HEADING_FILL = {
+			r: .94,
+			g: .94,
+			b: .94
+		};
+		HEADING_RULE = {
+			r: .6,
+			g: .6,
+			b: .6
+		};
+		HEADING_TEXT = {
+			r: .2,
+			g: .2,
+			b: .2
+		};
+		FIT_MIN_SCALE = .1;
+		COMMENT_FILL = {
+			r: 1,
+			g: 1,
+			b: .88
+		};
+		COMMENT_BORDER = {
+			r: .4,
+			g: .4,
+			b: .4
+		};
+		COMMENT_MARKER_COLOR = {
+			r: .8,
+			g: 0,
+			b: 0
+		};
+		COLUMN_FIT_EPSILON = .01;
+	}));
+	//#endregion
+	//#region src/utils/theme-colors.ts
+	/**
+	* Parse a hex colour string into 0–1 float RGB components.
+	*
+	* Accepts `RRGGBB` (6 digits), `AARRGGBB` (8 digits, alpha first — the form
+	* Excel uses for cell fills), and `RGB` (3 digits, CSS shorthand). A leading
+	* `#` is tolerated. Returns `null` for anything else.
+	*/
+	function hexToRgb01(hex) {
+		if (!hex) return null;
+		let h = hex.startsWith("#") ? hex.slice(1) : hex;
+		if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+		let a = 255;
+		let rHex;
+		let gHex;
+		let bHex;
+		if (h.length === 8) {
+			a = parseInt(h.slice(0, 2), 16);
+			rHex = h.slice(2, 4);
+			gHex = h.slice(4, 6);
+			bHex = h.slice(6, 8);
+		} else if (h.length === 6) {
+			rHex = h.slice(0, 2);
+			gHex = h.slice(2, 4);
+			bHex = h.slice(4, 6);
+		} else return null;
+		const r = parseInt(rHex, 16);
+		const g = parseInt(gHex, 16);
+		const b = parseInt(bHex, 16);
+		if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(a)) return null;
+		const alpha = a / 255;
+		return alpha < 1 ? {
+			r: r / 255,
+			g: g / 255,
+			b: b / 255,
+			a: alpha
+		} : {
+			r: r / 255,
+			g: g / 255,
+			b: b / 255
+		};
+	}
+	/**
+	* Apply a tint to a 0–1 float RGB colour, per OOXML §18.8.19.
+	*
+	* Tint ∈ [-1, 1]: positive lightens toward white
+	* (`c + (1 - c) * tint`), negative darkens toward black
+	* (`c * (1 + tint)`). `tint = 0` returns the colour unchanged. Result
+	* components are clamped to [0, 1]; alpha is preserved.
+	*/
+	function applyTintRgb01(color, tint) {
+		const apply = (c) => {
+			const v = tint < 0 ? c * (1 + tint) : c + (1 - c) * tint;
+			return Math.max(0, Math.min(1, v));
+		};
+		const out = {
+			r: apply(color.r),
+			g: apply(color.g),
+			b: apply(color.b)
+		};
+		if (color.a !== void 0) out.a = color.a;
+		return out;
+	}
+	var DEFAULT_OFFICE_THEME, CHART_THEME_PALETTE, CELL_THEME_PALETTE;
+	var init_theme_colors = __esmMin((() => {
+		DEFAULT_OFFICE_THEME = Object.freeze({
+			dk1: "000000",
+			lt1: "FFFFFF",
+			dk2: "44546A",
+			lt2: "E7E6E6",
+			accent1: "4472C4",
+			accent2: "ED7D31",
+			accent3: "A5A5A5",
+			accent4: "FFC000",
+			accent5: "5B9BD5",
+			accent6: "70AD47",
+			hlink: "0563C1",
+			folHlink: "954F72"
+		});
+		CHART_THEME_PALETTE = Object.freeze([
+			DEFAULT_OFFICE_THEME.dk1,
+			DEFAULT_OFFICE_THEME.lt1,
+			DEFAULT_OFFICE_THEME.dk2,
+			DEFAULT_OFFICE_THEME.lt2,
+			DEFAULT_OFFICE_THEME.accent1,
+			DEFAULT_OFFICE_THEME.accent2,
+			DEFAULT_OFFICE_THEME.accent3,
+			DEFAULT_OFFICE_THEME.accent4,
+			DEFAULT_OFFICE_THEME.accent5,
+			DEFAULT_OFFICE_THEME.accent6,
+			DEFAULT_OFFICE_THEME.hlink,
+			DEFAULT_OFFICE_THEME.folHlink
+		]);
+		CELL_THEME_PALETTE = Object.freeze([
+			DEFAULT_OFFICE_THEME.lt1,
+			DEFAULT_OFFICE_THEME.dk1,
+			DEFAULT_OFFICE_THEME.lt2,
+			DEFAULT_OFFICE_THEME.dk2,
+			DEFAULT_OFFICE_THEME.accent1,
+			DEFAULT_OFFICE_THEME.accent2,
+			DEFAULT_OFFICE_THEME.accent3,
+			DEFAULT_OFFICE_THEME.accent4,
+			DEFAULT_OFFICE_THEME.accent5,
+			DEFAULT_OFFICE_THEME.accent6,
+			DEFAULT_OFFICE_THEME.hlink,
+			DEFAULT_OFFICE_THEME.folHlink
+		]);
+	}));
+	//#endregion
+	//#region src/modules/pdf/render/style-converter.ts
+	/**
+	* Convert an ARGB color string to PDF RGB color.
+	* Handles "AARRGGBB" (8-char) and "RRGGBB" (6-char) formats.
+	* PDF uses 0-1 floats for each component.
+	*/
+	function argbToPdfColor(argb) {
+		if (!argb || argb.length < 6) return null;
+		return hexToRgb01(argb);
+	}
+	/**
+	* Convert a color data object to PDF color.
+	* Handles ARGB, theme-based, and indexed colors.
+	*/
+	function excelColorToPdf(color) {
+		if (!color) return null;
+		if (color.argb) return argbToPdfColor(color.argb);
+		if (color.theme !== void 0) {
+			const base = themeColorToPdf(color.theme);
+			if (!base) return null;
+			const tint = color.tint;
+			if (tint !== void 0 && tint !== 0) return applyTint(base, tint);
+			return base;
+		}
+		if (color.indexed !== void 0) return indexedColorToPdf(color.indexed);
+		return null;
+	}
+	/**
+	* Map a cell-colour theme index to a PDF colour using the default Office
+	* palette in SpreadsheetML cell order (0=lt1, 1=dk1, 2=lt2, 3=dk2, …).
+	*/
+	function themeColorToPdf(themeIndex) {
+		if (themeIndex >= 0 && themeIndex < CELL_THEME_PALETTE.length) return hexToRgb01(CELL_THEME_PALETTE[themeIndex]);
+		return null;
+	}
+	/**
+	* Convert an indexed color to PDF color.
+	* Index 64 = system foreground (black), 65 = system background (white).
+	*/
+	function indexedColorToPdf(index) {
+		if (index === 64) return {
+			r: 0,
+			g: 0,
+			b: 0
+		};
+		if (index === 65) return {
+			r: 1,
+			g: 1,
+			b: 1
+		};
+		if (index >= 0 && index < INDEXED_COLORS.length) return argbToPdfColor(INDEXED_COLORS[index]) ?? null;
+		return null;
+	}
+	/**
+	* Apply a tint value to a color.
+	* Tint range: -1.0 (fully dark) to +1.0 (fully light).
+	* Negative tint darkens, positive tint lightens.
+	*
+	* @see OOXML §18.8.19 - tint formula
+	*/
+	function applyTint(color, tint) {
+		return applyTintRgb01(color, tint);
+	}
+	/**
+	* Convert a color to its luminance-preserving grayscale equivalent, using the
+	* Rec. 601 luma weights. Backs Excel's "Black and white" print option: hues are
+	* discarded while relative lightness — and therefore contrast — is kept.
+	*
+	* Opacity is carried through untouched; dropping it would make transparent
+	* chart fills opaque.
+	*/
+	function toGrayscale(color) {
+		const luma = .299 * color.r + .587 * color.g + .114 * color.b;
+		return color.a === void 0 ? {
+			r: luma,
+			g: luma,
+			b: luma
+		} : {
+			r: luma,
+			g: luma,
+			b: luma,
+			a: color.a
+		};
+	}
+	/** Grayscale every edge of a border set, preserving `null` edges. */
+	function grayscaleBorders(borders) {
+		const convert = (b) => b === null ? null : {
+			...b,
+			color: toGrayscale(b.color)
+		};
+		return {
+			top: convert(borders.top),
+			right: convert(borders.right),
+			bottom: convert(borders.bottom),
+			left: convert(borders.left)
+		};
+	}
+	/**
+	* Extract font properties for PDF rendering.
+	*/
+	function extractFontProperties(font, defaultFamily, defaultSize) {
+		return {
+			fontFamily: font?.name ?? defaultFamily,
+			fontSize: font?.size ?? defaultSize,
+			bold: font?.bold ?? false,
+			italic: font?.italic ?? false,
+			strike: font?.strike ?? false,
+			underline: !!(font?.underline && font.underline !== "none"),
+			textColor: excelColorToPdf(font?.color) ?? DEFAULT_COLORS.black
+		};
+	}
+	/**
+	* Convert a fill to a PDF background color.
+	* Only pattern fills with "solid" pattern are supported as PDF backgrounds.
+	* Other patterns are approximated or ignored.
+	*/
+	function excelFillToPdfColor(fill) {
+		if (!fill) return null;
+		if (fill.type === "pattern") {
+			if (fill.pattern === "solid" && fill.fgColor) return excelColorToPdf(fill.fgColor);
+			if (fill.pattern === "none") return null;
+			if (fill.fgColor) return excelColorToPdf(fill.fgColor);
+		}
+		if (fill.type === "gradient") {
+			if (fill.stops && fill.stops.length > 0) return excelColorToPdf(fill.stops[0].color);
+		}
+		return null;
+	}
+	/**
+	* Map border styles to PDF line widths (in points).
+	*
+	* Values match Excel's actual border weights as used historically by this
+	* library. An earlier change doubled every width (0.25 → 0.5, 0.5 → 1,
+	* 1 → 2) to make `thin` and `medium` more visually distinct in PDF
+	* viewers, but that change made all borders heavier than Excel itself.
+	* The 2× ratio between thin/medium and the 4× ratio between
+	* thin/thick are preserved with the lighter values, so styles remain
+	* distinguishable while matching Excel.
+	*
+	*   hair   = 0.1 pt
+	*   thin   = 0.25 pt   (also dotted, dashed, dashDot, dashDotDot, slantDashDot, double)
+	*   medium = 0.5 pt    (also mediumDashed, mediumDashDot, mediumDashDotDot)
+	*   thick  = 1   pt
+	*/
+	function borderStyleToLineWidth(style) {
+		switch (style) {
+			case "hair": return .1;
+			case "thin": return .25;
+			case "medium": return .5;
+			case "thick": return 1;
+			case "double": return .25;
+			case "dotted": return .25;
+			case "dashed": return .25;
+			case "dashDot": return .25;
+			case "dashDotDot": return .25;
+			case "slantDashDot": return .25;
+			case "mediumDashed": return .5;
+			case "mediumDashDot": return .5;
+			case "mediumDashDotDot": return .5;
+			default: return .25;
+		}
+	}
+	/**
+	* Map border styles to PDF dash patterns.
+	* An empty array means a solid line.
+	*/
+	function borderStyleToDashPattern(style) {
+		switch (style) {
+			case "dotted": return [1, 1];
+			case "dashed":
+			case "mediumDashed": return [3, 2];
+			case "dashDot":
+			case "mediumDashDot": return [
+				3,
+				1,
+				1,
+				1
+			];
+			case "dashDotDot":
+			case "mediumDashDotDot": return [
+				3,
+				1,
+				1,
+				1,
+				1,
+				1
+			];
+			case "slantDashDot": return [
+				4,
+				2,
+				1,
+				2
+			];
+			case "hair": return [.5, .5];
+			default: return [];
+		}
+	}
+	/**
+	* Convert a single border side to a PDF LayoutBorder.
+	*/
+	function convertBorder(border) {
+		if (!border || !border.style) return null;
+		return {
+			width: borderStyleToLineWidth(border.style),
+			color: excelColorToPdf(border.color) ?? DEFAULT_COLORS.black,
+			dashPattern: borderStyleToDashPattern(border.style),
+			isDouble: border.style === "double"
+		};
+	}
+	/**
+	* Convert border data to PDF LayoutBorders.
+	*/
+	function excelBordersToPdf(borders) {
+		if (!borders) return {
+			top: null,
+			right: null,
+			bottom: null,
+			left: null
+		};
+		return {
+			top: convertBorder(borders.top),
+			right: convertBorder(borders.right),
+			bottom: convertBorder(borders.bottom),
+			left: convertBorder(borders.left)
+		};
+	}
+	/**
+	* Convert horizontal alignment to PDF alignment.
+	*/
+	function excelHAlignToPdf(alignment) {
+		if (!alignment?.horizontal) return "left";
+		switch (alignment.horizontal) {
+			case "center":
+			case "centerContinuous": return "center";
+			case "right": return "right";
+			default: return "left";
+		}
+	}
+	/**
+	* Convert vertical alignment to PDF alignment.
+	*/
+	function excelVAlignToPdf(alignment) {
+		if (!alignment?.vertical) return "bottom";
+		switch (alignment.vertical) {
+			case "top": return "top";
+			case "middle": return "middle";
+			default: return "bottom";
+		}
+	}
+	var INDEXED_COLORS, DEFAULT_COLORS;
+	var init_style_converter = __esmMin((() => {
+		init_theme_colors();
+		INDEXED_COLORS = [
+			"000000",
+			"FFFFFF",
+			"FF0000",
+			"00FF00",
+			"0000FF",
+			"FFFF00",
+			"FF00FF",
+			"00FFFF",
+			"000000",
+			"FFFFFF",
+			"FF0000",
+			"00FF00",
+			"0000FF",
+			"FFFF00",
+			"FF00FF",
+			"00FFFF",
+			"800000",
+			"008000",
+			"000080",
+			"808000",
+			"800080",
+			"008080",
+			"C0C0C0",
+			"808080",
+			"9999FF",
+			"993366",
+			"FFFFCC",
+			"CCFFFF",
+			"660066",
+			"FF8080",
+			"0066CC",
+			"CCCCFF",
+			"000080",
+			"FF00FF",
+			"FFFF00",
+			"00FFFF",
+			"800080",
+			"800000",
+			"008080",
+			"0000FF",
+			"00CCFF",
+			"CCFFFF",
+			"CCFFCC",
+			"FFFF99",
+			"99CCFF",
+			"FF99CC",
+			"CC99FF",
+			"FFCC99",
+			"3366FF",
+			"33CCCC",
+			"99CC00",
+			"FFCC00",
+			"FF9900",
+			"FF6600",
+			"666699",
+			"969696",
+			"003366",
+			"339966",
+			"003300",
+			"333300",
+			"993300",
+			"993366",
+			"333399",
+			"333333"
+		];
+		DEFAULT_COLORS = {
+			black: {
+				r: 0,
+				g: 0,
+				b: 0
+			},
+			white: {
+				r: 1,
+				g: 1,
+				b: 1
+			},
+			gridLine: {
+				r: .816,
+				g: .816,
+				b: .816
+			}
+		};
 	}));
 	//#endregion
 	//#region src/modules/pdf/render/page-renderer.ts
@@ -31086,6 +31591,8 @@ this.Documonster = this.Documonster || {};
 		for (const cell of page.cells) drawCellBorders(stream, cell);
 		const sf = page.scaleFactor;
 		for (const cell of page.cells) if (cell.text || cell.richText) drawCellText(stream, cell, fontManager, alphaValues, sf);
+		if (options.showRowColHeaders) drawRowColHeadings(stream, page, options, fontManager);
+		if (page.commentBoxes?.length) drawCommentBoxes(stream, page, options, fontManager);
 		const excelHeader = selectHeaderFooter(page, "header");
 		const excelFooter = selectHeaderFooter(page, "footer");
 		if (excelHeader !== void 0) {
@@ -31987,11 +32494,13 @@ this.Documonster = this.Documonster || {};
 			for (const item of resolved) {
 				const { run, text, resourceName, fontSize, width } = item;
 				const shift = run.superscript ? fontSize * HEADER_FOOTER_METRICS.SUPERSCRIPT_RISE : run.subscript ? -fontSize * HEADER_FOOTER_METRICS.SUBSCRIPT_DROP : 0;
-				const color = run.color ?? {
+				const bw = page.options.blackAndWhite;
+				const rawColor = run.color ?? {
 					r: 0,
 					g: 0,
 					b: 0
 				};
+				const color = bw ? toGrayscale(rawColor) : rawColor;
 				stream.save();
 				stream.setFillColor(color);
 				stream.setStrokeColor(color);
@@ -32055,6 +32564,169 @@ this.Documonster = this.Documonster || {};
 			};
 		});
 	}
+	/** Convert a 1-based column number to its Excel letters (1 → "A", 27 → "AA"). */
+	function columnNumberToLetters(col) {
+		let n = col;
+		let out = "";
+		while (n > 0) {
+			const rem = (n - 1) % 26;
+			out = String.fromCharCode(65 + rem) + out;
+			n = Math.floor((n - 1) / 26);
+		}
+		return out;
+	}
+	/**
+	* Draw Excel's printed row numbers and column letters around the grid.
+	*
+	* The bands occupy space reserved by the layout engine (see
+	* `computeHeadingMetrics`), so the grid origin already accounts for them and
+	* nothing here can push content off the page.
+	*/
+	function drawRowColHeadings(stream, page, options, fontManager) {
+		const headings = page.headings;
+		if (!headings || page.columnWidths.length === 0 || page.rowHeights.length === 0) return;
+		const { gutterWidth, bandHeight, fontSize } = headings;
+		const resourceName = fontManager.hasEmbeddedFont() ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(resolvePdfFontName(options.defaultFontFamily, false, false));
+		const fill = HEADING_FILL;
+		const rule = HEADING_RULE;
+		const textColor = HEADING_TEXT;
+		const gridLeft = page.columnOffsets[0];
+		const lastCol = page.columnWidths.length - 1;
+		const gridRight = page.columnOffsets[lastCol] + page.columnWidths[lastCol];
+		const gridTop = page.rowYPositions[0];
+		const lastRow = page.rowHeights.length - 1;
+		const gridBottom = page.rowYPositions[lastRow] - page.rowHeights[lastRow];
+		stream.save();
+		stream.fillRect(gridLeft, gridTop, gridRight - gridLeft, bandHeight, fill);
+		stream.fillRect(gridLeft - gutterWidth, gridBottom, gutterWidth, gridTop - gridBottom, fill);
+		stream.fillRect(gridLeft - gutterWidth, gridTop, gutterWidth, bandHeight, fill);
+		stream.setStrokeColor(rule);
+		stream.setLineWidth(.25);
+		for (let i = 0; i <= page.columnWidths.length; i++) {
+			const x = i < page.columnWidths.length ? page.columnOffsets[i] : page.columnOffsets[i - 1] + page.columnWidths[i - 1];
+			stream.moveTo(x, gridTop);
+			stream.lineTo(x, gridTop + bandHeight);
+		}
+		for (let i = 0; i <= page.rowYPositions.length; i++) {
+			const y = i < page.rowYPositions.length ? page.rowYPositions[i] : page.rowYPositions[i - 1] - page.rowHeights[i - 1];
+			stream.moveTo(gridLeft - gutterWidth, y);
+			stream.lineTo(gridLeft, y);
+		}
+		stream.moveTo(gridLeft - gutterWidth, gridTop + bandHeight);
+		stream.lineTo(gridRight, gridTop + bandHeight);
+		stream.moveTo(gridLeft - gutterWidth, gridBottom);
+		stream.lineTo(gridLeft - gutterWidth, gridTop + bandHeight);
+		stream.stroke();
+		stream.setFillColor(textColor);
+		const baselineOffset = (bandHeight - fontSize) / 2 + fontSize * .2;
+		for (let i = 0; i < page.sheetCols.length; i++) {
+			const label = columnNumberToLetters(page.sheetCols[i]);
+			fontManager.trackText(label);
+			const w = fontManager.measureText(label, resourceName, fontSize);
+			emitTextWithMatrix(stream, fontManager, {
+				text: label,
+				matrix: [
+					1,
+					0,
+					0,
+					1,
+					page.columnOffsets[i] + (page.columnWidths[i] - w) / 2,
+					gridTop + baselineOffset
+				],
+				resourceName,
+				fontSize
+			});
+		}
+		for (let i = 0; i < page.sheetRows.length; i++) {
+			const label = String(page.sheetRows[i]);
+			fontManager.trackText(label);
+			const w = fontManager.measureText(label, resourceName, fontSize);
+			const rowH = page.rowHeights[i];
+			emitTextWithMatrix(stream, fontManager, {
+				text: label,
+				matrix: [
+					1,
+					0,
+					0,
+					1,
+					gridLeft - gutterWidth + (gutterWidth - w) / 2,
+					page.rowYPositions[i] - rowH + (rowH - fontSize) / 2 + fontSize * .2
+				],
+				resourceName,
+				fontSize
+			});
+		}
+		stream.restore();
+	}
+	/**
+	* Draw Excel's on-sheet comment boxes and their cell corner markers.
+	*
+	* Positioned by the layout engine, so this only has to paint: a pale note-yellow
+	* box with a thin border, the wrapped body inside it, and the small red triangle
+	* Excel puts in the commented cell's top-right corner.
+	*/
+	function drawCommentBoxes(stream, page, options, fontManager) {
+		const boxes = page.commentBoxes;
+		if (!boxes?.length) return;
+		const bw = options.blackAndWhite;
+		const fill = bw ? toGrayscale(COMMENT_FILL) : COMMENT_FILL;
+		const border = bw ? toGrayscale(COMMENT_BORDER) : COMMENT_BORDER;
+		const markerColor = bw ? toGrayscale(COMMENT_MARKER_COLOR) : COMMENT_MARKER_COLOR;
+		const resourceName = fontManager.hasEmbeddedFont() ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(resolvePdfFontName(options.defaultFontFamily, false, false));
+		for (const box of boxes) {
+			const { rect } = box;
+			stream.save();
+			stream.fillRect(rect.x, rect.y, rect.width, rect.height, fill);
+			stream.setStrokeColor(border);
+			stream.setLineWidth(.5);
+			stream.rect(rect.x, rect.y, rect.width, rect.height);
+			stream.stroke();
+			const lineHeight = box.fontSize * LINE_HEIGHT_FACTOR;
+			const innerWidth = Math.max(rect.width - 6, 1);
+			const measure = (t) => fontManager.measureText(t, resourceName, box.fontSize);
+			const lines = box.text.split("\n").flatMap((part) => wrapTextLines(part, measure, innerWidth));
+			stream.setFillColor(bw ? toGrayscale({
+				r: 0,
+				g: 0,
+				b: 0
+			}) : {
+				r: 0,
+				g: 0,
+				b: 0
+			});
+			let baseline = rect.y + rect.height - 2 - box.fontSize;
+			for (const line of lines) {
+				if (baseline < rect.y + 2) break;
+				fontManager.trackText(line);
+				emitTextWithMatrix(stream, fontManager, {
+					text: line,
+					matrix: [
+						1,
+						0,
+						0,
+						1,
+						rect.x + 3,
+						baseline
+					],
+					resourceName,
+					fontSize: box.fontSize
+				});
+				baseline -= lineHeight;
+			}
+			stream.restore();
+			if (box.marker) {
+				const { x, y, size } = box.marker;
+				stream.save();
+				stream.setFillColor(markerColor);
+				stream.moveTo(x - size, y);
+				stream.lineTo(x, y);
+				stream.lineTo(x, y - size);
+				stream.closePath();
+				stream.fill();
+				stream.restore();
+			}
+		}
+	}
 	function drawPageHeader(stream, page, options, fontManager) {
 		const headerFontSize = 10;
 		const headerText = page.sheetName;
@@ -32143,7 +32815,8 @@ this.Documonster = this.Documonster || {};
 	*/
 	function renderTextWatermark(stream, page, watermark, fontManager) {
 		const fontSize = watermark.fontSize ?? TEXT_WM_DEFAULTS.fontSize;
-		const color = watermark.color ?? TEXT_WM_DEFAULTS.color;
+		const rawColor = watermark.color ?? TEXT_WM_DEFAULTS.color;
+		const color = page.options.blackAndWhite ? toGrayscale(rawColor) : rawColor;
 		const opacity = watermark.opacity ?? TEXT_WM_DEFAULTS.opacity;
 		const rotation = watermark.rotation ?? TEXT_WM_DEFAULTS.rotation;
 		const fontFamily = watermark.fontFamily ?? TEXT_WM_DEFAULTS.fontFamily;
@@ -32282,6 +32955,7 @@ this.Documonster = this.Documonster || {};
 		init_pdf_stream();
 		init_font_manager();
 		init_constants();
+		init_style_converter();
 		HEADER_FOOTER_DATE_OPTIONS = {
 			year: "numeric",
 			month: "numeric",
@@ -32337,115 +33011,6 @@ this.Documonster = this.Documonster || {};
 		MIN_REPEAT_SPACING = 10;
 	}));
 	//#endregion
-	//#region src/utils/theme-colors.ts
-	/**
-	* Parse a hex colour string into 0–1 float RGB components.
-	*
-	* Accepts `RRGGBB` (6 digits), `AARRGGBB` (8 digits, alpha first — the form
-	* Excel uses for cell fills), and `RGB` (3 digits, CSS shorthand). A leading
-	* `#` is tolerated. Returns `null` for anything else.
-	*/
-	function hexToRgb01(hex) {
-		if (!hex) return null;
-		let h = hex.startsWith("#") ? hex.slice(1) : hex;
-		if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
-		let a = 255;
-		let rHex;
-		let gHex;
-		let bHex;
-		if (h.length === 8) {
-			a = parseInt(h.slice(0, 2), 16);
-			rHex = h.slice(2, 4);
-			gHex = h.slice(4, 6);
-			bHex = h.slice(6, 8);
-		} else if (h.length === 6) {
-			rHex = h.slice(0, 2);
-			gHex = h.slice(2, 4);
-			bHex = h.slice(4, 6);
-		} else return null;
-		const r = parseInt(rHex, 16);
-		const g = parseInt(gHex, 16);
-		const b = parseInt(bHex, 16);
-		if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b) || Number.isNaN(a)) return null;
-		const alpha = a / 255;
-		return alpha < 1 ? {
-			r: r / 255,
-			g: g / 255,
-			b: b / 255,
-			a: alpha
-		} : {
-			r: r / 255,
-			g: g / 255,
-			b: b / 255
-		};
-	}
-	/**
-	* Apply a tint to a 0–1 float RGB colour, per OOXML §18.8.19.
-	*
-	* Tint ∈ [-1, 1]: positive lightens toward white
-	* (`c + (1 - c) * tint`), negative darkens toward black
-	* (`c * (1 + tint)`). `tint = 0` returns the colour unchanged. Result
-	* components are clamped to [0, 1]; alpha is preserved.
-	*/
-	function applyTintRgb01(color, tint) {
-		const apply = (c) => {
-			const v = tint < 0 ? c * (1 + tint) : c + (1 - c) * tint;
-			return Math.max(0, Math.min(1, v));
-		};
-		const out = {
-			r: apply(color.r),
-			g: apply(color.g),
-			b: apply(color.b)
-		};
-		if (color.a !== void 0) out.a = color.a;
-		return out;
-	}
-	var DEFAULT_OFFICE_THEME, CHART_THEME_PALETTE, CELL_THEME_PALETTE;
-	var init_theme_colors = __esmMin((() => {
-		DEFAULT_OFFICE_THEME = Object.freeze({
-			dk1: "000000",
-			lt1: "FFFFFF",
-			dk2: "44546A",
-			lt2: "E7E6E6",
-			accent1: "4472C4",
-			accent2: "ED7D31",
-			accent3: "A5A5A5",
-			accent4: "FFC000",
-			accent5: "5B9BD5",
-			accent6: "70AD47",
-			hlink: "0563C1",
-			folHlink: "954F72"
-		});
-		CHART_THEME_PALETTE = Object.freeze([
-			DEFAULT_OFFICE_THEME.dk1,
-			DEFAULT_OFFICE_THEME.lt1,
-			DEFAULT_OFFICE_THEME.dk2,
-			DEFAULT_OFFICE_THEME.lt2,
-			DEFAULT_OFFICE_THEME.accent1,
-			DEFAULT_OFFICE_THEME.accent2,
-			DEFAULT_OFFICE_THEME.accent3,
-			DEFAULT_OFFICE_THEME.accent4,
-			DEFAULT_OFFICE_THEME.accent5,
-			DEFAULT_OFFICE_THEME.accent6,
-			DEFAULT_OFFICE_THEME.hlink,
-			DEFAULT_OFFICE_THEME.folHlink
-		]);
-		CELL_THEME_PALETTE = Object.freeze([
-			DEFAULT_OFFICE_THEME.lt1,
-			DEFAULT_OFFICE_THEME.dk1,
-			DEFAULT_OFFICE_THEME.lt2,
-			DEFAULT_OFFICE_THEME.dk2,
-			DEFAULT_OFFICE_THEME.accent1,
-			DEFAULT_OFFICE_THEME.accent2,
-			DEFAULT_OFFICE_THEME.accent3,
-			DEFAULT_OFFICE_THEME.accent4,
-			DEFAULT_OFFICE_THEME.accent5,
-			DEFAULT_OFFICE_THEME.accent6,
-			DEFAULT_OFFICE_THEME.hlink,
-			DEFAULT_OFFICE_THEME.folHlink
-		]);
-	}));
-	//#endregion
 	//#region src/modules/pdf/core/digital-signature.ts
 	var digital_signature_exports = /* @__PURE__ */ __exportAll({
 		asn1Parse: () => asn1Parse,
@@ -34488,29 +35053,66 @@ this.Documonster = this.Documonster || {};
 	* @param alphaValues   Shared set that accumulates transparency values for
 	*                      later `ExtGState` registration. The surface adds any
 	*                      `color.a` values it observes to this set.
-	*/
-	function createChartSurface(stream, fontManager, alphaValues) {
+	* @param grayscale     When true, every color the chart renderer emits is
+	*                      converted to grayscale. Charts bypass the cell style
+	*                      pipeline entirely — the chart engine pushes colors
+	*                      straight into this surface — so Excel's "Black and
+	*                      white" print option has to be applied right here.
+	*/
+	function createChartSurface(stream, fontManager, alphaValues, grayscale = false) {
+		/** Single choke point for every color entering the surface. */
+		const mapColor = (color) => grayscale && color ? toGrayscale(color) : color;
 		const applyAlpha = (color) => {
 			if (color?.a !== void 0 && color.a < 1) {
 				alphaValues.add(color.a);
 				stream.setGraphicsState(alphaGsName(color.a));
 			}
 		};
-		const paintFillStroke = (options) => {
-			const { fill, stroke, lineWidth } = options;
+		/**
+		* Fill and/or stroke the path built by `buildPath`.
+		*
+		* `buildPath` is a closure rather than a pre-built path because a fill and a
+		* stroke with *different* opacities cannot share one graphics state: the
+		* alpha `ExtGState` sets `/ca` and `/CA` together, and `fillAndStroke()`
+		* paints both under whichever was applied last. In that case we paint in two
+		* passes and rebuild the path for the second one. (Within a single pass the
+		* unused half of the ExtGState is harmless — a fill-only pass never strokes.)
+		*/
+		const paintFillStroke = (buildPath, options) => {
+			const { lineWidth, dashPattern } = options;
+			const fill = mapColor(options.fill);
+			const stroke = mapColor(options.stroke);
+			const applyDash = () => {
+				if (dashPattern && dashPattern.length > 0) stream.setDashPattern(dashPattern);
+			};
+			if (fill && stroke) {
+				if ((fill.a ?? 1) !== (stroke.a ?? 1)) {
+					stream.save();
+					buildPath();
+					stream.setFillColor(fill);
+					applyAlpha(fill);
+					stream.fill();
+					stream.restore();
+					stream.save();
+					buildPath();
+					stream.setStrokeColor(stroke);
+					applyAlpha(stroke);
+					applyDash();
+					if (lineWidth !== void 0) stream.setLineWidth(lineWidth);
+					stream.stroke();
+					stream.restore();
+					return;
+				}
+			}
+			buildPath();
+			applyDash();
 			if (fill) {
 				stream.setFillColor(fill);
 				applyAlpha(fill);
 			}
 			if (stroke) {
 				stream.setStrokeColor(stroke);
-				const strokeNeedsAlpha = stroke.a !== void 0 && stroke.a < 1;
-				const fillAppliedAlpha = fill?.a !== void 0 && fill.a < 1;
-				if (strokeNeedsAlpha) applyAlpha(stroke);
-				else if (fillAppliedAlpha) {
-					alphaValues.add(1);
-					stream.setGraphicsState(alphaGsName(1));
-				}
+				if (!fill) applyAlpha(stroke);
 				if (lineWidth !== void 0) stream.setLineWidth(lineWidth);
 			}
 			if (fill && stroke) stream.fillAndStroke();
@@ -34522,8 +35124,7 @@ this.Documonster = this.Documonster || {};
 			drawRect(options) {
 				const { x, y, width, height, fill, stroke, lineWidth } = options;
 				stream.save();
-				stream.rect(x, y, width, height);
-				paintFillStroke({
+				paintFillStroke(() => stream.rect(x, y, width, height), {
 					fill,
 					stroke,
 					lineWidth
@@ -34532,7 +35133,8 @@ this.Documonster = this.Documonster || {};
 				return this;
 			},
 			drawLine(options) {
-				const { x1, y1, x2, y2, color, lineWidth, dashPattern } = options;
+				const { x1, y1, x2, y2, lineWidth, dashPattern } = options;
+				const color = mapColor(options.color);
 				stream.save();
 				if (color) {
 					stream.setStrokeColor(color);
@@ -34547,11 +35149,11 @@ this.Documonster = this.Documonster || {};
 			drawText(text, options) {
 				if (!text) return this;
 				const fontSize = options.fontSize ?? 10;
-				const color = options.color ?? {
+				const color = mapColor(options.color ?? {
 					r: 0,
 					g: 0,
 					b: 0
-				};
+				});
 				const bold = options.bold ?? false;
 				const italic = options.italic ?? false;
 				const fontFamily = options.fontFamily ?? "Helvetica";
@@ -34578,8 +35180,7 @@ this.Documonster = this.Documonster || {};
 			drawCircle(options) {
 				const { cx, cy, r, fill, stroke, lineWidth } = options;
 				stream.save();
-				stream.circle(cx, cy, r);
-				paintFillStroke({
+				paintFillStroke(() => stream.circle(cx, cy, r), {
 					fill,
 					stroke,
 					lineWidth
@@ -34588,25 +35189,27 @@ this.Documonster = this.Documonster || {};
 				return this;
 			},
 			drawPath(ops, options) {
+				const buildPath = () => {
+					for (const op of ops) switch (op.op) {
+						case "move":
+							stream.moveTo(op.x, op.y);
+							break;
+						case "line":
+							stream.lineTo(op.x, op.y);
+							break;
+						case "curve":
+							stream.curveTo(op.x1, op.y1, op.x2, op.y2, op.x3, op.y3);
+							break;
+						case "close": stream.closePath();
+					}
+					if (options?.closePath) stream.closePath();
+				};
 				stream.save();
-				for (const op of ops) switch (op.op) {
-					case "move":
-						stream.moveTo(op.x, op.y);
-						break;
-					case "line":
-						stream.lineTo(op.x, op.y);
-						break;
-					case "curve":
-						stream.curveTo(op.x1, op.y1, op.x2, op.y2, op.x3, op.y3);
-						break;
-					case "close": stream.closePath();
-				}
-				if (options?.closePath) stream.closePath();
-				if (options?.dashPattern && options.dashPattern.length > 0) stream.setDashPattern(options.dashPattern);
-				paintFillStroke({
+				paintFillStroke(buildPath, {
 					fill: options?.fill,
 					stroke: options?.stroke,
-					lineWidth: options?.lineWidth
+					lineWidth: options?.lineWidth,
+					dashPattern: options?.dashPattern
 				});
 				stream.restore();
 				return this;
@@ -34620,309 +35223,7 @@ this.Documonster = this.Documonster || {};
 	var init_chart_surface = __esmMin((() => {
 		init_font_manager();
 		init_page_renderer();
-	}));
-	//#endregion
-	//#region src/modules/pdf/render/style-converter.ts
-	/**
-	* Convert an ARGB color string to PDF RGB color.
-	* Handles "AARRGGBB" (8-char) and "RRGGBB" (6-char) formats.
-	* PDF uses 0-1 floats for each component.
-	*/
-	function argbToPdfColor(argb) {
-		if (!argb || argb.length < 6) return null;
-		return hexToRgb01(argb);
-	}
-	/**
-	* Convert a color data object to PDF color.
-	* Handles ARGB, theme-based, and indexed colors.
-	*/
-	function excelColorToPdf(color) {
-		if (!color) return null;
-		if (color.argb) return argbToPdfColor(color.argb);
-		if (color.theme !== void 0) {
-			const base = themeColorToPdf(color.theme);
-			if (!base) return null;
-			const tint = color.tint;
-			if (tint !== void 0 && tint !== 0) return applyTint(base, tint);
-			return base;
-		}
-		if (color.indexed !== void 0) return indexedColorToPdf(color.indexed);
-		return null;
-	}
-	/**
-	* Map a cell-colour theme index to a PDF colour using the default Office
-	* palette in SpreadsheetML cell order (0=lt1, 1=dk1, 2=lt2, 3=dk2, …).
-	*/
-	function themeColorToPdf(themeIndex) {
-		if (themeIndex >= 0 && themeIndex < CELL_THEME_PALETTE.length) return hexToRgb01(CELL_THEME_PALETTE[themeIndex]);
-		return null;
-	}
-	/**
-	* Convert an indexed color to PDF color.
-	* Index 64 = system foreground (black), 65 = system background (white).
-	*/
-	function indexedColorToPdf(index) {
-		if (index === 64) return {
-			r: 0,
-			g: 0,
-			b: 0
-		};
-		if (index === 65) return {
-			r: 1,
-			g: 1,
-			b: 1
-		};
-		if (index >= 0 && index < INDEXED_COLORS.length) return argbToPdfColor(INDEXED_COLORS[index]) ?? null;
-		return null;
-	}
-	/**
-	* Apply a tint value to a color.
-	* Tint range: -1.0 (fully dark) to +1.0 (fully light).
-	* Negative tint darkens, positive tint lightens.
-	*
-	* @see OOXML §18.8.19 - tint formula
-	*/
-	function applyTint(color, tint) {
-		return applyTintRgb01(color, tint);
-	}
-	/**
-	* Extract font properties for PDF rendering.
-	*/
-	function extractFontProperties(font, defaultFamily, defaultSize) {
-		return {
-			fontFamily: font?.name ?? defaultFamily,
-			fontSize: font?.size ?? defaultSize,
-			bold: font?.bold ?? false,
-			italic: font?.italic ?? false,
-			strike: font?.strike ?? false,
-			underline: !!(font?.underline && font.underline !== "none"),
-			textColor: excelColorToPdf(font?.color) ?? DEFAULT_COLORS.black
-		};
-	}
-	/**
-	* Convert a fill to a PDF background color.
-	* Only pattern fills with "solid" pattern are supported as PDF backgrounds.
-	* Other patterns are approximated or ignored.
-	*/
-	function excelFillToPdfColor(fill) {
-		if (!fill) return null;
-		if (fill.type === "pattern") {
-			if (fill.pattern === "solid" && fill.fgColor) return excelColorToPdf(fill.fgColor);
-			if (fill.pattern === "none") return null;
-			if (fill.fgColor) return excelColorToPdf(fill.fgColor);
-		}
-		if (fill.type === "gradient") {
-			if (fill.stops && fill.stops.length > 0) return excelColorToPdf(fill.stops[0].color);
-		}
-		return null;
-	}
-	/**
-	* Map border styles to PDF line widths (in points).
-	*
-	* Values match Excel's actual border weights as used historically by this
-	* library. An earlier change doubled every width (0.25 → 0.5, 0.5 → 1,
-	* 1 → 2) to make `thin` and `medium` more visually distinct in PDF
-	* viewers, but that change made all borders heavier than Excel itself.
-	* The 2× ratio between thin/medium and the 4× ratio between
-	* thin/thick are preserved with the lighter values, so styles remain
-	* distinguishable while matching Excel.
-	*
-	*   hair   = 0.1 pt
-	*   thin   = 0.25 pt   (also dotted, dashed, dashDot, dashDotDot, slantDashDot, double)
-	*   medium = 0.5 pt    (also mediumDashed, mediumDashDot, mediumDashDotDot)
-	*   thick  = 1   pt
-	*/
-	function borderStyleToLineWidth(style) {
-		switch (style) {
-			case "hair": return .1;
-			case "thin": return .25;
-			case "medium": return .5;
-			case "thick": return 1;
-			case "double": return .25;
-			case "dotted": return .25;
-			case "dashed": return .25;
-			case "dashDot": return .25;
-			case "dashDotDot": return .25;
-			case "slantDashDot": return .25;
-			case "mediumDashed": return .5;
-			case "mediumDashDot": return .5;
-			case "mediumDashDotDot": return .5;
-			default: return .25;
-		}
-	}
-	/**
-	* Map border styles to PDF dash patterns.
-	* An empty array means a solid line.
-	*/
-	function borderStyleToDashPattern(style) {
-		switch (style) {
-			case "dotted": return [1, 1];
-			case "dashed":
-			case "mediumDashed": return [3, 2];
-			case "dashDot":
-			case "mediumDashDot": return [
-				3,
-				1,
-				1,
-				1
-			];
-			case "dashDotDot":
-			case "mediumDashDotDot": return [
-				3,
-				1,
-				1,
-				1,
-				1,
-				1
-			];
-			case "slantDashDot": return [
-				4,
-				2,
-				1,
-				2
-			];
-			case "hair": return [.5, .5];
-			default: return [];
-		}
-	}
-	/**
-	* Convert a single border side to a PDF LayoutBorder.
-	*/
-	function convertBorder(border) {
-		if (!border || !border.style) return null;
-		return {
-			width: borderStyleToLineWidth(border.style),
-			color: excelColorToPdf(border.color) ?? DEFAULT_COLORS.black,
-			dashPattern: borderStyleToDashPattern(border.style),
-			isDouble: border.style === "double"
-		};
-	}
-	/**
-	* Convert border data to PDF LayoutBorders.
-	*/
-	function excelBordersToPdf(borders) {
-		if (!borders) return {
-			top: null,
-			right: null,
-			bottom: null,
-			left: null
-		};
-		return {
-			top: convertBorder(borders.top),
-			right: convertBorder(borders.right),
-			bottom: convertBorder(borders.bottom),
-			left: convertBorder(borders.left)
-		};
-	}
-	/**
-	* Convert horizontal alignment to PDF alignment.
-	*/
-	function excelHAlignToPdf(alignment) {
-		if (!alignment?.horizontal) return "left";
-		switch (alignment.horizontal) {
-			case "center":
-			case "centerContinuous": return "center";
-			case "right": return "right";
-			default: return "left";
-		}
-	}
-	/**
-	* Convert vertical alignment to PDF alignment.
-	*/
-	function excelVAlignToPdf(alignment) {
-		if (!alignment?.vertical) return "bottom";
-		switch (alignment.vertical) {
-			case "top": return "top";
-			case "middle": return "middle";
-			default: return "bottom";
-		}
-	}
-	var INDEXED_COLORS, DEFAULT_COLORS;
-	var init_style_converter = __esmMin((() => {
-		init_theme_colors();
-		INDEXED_COLORS = [
-			"000000",
-			"FFFFFF",
-			"FF0000",
-			"00FF00",
-			"0000FF",
-			"FFFF00",
-			"FF00FF",
-			"00FFFF",
-			"000000",
-			"FFFFFF",
-			"FF0000",
-			"00FF00",
-			"0000FF",
-			"FFFF00",
-			"FF00FF",
-			"00FFFF",
-			"800000",
-			"008000",
-			"000080",
-			"808000",
-			"800080",
-			"008080",
-			"C0C0C0",
-			"808080",
-			"9999FF",
-			"993366",
-			"FFFFCC",
-			"CCFFFF",
-			"660066",
-			"FF8080",
-			"0066CC",
-			"CCCCFF",
-			"000080",
-			"FF00FF",
-			"FFFF00",
-			"00FFFF",
-			"800080",
-			"800000",
-			"008080",
-			"0000FF",
-			"00CCFF",
-			"CCFFFF",
-			"CCFFCC",
-			"FFFF99",
-			"99CCFF",
-			"FF99CC",
-			"CC99FF",
-			"FFCC99",
-			"3366FF",
-			"33CCCC",
-			"99CC00",
-			"FFCC00",
-			"FF9900",
-			"FF6600",
-			"666699",
-			"969696",
-			"003366",
-			"339966",
-			"003300",
-			"333300",
-			"993300",
-			"993366",
-			"333399",
-			"333333"
-		];
-		DEFAULT_COLORS = {
-			black: {
-				r: 0,
-				g: 0,
-				b: 0
-			},
-			white: {
-				r: 1,
-				g: 1,
-				b: 1
-			},
-			gridLine: {
-				r: .816,
-				g: .816,
-				b: .816
-			}
-		};
+		init_style_converter();
 	}));
 	//#endregion
 	//#region src/modules/pdf/types.ts
@@ -35130,18 +35431,19 @@ this.Documonster = this.Documonster || {};
 		if (!ctx) return [createEmptyPage(sheet, options)];
 		const layoutPages = [];
 		const totalOutputPages = ctx.rowPages.length * ctx.colGroups.length;
-		for (const rowPage of ctx.rowPages) for (const colGroup of ctx.colGroups) {
+		const overThenDown = options.pageOrder === "overThenDown";
+		const outer = overThenDown ? ctx.rowPages : ctx.colGroups;
+		const inner = overThenDown ? ctx.colGroups : ctx.rowPages;
+		for (const outerTracks of outer) for (const innerTracks of inner) {
+			const rowPage = overThenDown ? outerTracks : innerTracks;
+			const colGroup = overThenDown ? innerTracks : outerTracks;
 			layoutPages.push(buildPageLayout(ctx, rowPage, colGroup, layoutPages.length, sheet, options, fontManager));
 			if (layoutPages.length < totalOutputPages) await yieldToEventLoop();
 		}
-		if (layoutPages.length > 0 && sheet.images) assignImagesToPages(sheet.images, layoutPages, ctx.scaleFactor);
-		if (layoutPages.length > 0 && sheet.charts) assignChartsToPages(sheet.charts, layoutPages, ctx.scaleFactor);
-		const firstPageNumber = sheet.pageSetup?.firstPageNumber ?? 1;
-		for (let i = 0; i < layoutPages.length; i++) {
-			layoutPages[i].sheetPageNumber = firstPageNumber + i;
-			layoutPages[i].sheetPageIndex = i + 1;
-			layoutPages[i].sheetPageCount = layoutPages.length;
-		}
+		if (layoutPages.length > 0 && sheet.images && !options.draft) assignImagesToPages(sheet.images, layoutPages, ctx.scaleFactor);
+		if (layoutPages.length > 0 && sheet.charts && !options.draft) assignChartsToPages(sheet.charts, layoutPages, ctx.scaleFactor);
+		if (options.cellComments === "atEnd" && sheet.comments?.length) layoutPages.push(...buildCommentPages(sheet, sheet.comments, options, fontManager));
+		for (let i = 0; i < layoutPages.length; i++) layoutPages[i].sheetPageIndex = i + 1;
 		return layoutPages;
 	}
 	/**
@@ -35170,9 +35472,7 @@ this.Documonster = this.Documonster || {};
 			...documentOptions,
 			orientation
 		};
-		let pageWidth = options.pageSize.width;
-		let pageHeight = options.pageSize.height;
-		if (options.orientation === "landscape") [pageWidth, pageHeight] = [pageHeight, pageWidth];
+		const { width: pageWidth, height: pageHeight } = pageDimensions(options);
 		const margins = options.margins;
 		const headerHeight = options.showSheetNames ? 20 : 0;
 		const footerHeight = options.showPageNumbers ? 20 : 0;
@@ -35191,6 +35491,35 @@ this.Documonster = this.Documonster || {};
 			raster: sheet.chart.raster
 		};
 		return [{
+			...blankPage(sheet, options),
+			charts: options.draft ? [] : [chart]
+		}];
+	}
+	/**
+	* Page dimensions for the resolved options, with landscape applied.
+	*
+	* `pageSize` is always stored portrait-wise, so every consumer has to swap the
+	* axes itself; centralised here so the four layout entry points cannot disagree.
+	*/
+	function pageDimensions(options) {
+		const { width, height } = options.pageSize;
+		return options.orientation === "landscape" ? {
+			width: height,
+			height: width
+		} : {
+			width,
+			height
+		};
+	}
+	/**
+	* A `LayoutPage` with every field at its empty value.
+	*
+	* The shape has ~20 members and four construction sites; building them from one
+	* skeleton means a new field cannot be forgotten in three of them.
+	*/
+	function blankPage(sheet, options) {
+		const { width, height } = pageDimensions(options);
+		return {
 			pageNumber: 1,
 			sheetPageNumber: sheet.pageSetup?.firstPageNumber ?? 1,
 			sheetPageIndex: 1,
@@ -35198,8 +35527,8 @@ this.Documonster = this.Documonster || {};
 			firstPageNumber: sheet.pageSetup?.firstPageNumber,
 			options,
 			cells: [],
-			width: pageWidth,
-			height: pageHeight,
+			width,
+			height,
 			sheetName: sheet.name,
 			sheetCols: [],
 			columnOffsets: [],
@@ -35208,10 +35537,10 @@ this.Documonster = this.Documonster || {};
 			rowYPositions: [],
 			rowHeights: [],
 			images: [],
-			charts: [chart],
+			charts: [],
 			scaleFactor: 1,
 			headerFooter: options.includeHeadersFooters ? sheet.headerFooter : void 0
-		}];
+		};
 	}
 	/**
 	* Steps 1–5: compute columns, scale, rows, merges, pagination.
@@ -35219,32 +35548,54 @@ this.Documonster = this.Documonster || {};
 	*/
 	function prepareLayout(sheet, options, fontManager) {
 		const { margins } = options;
-		let pageWidth = options.pageSize.width;
-		let pageHeight = options.pageSize.height;
-		if (options.orientation === "landscape") [pageWidth, pageHeight] = [pageHeight, pageWidth];
-		const contentWidth = pageWidth - margins.left - margins.right;
-		const contentHeight = pageHeight - margins.top - margins.bottom;
+		const { width: pageWidth, height: pageHeight } = pageDimensions(options);
 		const headerHeight = options.showSheetNames ? 20 : 0;
 		const printRange = getPrintRange(sheet, options);
-		const { columnWidths, visibleCols } = computeColumnWidths(sheet, printRange);
+		const headings = options.showRowColHeaders ? computeHeadingMetrics(sheet, printRange, fontManager, options) : void 0;
+		const gutterWidth = headings?.gutterWidth ?? 0;
+		const bandHeight = headings?.bandHeight ?? 0;
+		const contentWidth = pageWidth - margins.left - margins.right - gutterWidth;
+		const contentHeight = pageHeight - margins.top - margins.bottom - bandHeight;
+		const { columnWidths, visibleCols, repeatColIndices } = computeColumnWidths(sheet, printRange, options.repeatCols);
 		if (visibleCols.length === 0) return null;
+		const natural = computeRowHeights(sheet, printRange, fontManager, options, options.repeatRows);
+		const rowBreaks = buildBreakSet(sheet.rowBreaks ?? [], natural.visibleRows);
+		const colBreaks = buildBreakSet(sheet.colBreaks ?? [], visibleCols);
 		const totalTableWidth = columnWidths.reduce((sum, w) => sum + w, 0);
+		const footerHeight = options.showPageNumbers ? 20 : 0;
+		const availableHeight = contentHeight - headerHeight - footerHeight;
 		let scaleFactor = options.scale;
-		if (options.fitToPage && totalTableWidth > 0) {
-			const fitScale = contentWidth / totalTableWidth;
+		if (options.fitToWidth > 0 || options.fitToHeight > 0) {
+			let fit = 1;
+			const minFit = Math.min(1, FIT_MIN_SCALE / scaleFactor);
+			if (options.fitToWidth > 0 && totalTableWidth > 0) {
+				fit = Math.min(fit, contentWidth * options.fitToWidth / (totalTableWidth * scaleFactor));
+				fit = tightenToPageCount((candidate) => paginateTracks(columnWidths.map((w) => w * scaleFactor * candidate), contentWidth, repeatColIndices, colBreaks, COLUMN_FIT_EPSILON).length, options.fitToWidth, fit, minFit);
+			}
+			if (options.fitToHeight > 0 && availableHeight > 0) {
+				const totalTableHeight = natural.rowHeights.reduce((sum, h) => sum + h, 0);
+				if (totalTableHeight > 0) {
+					let heightFit = Math.min(fit, availableHeight * options.fitToHeight / (totalTableHeight * scaleFactor));
+					heightFit = tightenToPageCount((candidate) => paginateTracks(natural.rowHeights.map((h) => h * scaleFactor * candidate), availableHeight, natural.repeatRowIndices, rowBreaks).length, options.fitToHeight, heightFit, minFit);
+					fit = Math.min(fit, heightFit);
+				}
+			}
+			if (fit < 1) scaleFactor = Math.max(scaleFactor * fit, FIT_MIN_SCALE);
+		} else if (options.fitToPage && totalTableWidth > 0) {
+			const fitScale = contentWidth / (totalTableWidth * scaleFactor);
 			if (fitScale < 1) scaleFactor *= fitScale;
 		}
 		const scaledColumnWidths = columnWidths.map((w) => w * scaleFactor);
-		const footerHeight = options.showPageNumbers ? 20 : 0;
-		const availableHeight = contentHeight - headerHeight - footerHeight;
-		const { rowHeights, visibleRows } = computeRowHeights(sheet, scaleFactor, printRange, fontManager, options);
+		const rowHeights = natural.rowHeights.map((h) => h * scaleFactor);
+		const { visibleRows, repeatRowIndices } = natural;
 		const mergeMap = buildMergeMap(sheet);
-		const rowPages = paginateRows(rowHeights, availableHeight, typeof options.repeatRows === "number" ? options.repeatRows : 0, buildRowBreakSet(sheet, visibleRows));
-		const colGroups = paginateColumns(scaledColumnWidths, contentWidth, sheet, visibleCols);
+		const rowPages = paginateTracks(rowHeights, availableHeight, repeatRowIndices, rowBreaks);
+		const colGroups = paginateTracks(scaledColumnWidths, contentWidth, repeatColIndices, colBreaks, COLUMN_FIT_EPSILON);
 		return {
 			pageWidth,
 			pageHeight,
 			contentWidth,
+			availableHeight,
 			headerHeight,
 			scaleFactor,
 			scaledColumnWidths,
@@ -35254,27 +35605,173 @@ this.Documonster = this.Documonster || {};
 			mergeMap,
 			rowPages,
 			colGroups,
-			margins
+			margins,
+			headings
 		};
 	}
 	/**
+	* Size the row-number gutter and column-letter band for Excel's "Row and
+	* column headings" print option.
+	*
+	* The gutter is sized from the widest row label that can appear in the printed
+	* range, so the grid origin is stable across pages instead of jittering as row
+	* numbers gain digits.
+	*/
+	function computeHeadingMetrics(sheet, printRange, fontManager, options) {
+		const fontSize = 8;
+		const resourceName = fontManager.hasEmbeddedFont() ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(resolvePdfFontName(options.defaultFontFamily, false, false));
+		const lastRow = printRange?.endRow ?? sheet.bounds.bottom;
+		const widestLabel = String(Math.max(1, lastRow));
+		fontManager.trackText(widestLabel);
+		return {
+			gutterWidth: fontManager.measureText(widestLabel, resourceName, fontSize) + 6,
+			bandHeight: 14,
+			fontSize
+		};
+	}
+	/**
+	* Largest scale ≤ `startScale` whose real pagination lands within `target`
+	* pages, found by bisection.
+	*
+	* The caller passes a closure that re-paginates at a candidate scale, so the
+	* answer respects indivisible columns/rows, manual breaks and repeated title
+	* bands instead of trusting a total-size ratio. Returns `startScale` untouched
+	* when it already fits, so nothing is shrunk needlessly.
+	*
+	* `minScale` is the floor the result may not go below. When the target is
+	* unreachable even there — manual page breaks alone can force more pages than
+	* requested — the floor is returned and the sheet simply spans more than
+	* `target` pages, which is preferable to shrinking it into illegibility.
+	*/
+	function tightenToPageCount(pageCountAt, target, startScale, minScale) {
+		const start = Math.max(startScale, minScale);
+		if (pageCountAt(start) <= target || start <= minScale) return start;
+		let lo = minScale;
+		let hi = start;
+		if (pageCountAt(lo) > target) return lo;
+		for (let i = 0; i < 24; i++) {
+			const mid = (lo + hi) / 2;
+			if (pageCountAt(mid) <= target) lo = mid;
+			else hi = mid;
+		}
+		return lo;
+	}
+	/**
+	* Lay out Excel's "Comments at end of sheet" as extra pages.
+	*
+	* Each entry becomes an ordinary {@link LayoutCell} spanning the content width,
+	* so the existing page renderer draws them with no special casing — including
+	* word wrapping, which long comment bodies need. Pages are filled top to bottom
+	* and a new one starts when the next entry would overflow.
+	*/
+	function buildCommentPages(sheet, comments, options, fontManager) {
+		const { width: pageWidth, height: pageHeight } = pageDimensions(options);
+		const { margins } = options;
+		const headerHeight = options.showSheetNames ? 20 : 0;
+		const footerHeight = options.showPageNumbers ? 20 : 0;
+		const contentWidth = pageWidth - margins.left - margins.right;
+		const top = pageHeight - margins.top - headerHeight;
+		const bottom = margins.bottom + footerHeight;
+		const fontSize = options.defaultFontSize;
+		const resourceName = fontManager.hasEmbeddedFont() ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(resolvePdfFontName(options.defaultFontFamily, false, false));
+		const measure = (text) => fontManager.measureText(text, resourceName, fontSize);
+		const lineHeight = fontSize * LINE_HEIGHT_FACTOR;
+		const textColor = {
+			r: 0,
+			g: 0,
+			b: 0
+		};
+		const pages = [];
+		let cells = [];
+		let cursor = top;
+		const flush = () => {
+			if (cells.length > 0) {
+				pages.push({
+					...blankPage(sheet, options),
+					cells
+				});
+				cells = [];
+				cursor = top;
+			}
+		};
+		const push = (text, bold) => {
+			fontManager.trackText(text);
+			const lines = wrapTextLines(text, measure, Math.max(contentWidth - 6, 1));
+			const height = Math.max(lines.length, 1) * lineHeight + 4;
+			if (cursor - height < bottom) flush();
+			cells.push({
+				text,
+				rect: {
+					x: margins.left,
+					y: cursor - height,
+					width: contentWidth,
+					height
+				},
+				fontFamily: options.defaultFontFamily,
+				fontSize,
+				bold,
+				italic: false,
+				strike: false,
+				underline: false,
+				textColor,
+				fillColor: null,
+				horizontalAlign: "left",
+				verticalAlign: "top",
+				wrapText: true,
+				borders: {
+					top: null,
+					right: null,
+					bottom: null,
+					left: null
+				},
+				borderInsets: {
+					top: 0,
+					right: 0,
+					bottom: 0,
+					left: 0
+				},
+				colSpan: 1,
+				rowSpan: 1,
+				hyperlink: null,
+				richText: null,
+				textRotation: 0,
+				indent: 0,
+				textOverflowWidth: 0
+			});
+			cursor -= height;
+		};
+		push(`${sheet.name} — comments`, true);
+		for (const comment of comments) {
+			const author = comment.author ? ` (${comment.author})` : "";
+			push(`${comment.ref}${author}: ${comment.text}`, false);
+		}
+		flush();
+		return pages;
+	}
+	/**
 	* Build the LayoutPage for a single rowPage × colGroup combination.
 	*/
 	function buildPageLayout(ctx, rowPage, colGroup, currentPageCount, sheet, options, fontManager) {
-		const { scaledColumnWidths, rowHeights, visibleRows, visibleCols, mergeMap, pageWidth, pageHeight, contentWidth, headerHeight, scaleFactor, margins } = ctx;
+		const { scaledColumnWidths, rowHeights, visibleRows, visibleCols, mergeMap, pageWidth, pageHeight, contentWidth, availableHeight, headerHeight, scaleFactor, margins, headings } = ctx;
 		const cells = [];
+		const gridLeft = margins.left + (headings?.gutterWidth ?? 0);
+		const gridTop = pageHeight - margins.top - headerHeight - (headings?.bandHeight ?? 0);
 		const groupColWidths = colGroup.map((ci) => scaledColumnWidths[ci]);
 		const groupTotalWidth = groupColWidths.reduce((s, w) => s + w, 0);
 		const groupColOffsets = [];
-		let gx = margins.left;
-		if (groupTotalWidth < contentWidth) gx = margins.left + (contentWidth - groupTotalWidth) / 2;
+		let gx = gridLeft;
+		if (options.horizontalCentered && groupTotalWidth < contentWidth) gx = gridLeft + (contentWidth - groupTotalWidth) / 2;
 		for (const w of groupColWidths) {
 			groupColOffsets.push(gx);
 			gx += w;
 		}
 		const rowYPositions = [];
 		const pageRowHeights = [];
-		let currentY = pageHeight - margins.top - headerHeight;
+		let currentY = gridTop;
+		if (options.verticalCentered) {
+			const pageTotalHeight = rowPage.reduce((sum, rowIdx) => sum + (rowHeights[rowIdx] ?? DEFAULT_ROW_HEIGHT * scaleFactor), 0);
+			if (pageTotalHeight < availableHeight) currentY -= (availableHeight - pageTotalHeight) / 2;
+		}
 		for (const rowIdx of rowPage) {
 			const rowH = rowHeights[rowIdx] ?? DEFAULT_ROW_HEIGHT * scaleFactor;
 			rowYPositions.push(currentY);
@@ -35314,7 +35811,10 @@ this.Documonster = this.Documonster || {};
 				const rectY = cellY - cellHeight;
 				cells.push(buildLayoutCell(cell, cellX, rectY, cellWidth, cellHeight, colSpan, rowSpan, options, fontManager, scaleFactor));
 				const layoutCell = cells[cells.length - 1];
-				if (mergeInfo?.isMaster) propagateMergeBorders(layoutCell, mergeInfo, wsRowNumber, wsColNumber, sheet);
+				if (mergeInfo?.isMaster) {
+					propagateMergeBorders(layoutCell, mergeInfo, wsRowNumber, wsColNumber, sheet);
+					if (options.blackAndWhite) layoutCell.borders = grayscaleBorders(layoutCell.borders);
+				}
 				cellGrid.set(`${ri}:${gci}`, layoutCell);
 			}
 		}
@@ -35340,36 +35840,94 @@ this.Documonster = this.Documonster || {};
 			images: [],
 			charts: [],
 			scaleFactor,
+			headings,
+			commentBoxes: options.cellComments === "asDisplayed" ? placeCommentBoxes(sheet, colGroup.map((ci) => visibleCols[ci]), groupColOffsets, groupColWidths, rowPage.map((ri) => visibleRows[ri]), rowYPositions, pageRowHeights, options, scaleFactor) : void 0,
 			headerFooter: options.includeHeadersFooters ? sheet.headerFooter : void 0
 		};
 	}
-	function createEmptyPage(sheet, options) {
-		let pageWidth = options.pageSize.width;
-		let pageHeight = options.pageSize.height;
-		if (options.orientation === "landscape") [pageWidth, pageHeight] = [pageHeight, pageWidth];
+	/**
+	* Position each comment box on a page, for `cellComments: "asDisplayed"`.
+	*
+	* A comment is placed when its box overlaps the page's tracks. Fractional VML
+	* coordinates are interpolated against the page's own column offsets and row
+	* positions, so a box lands correctly even when the scale, hidden tracks or
+	* repeated title bands have moved the grid around. Comments whose box falls
+	* entirely outside the page are skipped, which keeps each one on a single page
+	* rather than slicing it across the seam.
+	*/
+	function placeCommentBoxes(sheet, sheetCols, columnOffsets, columnWidths, sheetRows, rowYPositions, rowHeights, options, scaleFactor) {
+		const comments = sheet.comments;
+		if (!comments?.length || sheetCols.length === 0 || sheetRows.length === 0) return;
+		const xAt = (col) => {
+			const index = sheetCols.indexOf(Math.floor(col) + 1);
+			if (index < 0) return;
+			return columnOffsets[index] + (col - Math.floor(col)) * columnWidths[index];
+		};
+		const yAt = (row) => {
+			const index = sheetRows.indexOf(Math.floor(row) + 1);
+			if (index < 0) return;
+			return rowYPositions[index] - (row - Math.floor(row)) * rowHeights[index];
+		};
+		const boxes = [];
+		for (const comment of comments) {
+			const anchor = comment.anchor ?? defaultCommentAnchor(comment.ref);
+			if (!anchor) continue;
+			const left = xAt(anchor.left);
+			const right = xAt(anchor.right);
+			const top = yAt(anchor.top);
+			const bottom = yAt(anchor.bottom);
+			if (left === void 0 || right === void 0 || top === void 0 || bottom === void 0) continue;
+			const width = right - left;
+			const height = top - bottom;
+			if (width <= 0 || height <= 0) continue;
+			const cell = parseCellRef(comment.ref);
+			const markerCol = sheetCols.indexOf(cell.c + 1);
+			const markerRow = sheetRows.indexOf(cell.r + 1);
+			const author = comment.author ? `${comment.author}:\n` : "";
+			boxes.push({
+				rect: {
+					x: left,
+					y: bottom,
+					width,
+					height
+				},
+				text: `${author}${comment.text}`,
+				fontSize: options.defaultFontSize * scaleFactor,
+				marker: markerCol >= 0 && markerRow >= 0 ? {
+					x: columnOffsets[markerCol] + columnWidths[markerCol],
+					y: rowYPositions[markerRow],
+					size: 4 * scaleFactor
+				} : void 0
+			});
+		}
+		return boxes.length > 0 ? boxes : void 0;
+	}
+	/**
+	* Excel's default comment placement, used when the note carries no VML anchor.
+	*
+	* Mirrors the geometry Excel writes for a fresh comment: the box starts at the
+	* commented cell's column, two rows above it, and spans two columns by four
+	* rows.
+	*/
+	function defaultCommentAnchor(ref) {
+		let cell;
+		try {
+			cell = parseCellRef(ref);
+		} catch {
+			return;
+		}
+		const left = cell.c + 6 / 68;
+		const top = Math.max(cell.r - 2, 0) + 14 / 18;
 		return {
-			pageNumber: 1,
-			sheetPageNumber: sheet.pageSetup?.firstPageNumber ?? 1,
-			sheetPageIndex: 1,
-			sheetPageCount: 1,
-			firstPageNumber: sheet.pageSetup?.firstPageNumber,
-			options,
-			cells: [],
-			width: pageWidth,
-			height: pageHeight,
-			sheetName: sheet.name,
-			sheetCols: [],
-			columnOffsets: [],
-			columnWidths: [],
-			sheetRows: [],
-			rowYPositions: [],
-			rowHeights: [],
-			images: [],
-			charts: [],
-			scaleFactor: 1,
-			headerFooter: options.includeHeadersFooters ? sheet.headerFooter : void 0
+			left,
+			top,
+			right: left + 2,
+			bottom: top + 4
 		};
 	}
+	function createEmptyPage(sheet, options) {
+		return blankPage(sheet, options);
+	}
 	/**
 	* Parse a cell reference like "A1" into 0-indexed { c, r }.
 	*/
@@ -35426,63 +35984,87 @@ this.Documonster = this.Documonster || {};
 			return null;
 		}
 	}
-	function computeColumnWidths(sheet, printRange) {
+	function computeColumnWidths(sheet, printRange, titleBand) {
 		const bounds = sheet.bounds;
 		if (!(bounds.top > 0 && bounds.left > 0)) return {
 			columnWidths: [],
-			visibleCols: []
+			visibleCols: [],
+			repeatColIndices: []
 		};
 		const startCol = printRange?.startCol ?? bounds.left;
 		const endCol = printRange?.endCol ?? bounds.right;
 		const columnWidths = [];
 		const visibleCols = [];
-		for (let c = startCol; c <= endCol; c++) {
+		const emitted = /* @__PURE__ */ new Set();
+		const push = (c) => {
+			if (emitted.has(c)) return;
 			const col = sheet.columns.get(c);
-			if (col?.hidden) continue;
+			if (col?.hidden) return;
+			emitted.add(c);
 			const pixelWidth = charWidthToPixel(col?.width ?? DEFAULT_COLUMN_WIDTH$1, 7);
 			const pointWidth = Math.max(pixelWidth * PX_TO_PT, MIN_COLUMN_WIDTH);
 			columnWidths.push(pointWidth);
 			visibleCols.push(c);
-		}
+		};
+		const titleFullyInside = titleBand && titleBand.first >= startCol && titleBand.last <= endCol;
+		if (titleBand && !titleFullyInside) for (let c = titleBand.first; c <= titleBand.last; c++) push(c);
+		for (let c = startCol; c <= endCol; c++) push(c);
 		return {
 			columnWidths,
-			visibleCols
+			visibleCols,
+			repeatColIndices: titleBand ? visibleCols.flatMap((c, i) => c >= titleBand.first && c <= titleBand.last ? [i] : []) : []
 		};
 	}
-	function computeRowHeights(sheet, scaleFactor, printRange, fontManager, options) {
+	/**
+	* Measure every printable row at 100% scale.
+	*
+	* Heights are deliberately unscaled: `countWrapLines` derives the wrapped line
+	* count from ratios that are independent of the print scale, so a scaled height
+	* is exactly `unscaled * scale`. Measuring once and multiplying avoids re-running
+	* the most expensive step of layout for every probe of the fit solver.
+	*/
+	function computeRowHeights(sheet, printRange, fontManager, options, titleBand) {
 		const bounds = sheet.bounds;
 		if (bounds.top <= 0) return {
 			rowHeights: [],
-			visibleRows: []
+			visibleRows: [],
+			repeatRowIndices: []
 		};
 		const startRow = printRange?.startRow ?? bounds.top;
 		const endRow = printRange?.endRow ?? bounds.bottom;
 		const rowHeights = [];
 		const visibleRows = [];
-		for (let r = startRow; r <= endRow; r++) {
+		const emitted = /* @__PURE__ */ new Set();
+		const push = (r) => {
+			if (emitted.has(r)) return;
 			const row = sheet.rows.get(r);
-			if (row?.hidden) continue;
+			if (row?.hidden) return;
+			emitted.add(r);
 			let height;
 			if (row?.height && row.customHeight) height = row.height;
-			else if (row?.height) height = Math.max(row.height, autoRowHeight(row, scaleFactor, sheet, fontManager, options));
-			else height = autoRowHeight(row, scaleFactor, sheet, fontManager, options);
-			rowHeights.push(height * scaleFactor);
+			else if (row?.height) height = Math.max(row.height, autoRowHeight(row, sheet, fontManager, options));
+			else height = autoRowHeight(row, sheet, fontManager, options);
+			rowHeights.push(height);
 			visibleRows.push(r);
-		}
+		};
+		const titleFullyInside = titleBand && titleBand.first >= startRow && titleBand.last <= endRow;
+		if (titleBand && !titleFullyInside) for (let r = titleBand.first; r <= titleBand.last; r++) push(r);
+		for (let r = startRow; r <= endRow; r++) push(r);
 		return {
 			rowHeights,
-			visibleRows
+			visibleRows,
+			repeatRowIndices: titleBand ? visibleRows.flatMap((r, i) => r >= titleBand.first && r <= titleBand.last ? [i] : []) : []
 		};
 	}
 	/**
 	* Compute the minimum row height required to display wrapped cell content.
 	* Returns at least `DEFAULT_ROW_HEIGHT`.
 	*/
-	function autoRowHeight(row, scaleFactor, sheet, fontManager, options) {
+	function autoRowHeight(row, sheet, fontManager, options) {
 		let height = DEFAULT_ROW_HEIGHT;
 		if (row) for (const cell of row.cells.values()) {
 			const fontSize = getCellFontSize(cell);
-			const wrapLineCount = countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options);
+			const wrapLineCount = countWrapLines(cell, fontSize, sheet, fontManager, options);
 			const lineHeight = fontSize * LINE_HEIGHT_FACTOR;
 			const borderTop = cell.style?.border?.top?.style ? borderStyleToLineWidth(cell.style.border.top.style) / 2 : 0;
 			const borderBottom = cell.style?.border?.bottom?.style ? borderStyleToLineWidth(cell.style.border.bottom.style) / 2 : 0;
@@ -35512,31 +36094,30 @@ this.Documonster = this.Documonster || {};
 	* Count the wrap-line count for a cell, using actual font measurements
 	* so row heights match the page renderer exactly.
 	*/
-	function countWrapLines(cell, fontSize, scaleFactor, sheet, fontManager, options) {
+	function countWrapLines(cell, fontSize, sheet, fontManager, options) {
 		const text = typeof cell.text === "string" ? cell.text : String(cell.text ?? "");
 		const lineCount = Math.max(1, (text.match(/\n/g) ?? []).length + 1);
 		if (!cell.style?.alignment?.wrapText || text.length === 0) return lineCount;
-		const scaledColPts = charWidthToPixel(sheet.columns.get(cell.col)?.width ?? DEFAULT_COLUMN_WIDTH$1, 7) * PX_TO_PT * scaleFactor;
+		const colPts = charWidthToPixel(sheet.columns.get(cell.col)?.width ?? DEFAULT_COLUMN_WIDTH$1, 7) * PX_TO_PT;
 		const indent = cell.style.alignment.indent ?? 0;
 		const borderLeft = cell.style?.border?.left?.style ? borderStyleToLineWidth(cell.style.border.left.style) / 2 : 0;
 		const borderRight = cell.style?.border?.right?.style ? borderStyleToLineWidth(cell.style.border.right.style) / 2 : 0;
 		const padding = 3 + borderLeft + (3 + borderRight) + indent * 10;
-		const effectiveWidth = Math.max(scaledColPts - padding, 1);
+		const effectiveWidth = Math.max(colPts - padding, 1);
 		if (cell.type === PdfCellType.RichText) {
 			const value = cell.value;
 			if (value && typeof value === "object" && "richText" in value) {
 				const runs = value.richText;
 				if (runs.length > 0) {
-					const wrappedCount = countRichTextWrapLines(text, runs, scaleFactor, effectiveWidth, fontManager, options, cell.style?.font);
+					const wrappedCount = countRichTextWrapLines(text, runs, effectiveWidth, fontManager, options, cell.style?.font);
 					return Math.max(lineCount, wrappedCount);
 				}
 			}
 		}
-		const scaledFontSize = fontSize * scaleFactor;
 		const fontProps = extractFontProperties(cell.style.font, options.defaultFontFamily, options.defaultFontSize);
 		const pdfFontName = resolvePdfFontName(fontProps.fontFamily, fontProps.bold, fontProps.italic);
 		const resourceName = fontManager.hasEmbeddedFont() ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(pdfFontName);
-		const measure = (s) => fontManager.measureText(s, resourceName, scaledFontSize);
+		const measure = (s) => fontManager.measureText(s, resourceName, fontSize);
 		const wrappedLines = wrapTextLines(text, measure, effectiveWidth);
 		return Math.max(lineCount, wrappedLines.length);
 	}
@@ -35545,7 +36126,7 @@ this.Documonster = this.Documonster || {};
 	* This mirrors the logic in wrapRichTextLines (page-renderer) so that
 	* the row height calculation matches the actual rendering.
 	*/
-	function countRichTextWrapLines(text, runs, scaleFactor, effectiveWidth, fontManager, options, cellFont) {
+	function countRichTextWrapLines(text, runs, effectiveWidth, fontManager, options, cellFont) {
 		const defaultFamily = cellFont?.name ?? options.defaultFontFamily;
 		const defaultSize = cellFont?.size ?? options.defaultFontSize;
 		const runForChar = [];
@@ -35569,7 +36150,7 @@ this.Documonster = this.Documonster || {};
 				size: run.font.size ?? cellFont?.size,
 				bold: run.font.bold ?? false,
 				italic: run.font.italic ?? false
-			} : cellFont, defaultFamily, defaultSize).fontSize * scaleFactor;
+			} : cellFont, defaultFamily, defaultSize).fontSize;
 		});
 		const measureRange = (start, end) => {
 			let width = 0;
@@ -35638,17 +36219,21 @@ this.Documonster = this.Documonster || {};
 		return Math.max(1, totalLines);
 	}
 	/**
-	* Build a set of visible-row indices where manual page breaks occur.
+	* Translate manual break positions from sheet track numbers into indices of the
+	* printed track list.
+	*
+	* A break sits *after* its track, so the following index starts a new page.
+	* Shared by both axes; computed once per sheet because the fit solver paginates
+	* many times and must not rebuild the lookup on every probe.
 	*/
-	function buildRowBreakSet(sheet, visibleRows) {
+	function buildBreakSet(breakTracks, visibleTracks) {
 		const breaks = /* @__PURE__ */ new Set();
-		const rowBreaks = sheet.rowBreaks ?? [];
-		if (rowBreaks.length === 0) return breaks;
-		const rowToIndex = /* @__PURE__ */ new Map();
-		for (let i = 0; i < visibleRows.length; i++) rowToIndex.set(visibleRows[i], i);
-		for (const brk of rowBreaks) {
-			const idx = rowToIndex.get(brk);
-			if (idx !== void 0) breaks.add(idx + 1);
+		if (breakTracks.length === 0) return breaks;
+		const trackToIndex = /* @__PURE__ */ new Map();
+		for (let i = 0; i < visibleTracks.length; i++) trackToIndex.set(visibleTracks[i], i);
+		for (const track of breakTracks) {
+			const index = trackToIndex.get(track);
+			if (index !== void 0) breaks.add(index + 1);
 		}
 		return breaks;
 	}
@@ -35676,89 +36261,73 @@ this.Documonster = this.Documonster || {};
 		}
 		return map;
 	}
-	function paginateRows(rowHeights, availableHeight, repeatRowCount, rowBreaks) {
-		if (rowHeights.length === 0) return [[]];
+	/**
+	* Split a track list (rows or columns) into pages.
+	*
+	* One implementation serves both axes: heights against the available page
+	* height, widths against the content width. The axes differ only in the overflow
+	* tolerance, so `epsilon` is the sole parameter that distinguishes them —
+	* columns need a small slack because scaled point widths accumulate rounding.
+	*
+	* `repeatIndices` are the tracks of a print-title band. They are re-emitted at
+	* the start of every page after the first, which is why they are absolute
+	* indices rather than a count: a band may sit in the middle of the printed range
+	* (Excel allows `printTitlesColumn = "C:D"`).
+	*
+	* Manual breaks are honoured via `breaks`, holding the index that must start a
+	* new page.
+	*/
+	function paginateTracks(sizes, available, repeatIndices, breaks, epsilon = 0) {
+		if (sizes.length === 0) return [[]];
 		const pages = [];
-		let currentPage = [];
-		let currentPageHeight = 0;
+		let current = [];
+		let used = 0;
 		let isFirstPage = true;
 		let repeatedPrefixCount = 0;
-		const addRepeatRows = () => {
+		const repeatSet = new Set(repeatIndices);
+		const addRepeats = () => {
 			repeatedPrefixCount = 0;
-			for (let h = 0; h < repeatRowCount && h < rowHeights.length; h++) {
-				if (currentPageHeight + rowHeights[h] > availableHeight && currentPage.length > 0) break;
-				currentPage.push(h);
-				currentPageHeight += rowHeights[h];
+			for (const index of repeatIndices) {
+				if (index >= sizes.length) continue;
+				if (used + sizes[index] > available + epsilon && current.length > 0) break;
+				current.push(index);
+				used += sizes[index];
 				repeatedPrefixCount++;
 			}
 		};
-		for (let i = 0; i < rowHeights.length; i++) {
-			const rowHeight = rowHeights[i];
-			const pageAvailable = availableHeight;
-			let skipRepeatedRow = false;
-			while (true) {
-				const forceBreak = rowBreaks.has(i) && currentPage.length > 0;
-				if ((forceBreak || currentPageHeight + rowHeight > pageAvailable) && currentPage.length > 0) {
-					if (!forceBreak && !isFirstPage && currentPage.length > 0 && currentPage.length === repeatedPrefixCount) {
-						currentPage = [];
-						currentPageHeight = 0;
+		for (let i = 0; i < sizes.length; i++) {
+			const size = sizes[i];
+			let breakConsumed = false;
+			for (;;) {
+				const forceBreak = !breakConsumed && breaks.has(i) && current.length > 0;
+				if ((forceBreak || used + size > available + epsilon) && current.length > 0) {
+					if (forceBreak) breakConsumed = true;
+					if (!forceBreak && !isFirstPage && current.length === repeatedPrefixCount) {
+						current = [];
+						used = 0;
 						repeatedPrefixCount = 0;
 						continue;
 					}
-					pages.push(currentPage);
-					currentPage = [];
-					currentPageHeight = 0;
+					pages.push(current);
+					current = [];
+					used = 0;
 					repeatedPrefixCount = 0;
 					isFirstPage = false;
-					addRepeatRows();
+					addRepeats();
 					continue;
 				}
-				if (!isFirstPage && i < repeatRowCount && currentPage.includes(i)) {
-					skipRepeatedRow = true;
-					break;
+				if (isFirstPage || !repeatSet.has(i) || !current.includes(i)) {
+					current.push(i);
+					used += size;
 				}
-				currentPage.push(i);
-				currentPageHeight += rowHeight;
 				break;
 			}
-			if (skipRepeatedRow) continue;
-		}
-		if (currentPage.length > 0) pages.push(currentPage);
-		return pages.length > 0 ? pages : [[]];
-	}
-	/**
-	* Split columns into groups for horizontal pagination.
-	*/
-	function paginateColumns(columnWidths, contentWidth, sheet, visibleCols) {
-		if (columnWidths.length === 0) return [[]];
-		const colBreaks = /* @__PURE__ */ new Set();
-		const wsColBreaks = sheet.colBreaks ?? [];
-		if (wsColBreaks.length > 0) {
-			const colToIndex = /* @__PURE__ */ new Map();
-			for (let i = 0; i < visibleCols.length; i++) colToIndex.set(visibleCols[i], i);
-			for (const brk of wsColBreaks) {
-				const idx = colToIndex.get(brk);
-				if (idx !== void 0) colBreaks.add(idx + 1);
-			}
-		}
-		const groups = [];
-		let currentGroup = [];
-		let currentWidth = 0;
-		for (let i = 0; i < columnWidths.length; i++) {
-			const colWidth = columnWidths[i];
-			if ((colBreaks.has(i) && currentGroup.length > 0 || currentWidth + colWidth > contentWidth + .01) && currentGroup.length > 0) {
-				groups.push(currentGroup);
-				currentGroup = [];
-				currentWidth = 0;
-			}
-			currentGroup.push(i);
-			currentWidth += colWidth;
 		}
-		if (currentGroup.length > 0) groups.push(currentGroup);
-		return groups.length > 0 ? groups : [Array.from({ length: columnWidths.length }, (_, i) => i)];
+		if (current.length > 0) pages.push(current);
+		return pages;
 	}
 	function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, fontManager, scaleFactor) {
-		const text = cell?.text ?? "";
+		const text = resolveErrorText(cell, options.errors);
 		const style = cell?.style ?? {};
 		const fontProps = extractFontProperties(style.font, options.defaultFontFamily, options.defaultFontSize);
 		const scaledFontSize = fontProps.fontSize * scaleFactor;
@@ -35769,7 +36338,9 @@ this.Documonster = this.Documonster || {};
 			fontManager.trackText(text);
 		}
 		const richText = buildRichTextRuns(cell, options, fontManager, scaleFactor, style.font);
-		const borders = excelBordersToPdf(style.border);
+		const rawBorders = excelBordersToPdf(style.border);
+		const borders = options.blackAndWhite ? grayscaleBorders(rawBorders) : rawBorders;
+		const rawFill = excelFillToPdfColor(style.fill);
 		return {
 			text,
 			rect: {
@@ -35784,8 +36355,8 @@ this.Documonster = this.Documonster || {};
 			italic: fontProps.italic,
 			strike: fontProps.strike,
 			underline: fontProps.underline,
-			textColor: fontProps.textColor,
-			fillColor: excelFillToPdfColor(style.fill),
+			textColor: options.blackAndWhite ? toGrayscale(fontProps.textColor) : fontProps.textColor,
+			fillColor: options.blackAndWhite && rawFill !== null ? toGrayscale(rawFill) : rawFill,
 			horizontalAlign: resolveHorizontalAlign(style.alignment, cell?.type, cell?.result),
 			verticalAlign: excelVAlignToPdf(style.alignment),
 			wrapText: style.alignment?.wrapText ?? false,
@@ -35873,7 +36444,7 @@ this.Documonster = this.Documonster || {};
 	*  - `br` — when present — locates the opposite corner, so the rect size is
 	*    the difference.
 	*  - `ext` — when present — overrides the size directly. Images use pixels
-	*    (px × 0.75 = pt); charts use EMU (EMU / 9525 = pt). The `extUnit`
+	*    (px × 0.75 = pt); charts use EMU (EMU / 12700 = pt). The `extUnit`
 	*    field disambiguates. Historical callers that omit `extUnit` keep
 	*    the legacy px behaviour.
 	*
@@ -35899,8 +36470,8 @@ this.Documonster = this.Documonster || {};
 		const extUnit = range.extUnit ?? "px";
 		if (range.ext) {
 			if (extUnit === "emu") {
-				width = emuToPx$1(range.ext.width) * scaleFactor;
-				height = emuToPx$1(range.ext.height) * scaleFactor;
+				width = emuToPt$1(range.ext.width) * scaleFactor;
+				height = emuToPt$1(range.ext.height) * scaleFactor;
 			} else {
 				width = range.ext.width * .75 * scaleFactor;
 				height = range.ext.height * .75 * scaleFactor;
@@ -36006,13 +36577,16 @@ this.Documonster = this.Documonster || {};
 				continue;
 			}
 			const tl = chart.range.tl;
+			const tlCol = (tl.nativeCol ?? tl.col ?? 0) + 1;
 			const tlRow = (tl.nativeRow ?? tl.row ?? 0) + 1;
+			const band = layoutPages.filter((page) => page.sheetCols.includes(tlCol));
+			const ordered = (band.length > 0 ? band : [...layoutPages]).sort((a, b) => (a.sheetRows[0] ?? 0) - (b.sheetRows[0] ?? 0));
 			let targetPage;
-			for (let pi = 0; pi < layoutPages.length; pi++) {
-				const page = layoutPages[pi];
+			for (let pi = 0; pi < ordered.length; pi++) {
+				const page = ordered[pi];
 				const lastPageRow = page.sheetRows[page.sheetRows.length - 1] ?? 0;
-				if (lastPageRow >= tlRow - 1 && pi + 1 < layoutPages.length) {
-					targetPage = layoutPages[pi + 1];
+				if (lastPageRow >= tlRow - 1 && pi + 1 < ordered.length) {
+					targetPage = ordered[pi + 1];
 					break;
 				}
 				if (lastPageRow >= tlRow) {
@@ -36020,7 +36594,7 @@ this.Documonster = this.Documonster || {};
 					break;
 				}
 			}
-			if (!targetPage) targetPage = layoutPages[layoutPages.length - 1];
+			if (!targetPage) targetPage = ordered[ordered.length - 1];
 			if (targetPage) {
 				const margins = targetPage.options.margins;
 				const headerH = targetPage.options.showSheetNames ? 20 : 0;
@@ -36155,10 +36729,28 @@ this.Documonster = this.Documonster || {};
 				italic: fontProps.italic,
 				strike: fontProps.strike,
 				underline: fontProps.underline,
-				textColor: fontProps.textColor
+				textColor: options.blackAndWhite ? toGrayscale(fontProps.textColor) : fontProps.textColor
 			};
 		});
 	}
+	/**
+	* Apply Excel's "Cell errors as" print option to a cell's display text.
+	*
+	* Error values reach the PDF model in two shapes: a plain error cell
+	* (`PdfCellType.Error`) and a formula whose computed result is an error
+	* (`PdfCellType.Formula` with an `{ error }` result). Both must be substituted.
+	*/
+	function resolveErrorText(cell, mode) {
+		const text = cell?.text ?? "";
+		if (mode === "displayed" || !cell) return text;
+		if (!(cell.type === PdfCellType.Error || cell.type === PdfCellType.Formula && typeof cell.result === "object" && cell.result !== null && "error" in cell.result)) return text;
+		switch (mode) {
+			case "blank": return "";
+			case "dash": return "--";
+			case "NA": return "#N/A";
+			default: return text;
+		}
+	}
 	var DEFAULT_COLUMN_WIDTH$1, DEFAULT_ROW_HEIGHT, MIN_COLUMN_WIDTH;
 	var init_layout_engine = __esmMin((() => {
 		init_font_manager();
@@ -36269,7 +36861,7 @@ this.Documonster = this.Documonster || {};
 			if (!chart.drawVector) continue;
 			const stream = new PdfContentStream();
 			const alphaValues = /* @__PURE__ */ new Set();
-			const surface = createChartSurface(stream, fontManager, alphaValues);
+			const surface = createChartSurface(stream, fontManager, alphaValues, page.options.blackAndWhite);
 			chart.drawVector(surface, constrainChartAspectRatio(chart.rect));
 			cache.set(chart, {
 				stream,
@@ -36363,6 +36955,7 @@ this.Documonster = this.Documonster || {};
 		try {
 			const { stream: contentStream, alphaValues } = renderPage(page, page.options, fontManager, totalPages);
 			const imageXObjects = /* @__PURE__ */ new Map();
+			const grayscaleRaster = page.options.blackAndWhite;
 			let headerImageContentObjNum;
 			const headerContent = selectHeaderFooter(page, "header");
 			const footerContent = selectHeaderFooter(page, "footer");
@@ -36373,15 +36966,18 @@ this.Documonster = this.Documonster || {};
 				const alignWithMargins = page.headerFooter?.alignWithMargins !== false;
 				const leftEdge = alignWithMargins ? page.options.margins.left : 18;
 				const rightEdge = alignWithMargins ? page.width - page.options.margins.right : page.width - 18;
+				const hfScale = page.headerFooter?.scaleWithDoc === false ? 1 : page.scaleFactor;
 				for (let index = 0; index < headerImages.length; index++) {
 					const headerImage = headerImages[index];
 					if (!activePositions.has(headerImage.position)) continue;
 					const imageName = `HfIm${index + 1}`;
-					imageXObjects.set(imageName, getOrWriteImageObject(writer, imageObjectCache, headerImage.data, headerImage.format));
+					imageXObjects.set(imageName, getOrWriteImageObject(writer, imageObjectCache, headerImage.data, headerImage.format, grayscaleRaster));
+					const drawWidth = headerImage.width * hfScale;
+					const drawHeight = headerImage.height * hfScale;
 					const placement = headerFooterImagePlacement(headerImage.position);
-					const imageX = placement.section === "left" ? leftEdge : placement.section === "right" ? rightEdge - headerImage.width : (page.width - headerImage.width) / 2;
-					const imageY = placement.kind === "header" ? page.height - page.options.headerMargin - headerImage.height : page.options.footerMargin;
-					imageStream.drawImage(imageName, imageX, imageY, headerImage.width, headerImage.height);
+					const imageX = placement.section === "left" ? leftEdge : placement.section === "right" ? rightEdge - drawWidth : (page.width - drawWidth) / 2;
+					const imageY = placement.kind === "header" ? page.height - page.options.headerMargin - drawHeight : page.options.footerMargin;
+					imageStream.drawImage(imageName, imageX, imageY, drawWidth, drawHeight);
 				}
 				headerImageContentObjNum = writer.allocObject();
 				writer.addStreamObject(headerImageContentObjNum, new PdfDict(), imageStream);
@@ -36389,7 +36985,7 @@ this.Documonster = this.Documonster || {};
 			if (page.images.length > 0) for (let imgIdx = 0; imgIdx < page.images.length; imgIdx++) {
 				const img = page.images[imgIdx];
 				const imgName = `Im${imgIdx + 1}`;
-				const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, img.data, img.format);
+				const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, img.data, img.format, grayscaleRaster);
 				imageXObjects.set(imgName, imgObjNum);
 				contentStream.drawImage(imgName, img.rect.x, img.rect.y, img.rect.width, img.rect.height);
 			}
@@ -36405,7 +37001,7 @@ this.Documonster = this.Documonster || {};
 					}
 					if (chart.raster) {
 						const imgName = `Im${++rasterCounter}`;
-						const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, chart.raster.data, chart.raster.format);
+						const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, chart.raster.data, chart.raster.format, grayscaleRaster);
 						imageXObjects.set(imgName, imgObjNum);
 						contentStream.drawImage(imgName, chart.rect.x, chart.rect.y, chart.rect.width, chart.rect.height);
 					}
@@ -36417,7 +37013,7 @@ this.Documonster = this.Documonster || {};
 				const wmResult = renderWatermark(wmContentStream, page, watermark, fontManager);
 				for (const alpha of wmResult.alphaValues) alphaValues.add(alpha);
 				for (const wmImg of wmResult.imageXObjects) {
-					const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, wmImg.data, wmImg.format);
+					const imgObjNum = getOrWriteImageObject(writer, imageObjectCache, wmImg.data, wmImg.format, grayscaleRaster);
 					imageXObjects.set(wmImg.name, imgObjNum);
 				}
 				watermarkContentObjNum = writer.allocObject();
@@ -36469,6 +37065,7 @@ this.Documonster = this.Documonster || {};
 				height: page.height,
 				contentsRef,
 				resourcesRef: resourcesObjNum,
+				transparencyGroup: alphaValues.size > 0,
 				annotRefs: annotRefs.length > 0 ? annotRefs : void 0
 			});
 			pageObjNums.push(pageObjNum);
@@ -36477,11 +37074,16 @@ this.Documonster = this.Documonster || {};
 			throw new PdfRenderError(`Failed to render page ${page.pageNumber} of "${page.sheetName}"`, { cause: err });
 		}
 	}
-	function getOrWriteImageObject(writer, cache, data, format) {
-		const existing = cache.get(data);
+	function getOrWriteImageObject(writer, cache, data, format, grayscale = false) {
+		let variants = cache.get(data);
+		if (variants === void 0) {
+			variants = /* @__PURE__ */ new Map();
+			cache.set(data, variants);
+		}
+		const existing = variants.get(grayscale);
 		if (existing !== void 0) return existing;
-		const objectNumber = writeImageXObject(writer, data, format);
-		cache.set(data, objectNumber);
+		const objectNumber = writeImageXObject(writer, data, format, grayscale);
+		variants.set(grayscale, objectNumber);
 		return objectNumber;
 	}
 	function headerFooterImagePositions(content, kind) {
@@ -36536,6 +37138,97 @@ this.Documonster = this.Documonster || {};
 		return result;
 	}
 	/**
+	* Parse an Excel "Columns to repeat at left" reference (`printTitlesColumn`)
+	* into an absolute column band, e.g. `"A:B"` → `{ first: 1, last: 2 }`.
+	*
+	* Returns `null` for anything that is not a column range.
+	*/
+	function parseTitlesColumnBand(ref) {
+		const match = ref.replace(/\$/g, "").toUpperCase().match(/^([A-Z]+)(?::([A-Z]+))?$/);
+		if (!match) return null;
+		const first = columnLettersToNumber(match[1]);
+		const last = match[2] ? columnLettersToNumber(match[2]) : first;
+		if (last < first) return null;
+		return {
+			first,
+			last
+		};
+	}
+	/**
+	* Parse an Excel "Rows to repeat at top" reference (`printTitlesRow`) into an
+	* absolute row band, e.g. `"1:3"` → `{ first: 1, last: 3 }`.
+	*/
+	function parseTitlesRowBand(ref) {
+		const match = ref.replace(/\$/g, "").match(/^(\d+)(?::(\d+))?$/);
+		if (!match) return null;
+		const first = parseInt(match[1], 10);
+		const last = match[2] ? parseInt(match[2], 10) : first;
+		if (first < 1 || last < first) return null;
+		return {
+			first,
+			last
+		};
+	}
+	function columnLettersToNumber(letters) {
+		let n = 0;
+		for (let i = 0; i < letters.length; i++) n = n * 26 + (letters.charCodeAt(i) - 64);
+		return n;
+	}
+	function normalizePageOrder(value) {
+		return value === "overThenDown" ? "overThenDown" : "downThenOver";
+	}
+	/** Excel writes `None` / `asDisplayed` / `atEnd`. */
+	function normalizeCommentMode(value) {
+		if (value === "atEnd" || value === "asDisplayed") return value;
+		return "none";
+	}
+	function normalizeErrorMode(value) {
+		switch (value) {
+			case "blank":
+			case "dash":
+			case "NA": return value;
+			default: return "displayed";
+		}
+	}
+	/**
+	* Reconcile documonster's scaling options with Excel's two mutually exclusive
+	* scaling modes (Page Setup → Scaling):
+	*
+	*  - **"Adjust to N %"** — `pageSetup.scale`, with `pageSetup.fitToPage` off.
+	*  - **"Fit to N pages wide by M tall"** — `pageSetup.fitToWidth` /
+	*    `fitToHeight`, with `pageSetup.fitToPage` on. Excel ignores `scale` here.
+	*
+	* Neither mode ever enlarges: Excel caps fit-to-page scaling at 100%.
+	*
+	* `PdfExportOptions.fitToPage` is documonster's own convenience default
+	* ("shrink to one page wide"). It only applies when neither the caller nor the
+	* sheet expresses a scaling intent, so a sheet that asks for 80% is not
+	* shrunk twice.
+	*/
+	function resolveScaling(options, ps) {
+		const clampPages = (n) => n === void 0 || !Number.isFinite(n) || n <= 0 ? 0 : Math.floor(n);
+		const callerFit = options?.fitToWidth !== void 0 || options?.fitToHeight !== void 0;
+		const sheetFitMode = ps?.fitToPage === true;
+		let fitToWidth = 0;
+		let fitToHeight = 0;
+		if (callerFit) {
+			fitToWidth = clampPages(options?.fitToWidth);
+			fitToHeight = clampPages(options?.fitToHeight);
+		} else if (sheetFitMode && options?.scale === void 0 && options?.fitToPage !== false) {
+			fitToWidth = clampPages(ps?.fitToWidth);
+			fitToHeight = clampPages(ps?.fitToHeight);
+		}
+		const sheetScalePercent = !sheetFitMode && ps?.scale !== void 0 && ps.scale !== 100 ? ps.scale / 100 : void 0;
+		const scale = Math.max(.1, Math.min(4, options?.scale ?? sheetScalePercent ?? 1));
+		const hasFitConstraint = fitToWidth > 0 || fitToHeight > 0;
+		return {
+			fitToPage: options?.fitToPage ?? !(hasFitConstraint || sheetScalePercent !== void 0 || callerFit),
+			scale,
+			fitToWidth,
+			fitToHeight
+		};
+	}
+	/**
 	* Resolve user options with defaults.
 	*/
 	function resolveOptions(options, sheet) {
@@ -36544,26 +37237,46 @@ this.Documonster = this.Documonster || {};
 		const chartsheetOrientation = sheet && isPdfChartsheet(sheet) ? sheet.orientation : void 0;
 		const orientation = options?.orientation ?? chartsheetOrientation ?? (ps?.orientation === "landscape" ? "landscape" : "portrait");
 		const margins = resolveMargins(options?.margins, ps?.margins);
-		const gridLineColor = argbToPdfColor(options?.gridLineColor ?? "FFD0D0D0") ?? {
+		const blackAndWhite = options?.blackAndWhite ?? ps?.blackAndWhite ?? false;
+		const gridLineColorRaw = argbToPdfColor(options?.gridLineColor ?? "FFD0D0D0") ?? {
 			r: .816,
 			g: .816,
 			b: .816
 		};
-		let repeatRows = options?.repeatRows ?? false;
-		if (repeatRows === false && sheet && !isPdfChartsheet(sheet) && ps?.printTitlesRow) {
-			const match = ps.printTitlesRow.match(/^(\d+)(?::(\d+))?$/);
-			if (match) repeatRows = parseInt(match[2] ?? match[1], 10);
-		}
+		const gridLineColor = blackAndWhite ? toGrayscale(gridLineColorRaw) : gridLineColorRaw;
+		const isWorksheet = Boolean(sheet) && !isPdfChartsheet(sheet);
+		const countToBand = (n) => typeof n === "number" && n > 0 ? {
+			first: 1,
+			last: n
+		} : false;
+		let repeatRows = false;
+		if (options?.repeatRows !== void 0) repeatRows = countToBand(options.repeatRows);
+		else if (isWorksheet && ps?.printTitlesRow) repeatRows = parseTitlesRowBand(ps.printTitlesRow) ?? false;
+		let repeatCols = false;
+		if (options?.repeatCols !== void 0) repeatCols = countToBand(options.repeatCols);
+		else if (isWorksheet && ps?.printTitlesColumn) repeatCols = parseTitlesColumnBand(ps.printTitlesColumn) ?? false;
+		const { fitToPage, scale, fitToWidth, fitToHeight } = resolveScaling(options, ps);
 		return {
 			pageSize,
 			orientation,
 			margins,
 			ignorePrintArea: options?.ignorePrintArea ?? false,
-			fitToPage: options?.fitToPage !== void 0 ? options.fitToPage : true,
-			scale: Math.max(.1, Math.min(3, options?.scale ?? ((options?.fitToPage !== void 0 ? options.fitToPage : true) ? 1 : ps?.scale ? ps.scale / 100 : 1))),
+			fitToPage,
+			scale,
+			fitToWidth,
+			fitToHeight,
 			showGridLines: options?.showGridLines ?? ps?.showGridLines ?? false,
 			gridLineColor,
+			showRowColHeaders: options?.showRowColHeaders ?? ps?.showRowColHeaders ?? false,
+			horizontalCentered: options?.horizontalCentered ?? ps?.horizontalCentered ?? false,
+			verticalCentered: options?.verticalCentered ?? ps?.verticalCentered ?? false,
+			pageOrder: options?.pageOrder ?? normalizePageOrder(ps?.pageOrder),
+			blackAndWhite,
+			draft: options?.draft ?? ps?.draft ?? false,
+			errors: options?.errors ?? normalizeErrorMode(ps?.errors),
+			cellComments: options?.cellComments ?? normalizeCommentMode(ps?.cellComments),
 			repeatRows,
+			repeatCols,
 			defaultFontFamily: options?.defaultFontFamily ?? "Helvetica",
 			defaultFontSize: options?.defaultFontSize ?? 11,
 			showSheetNames: options?.showSheetNames ?? false,
@@ -45944,6 +46657,9 @@ this.Documonster = this.Documonster || {};
 	function cellHyperlink(c) {
 		return c._value.hyperlink;
 	}
+	function cellComment(c) {
+		return c._comment;
+	}
 	function cellText(c) {
 		return c._value.toString();
 	}
@@ -63776,7 +64492,7 @@ this.Documonster = this.Documonster || {};
 	*/
 	async function excelToPdf(workbook, options) {
 		options?.recalculate?.(workbook);
-		return exportPdf(await excelWorkbookToPdf(workbook), options);
+		return exportPdf(await excelWorkbookToPdf(workbook, options), options);
 	}
 	/**
 	* Render a single {@link Chart} to a standalone one-page PDF.
@@ -63879,9 +64595,9 @@ this.Documonster = this.Documonster || {};
 	* Chartsheets without an orderNo fall to the end, mirroring how Excel
 	* treats sheets with missing tab positions.
 	*/
-	async function excelWorkbookToPdf(workbook) {
-		const worksheetResults = await Promise.all(getWorksheets(workbook).map((ws) => convertSheet(ws, workbook)));
-		const chartsheetResults = await Promise.all(getChartsheets(workbook).map((cs) => convertChartsheet(cs, workbook)));
+	async function excelWorkbookToPdf(workbook, options) {
+		const worksheetResults = await Promise.all(getWorksheets(workbook).map((ws) => convertSheet(ws, workbook, options)));
+		const chartsheetResults = await Promise.all(getChartsheets(workbook).map((cs) => convertChartsheet(cs, workbook, options)));
 		const combined = [...worksheetResults, ...chartsheetResults];
 		combined.sort((a, b) => (a.orderNo ?? Number.POSITIVE_INFINITY) - (b.orderNo ?? Number.POSITIVE_INFINITY));
 		return {
@@ -63894,7 +64610,7 @@ this.Documonster = this.Documonster || {};
 			sheets: combined
 		};
 	}
-	async function convertSheet(ws, workbook) {
+	async function convertSheet(ws, workbook, options) {
 		const dimensions = getSheetDimensions(ws);
 		const hasData = dimensions && dimensions.top > 0 && dimensions.left > 0;
 		const bounds = hasData ? {
@@ -63971,16 +64687,30 @@ this.Documonster = this.Documonster || {};
 				footer: ps.margins.footer
 			} : void 0,
 			scale: ps.scale,
+			fitToPage: ps.fitToPage,
+			fitToWidth: ps.fitToWidth,
+			fitToHeight: ps.fitToHeight,
 			printTitlesRow: ps.printTitlesRow,
+			printTitlesColumn: ps.printTitlesColumn,
 			showGridLines: ps.showGridLines,
+			showRowColHeaders: ps.showRowColHeaders,
 			printArea: ps.printArea,
-			firstPageNumber: ps.useFirstPageNumber === false ? void 0 : ps.firstPageNumber
+			firstPageNumber: ps.useFirstPageNumber === false ? void 0 : ps.firstPageNumber,
+			pageOrder: ps.pageOrder,
+			blackAndWhite: ps.blackAndWhite,
+			draft: ps.draft,
+			errors: ps.errors,
+			cellComments: ps.cellComments,
+			horizontalCentered: ps.horizontalCentered,
+			verticalCentered: ps.verticalCentered
 		} : void 0;
 		const rowBreaks = ws.rowBreaks?.map((b) => b.id);
 		const colBreaks = ws.colBreaks?.map((b) => b.id);
-		const images = collectImages(ws, workbook);
-		const charts = await collectCharts(ws);
-		const sparklineCharts = collectSparklineCharts(ws);
+		const comments = collectComments(ws);
+		const draftQuality = options?.draft ?? ws.pageSetup?.draft ?? false;
+		const images = draftQuality ? void 0 : collectImages(ws, workbook);
+		const charts = draftQuality ? void 0 : await collectCharts(ws);
+		const sparklineCharts = draftQuality ? void 0 : collectSparklineCharts(ws);
 		const allCharts = charts ? sparklineCharts ? [...charts, ...sparklineCharts] : charts : sparklineCharts || void 0;
 		const anchoredRanges = [];
 		if (images) for (const img of images) anchoredRanges.push(img.range);
@@ -64023,14 +64753,74 @@ this.Documonster = this.Documonster || {};
 			rows,
 			merges,
 			pageSetup,
-			headerFooter: convertHeaderFooter(ws, workbook),
+			headerFooter: convertHeaderFooter(ws, workbook, draftQuality),
 			rowBreaks,
 			colBreaks,
 			images,
-			charts: allCharts
+			charts: allCharts,
+			comments
 		};
 	}
-	function convertHeaderFooter(ws, workbook) {
+	/**
+	* Collect every comment on a worksheet, in row-major order.
+	*
+	* Two sources are merged: classic notes stored on the cell (`_comment`, the
+	* VML-backed kind) and Office 365 threaded comments held on the sheet. Only the
+	* text and author are needed — the printed form is an end-of-sheet list, not a
+	* positioned box — so the VML geometry is deliberately ignored.
+	*/
+	function collectComments(ws) {
+		const collected = [];
+		for (const row of ws._rows ?? []) {
+			if (!row) continue;
+			for (const cell of row.cells ?? []) {
+				if (!cell) continue;
+				const note = cellComment(cell);
+				const text = noteText(note?.note);
+				if (text) collected.push({
+					ref: cell.address,
+					text,
+					author: note?.author,
+					anchor: parseVmlAnchor(note?.note)
+				});
+			}
+		}
+		for (const entry of ws.threadedComments ?? []) {
+			const text = entry.comment.text?.trim();
+			if (text) collected.push({
+				ref: entry.ref,
+				text,
+				author: entry.comment.personId
+			});
+		}
+		return collected.length > 0 ? collected : void 0;
+	}
+	/**
+	* Decode a VML comment anchor into fractional sheet coordinates.
+	*
+	* `<x:Anchor>` holds eight integers: for each edge a column/row index followed
+	* by an offset into it, measured in 1/68 of a column and 1/18 of a row (the
+	* reciprocals Excel uses when it writes the value). Returns `undefined` when the
+	* note has no anchor, so callers fall back to Excel's default placement.
+	*/
+	function parseVmlAnchor(note) {
+		if (!note || typeof note === "string" || typeof note.anchor !== "string") return;
+		const parts = note.anchor.split(",").map((p) => Number(p.trim()));
+		if (parts.length !== 8 || parts.some((n) => !Number.isFinite(n))) return;
+		const [l, lf, t, tf, r, rf, b, bf] = parts;
+		return {
+			left: l + lf / 68,
+			top: t + tf / 18,
+			right: r + rf / 68,
+			bottom: b + bf / 18
+		};
+	}
+	/** Flatten a note body, which may be plain text or a rich `NoteConfig`. */
+	function noteText(note) {
+		if (typeof note === "string") return note.trim() || void 0;
+		if (note && typeof note === "object" && Array.isArray(note.texts)) return note.texts.map((t) => typeof t === "string" ? t : t.text ?? "").join("").trim() || void 0;
+	}
+	function convertHeaderFooter(ws, workbook, draftQuality = false) {
 		const source = ws.headerFooter;
 		const fields = [
 			source.oddHeader,
@@ -64040,7 +64830,7 @@ this.Documonster = this.Documonster || {};
 			source.firstHeader,
 			source.firstFooter
 		];
-		const images = convertHeaderFooterImages(ws, workbook);
+		const images = draftQuality ? [] : convertHeaderFooterImages(ws, workbook);
 		if (!fields.some(Boolean) && images.length === 0) return;
 		return {
 			differentFirst: source.differentFirst,
@@ -64797,11 +65587,12 @@ this.Documonster = this.Documonster || {};
 	*   (matches what Excel prints for a chartsheet whose chart was deleted
 	*   but the sheet kept).
 	*/
-	async function convertChartsheet(cs, workbook) {
+	async function convertChartsheet(cs, workbook, options) {
 		const classicModel = chartsheetChartModel(cs);
 		const chartExModel = chartsheetChartExModel(cs);
+		const draftQuality = options?.draft ?? chartsheetPageSetup(cs)?.draft ?? false;
 		let chart = {};
-		if (classicModel) {
+		if (!draftQuality && classicModel) {
 			const model = classicModel;
 			chart = { drawVector: (surface, rect) => {
 				drawChartPdf(surface, model, {
@@ -64811,7 +65602,7 @@ this.Documonster = this.Documonster || {};
 					height: rect.height
 				});
 			} };
-		} else if (chartExModel) {
+		} else if (!draftQuality && chartExModel) {
 			if (canRenderChartExAsVectorPdf(chartExModel)) {
 				const model = chartExModel;
 				chart = { drawVector: (surface, rect) => {
@@ -64839,6 +65630,8 @@ this.Documonster = this.Documonster || {};
 			orientation: ps?.orientation,
 			paperSize: ps?.paperSize,
 			showGridLines: false,
+			blackAndWhite: ps?.blackAndWhite,
+			draft: ps?.draft,
 			firstPageNumber: ps?.useFirstPageNumber === false ? void 0 : ps?.firstPageNumber,
 			margins: margins ? {
 				left: margins.left ?? margins.l ?? .7,
@@ -64857,7 +65650,7 @@ this.Documonster = this.Documonster || {};
 			orientation,
 			chart,
 			pageSetup,
-			headerFooter: convertHeaderFooterModel(chartsheetModel(cs).headerFooter, convertChartsheetHeaderImages(chartsheetModel(cs).headerImages, workbook))
+			headerFooter: convertHeaderFooterModel(chartsheetModel(cs).headerFooter, draftQuality ? [] : convertChartsheetHeaderImages(chartsheetModel(cs).headerImages, workbook))
 		};
 	}
 	function convertChartsheetHeaderImages(images, workbook) {