@cj-tech-master/excelts 9.0.0 → 9.1.0

package/dist/iife/excelts.iife.js

@@ -1,5 +1,5 @@
 /*!
-* @cj-tech-master/excelts v9.0.0
+* @cj-tech-master/excelts v9.1.0
 * Zero-dependency TypeScript toolkit — Excel (XLSX), PDF, CSV, Markdown, XML, ZIP/TAR, and streaming.
 * (c) 2026 cjnoname
 * Released under the MIT License
@@ -2590,6 +2590,18 @@ var ExcelTS = (function(exports) {
 					type: this.type,
 					imageId: this.imageId ?? ""
 				};
+				case "watermark": return {
+					type: this.type,
+					imageId: this.imageId ?? "",
+					opacity: this.opacity
+				};
+				case "headerImage": return {
+					type: this.type,
+					imageId: this.imageId ?? "",
+					headerWidth: this.headerWidth,
+					headerHeight: this.headerHeight,
+					applyTo: this.applyTo
+				};
 				case "image": {
 					const range = this.range;
 					if (!range) throw new ImageError("Image has no range");
@@ -2608,9 +2620,13 @@ var ExcelTS = (function(exports) {
 				default: throw new ImageError("Invalid Image Type");
 			}
 		}
-		set model({ type, imageId, range, hyperlinks }) {
+		set model({ type, imageId, range, hyperlinks, opacity, headerWidth, headerHeight, applyTo }) {
 			this.type = type;
 			this.imageId = imageId;
+			this.opacity = opacity;
+			this.headerWidth = headerWidth;
+			this.headerHeight = headerHeight;
+			this.applyTo = applyTo;
 			if (type === "image") {
 				if (typeof range === "string") {
 					const decoded = colCache.decode(range);
@@ -2639,6 +2655,10 @@ var ExcelTS = (function(exports) {
 			const cloned = new Image(target);
 			cloned.type = this.type;
 			cloned.imageId = this.imageId;
+			cloned.opacity = this.opacity;
+			cloned.headerWidth = this.headerWidth;
+			cloned.headerHeight = this.headerHeight;
+			cloned.applyTo = this.applyTo;
 			if (this.range) cloned.range = {
 				tl: this.range.tl.clone(target),
 				br: this.range.br ? this.range.br.clone(target) : void 0,
@@ -9693,6 +9713,7 @@ var ExcelTS = (function(exports) {
 			this.pivotTables = [];
 			this.conditionalFormattings = [];
 			this.formControls = [];
+			this._watermark = null;
 		}
 		get name() {
 			return this._name;
@@ -10276,6 +10297,73 @@ var ExcelTS = (function(exports) {
 			return image && image.imageId;
 		}
 		/**
+		* Add a watermark to the worksheet using an image from `workbook.addImage()`.
+		*
+		* The watermark can be placed in one of two modes:
+		*
+		* - **overlay** (default): Places the watermark image as a drawing on top of cells.
+		*   Visible on screen AND when printed. Supports transparency via DrawingML `alphaModFix`.
+		*
+		* - **header**: Places the watermark image in the page header using VML.
+		*   Visible in Page Layout view and when printed. Renders behind cell content.
+		*   Transparency must be baked into the image (PNG with alpha channel).
+		*
+		* @param options - Watermark configuration
+		*
+		* @example Overlay watermark with transparency:
+		* ```typescript
+		* const imgId = workbook.addImage({ buffer: pngData, extension: "png" });
+		* worksheet.addWatermark({ imageId: imgId, opacity: 0.15 });
+		* ```
+		*
+		* @example Header watermark (behind content):
+		* ```typescript
+		* const imgId = workbook.addImage({ buffer: pngData, extension: "png" });
+		* worksheet.addWatermark({ imageId: imgId, mode: "header" });
+		* ```
+		*/
+		addWatermark(options) {
+			this._media = this._media.filter((m) => m.type !== "watermark" && m.type !== "headerImage");
+			this._watermark = {
+				imageId: String(options.imageId),
+				mode: options.mode ?? "overlay",
+				opacity: options.opacity,
+				headerWidth: options.headerWidth,
+				headerHeight: options.headerHeight,
+				applyTo: options.applyTo
+			};
+			if (this._watermark.mode === "overlay") {
+				const model = {
+					type: "watermark",
+					imageId: String(options.imageId),
+					opacity: options.opacity
+				};
+				this._media.push(new Image(this, model));
+			} else {
+				const model = {
+					type: "headerImage",
+					imageId: String(options.imageId),
+					headerWidth: options.headerWidth,
+					headerHeight: options.headerHeight,
+					applyTo: options.applyTo
+				};
+				this._media.push(new Image(this, model));
+			}
+		}
+		/**
+		* Get the current watermark configuration, or null if none is set.
+		*/
+		getWatermark() {
+			return this._watermark;
+		}
+		/**
+		* Remove the watermark from the worksheet.
+		*/
+		removeWatermark() {
+			this._watermark = null;
+			this._media = this._media.filter((m) => m.type !== "watermark" && m.type !== "headerImage");
+		}
+		/**
 		* Add a form control checkbox to the worksheet.
 		*
 		* Form control checkboxes are the legacy style that work in Office 2007+,
@@ -10511,6 +10599,7 @@ var ExcelTS = (function(exports) {
 				pivotTables: this.pivotTables,
 				conditionalFormattings: this.conditionalFormattings,
 				formControls: this.formControls.map((fc) => fc.model),
+				watermark: this._watermark,
 				drawing: this._drawing
 			};
 			model.cols = Column.toModel(this.columns);
@@ -10554,6 +10643,25 @@ var ExcelTS = (function(exports) {
 			this.views = value.views;
 			this.autoFilter = value.autoFilter;
 			this._media = value.media.map((medium) => new Image(this, medium));
+			this._watermark = value.watermark ?? null;
+			if (!this._watermark) {
+				for (const medium of this._media) if (medium.type === "watermark") {
+					this._watermark = {
+						imageId: medium.imageId ?? "",
+						mode: "overlay",
+						opacity: medium.opacity
+					};
+					break;
+				} else if (medium.type === "headerImage") {
+					this._watermark = {
+						imageId: medium.imageId ?? "",
+						mode: "header",
+						headerWidth: medium.headerWidth,
+						headerHeight: medium.headerHeight
+					};
+					break;
+				}
+			}
 			this.sheetProtection = value.sheetProtection;
 			this.tables = value.tables.reduce((tables, table) => {
 				const t = new Table(this, table);
@@ -15419,6 +15527,7 @@ var ExcelTS = (function(exports) {
 	const drawingXmlRegex = /^xl\/drawings\/(drawing\d+)[.]xml$/;
 	const drawingRelsXmlRegex = /^xl\/drawings\/_rels\/(drawing\d+)[.]xml[.]rels$/;
 	const vmlDrawingRegex = /^xl\/drawings\/(vmlDrawing\d+)[.]vml$/;
+	const vmlDrawingHFRegex = /^xl\/drawings\/(vmlDrawingHF\d+)[.]vml$/;
 	const commentsXmlRegex = /^xl\/comments(\d+)[.]xml$/;
 	const tableXmlRegex = /^xl\/tables\/(table\d+)[.]xml$/;
 	const pivotTableXmlRegex = /^xl\/pivotTables\/(pivotTable\d+)[.]xml$/;
@@ -15468,6 +15577,10 @@ var ExcelTS = (function(exports) {
 		const match = vmlDrawingRegex.exec(path);
 		return match ? match[1] : void 0;
 	}
+	function getVmlDrawingHFNameFromPath(path) {
+		const match = vmlDrawingHFRegex.exec(path);
+		return match ? match[1] : void 0;
+	}
 	function getCommentsIndexFromPath(path) {
 		const match = commentsXmlRegex.exec(path);
 		return match ? match[1] : void 0;
@@ -15523,6 +15636,12 @@ var ExcelTS = (function(exports) {
 	function vmlDrawingPath(sheetId) {
 		return `xl/drawings/vmlDrawing${sheetId}.vml`;
 	}
+	function vmlDrawingHFPath(sheetId) {
+		return `xl/drawings/vmlDrawingHF${sheetId}.vml`;
+	}
+	function vmlDrawingHFRelsPath(sheetId) {
+		return `xl/drawings/_rels/vmlDrawingHF${sheetId}.vml.rels`;
+	}
 	function tablePath(target) {
 		return `xl/tables/${target}`;
 	}
@@ -15568,6 +15687,9 @@ var ExcelTS = (function(exports) {
 	function vmlDrawingRelTargetFromWorksheet(sheetId) {
 		return `../drawings/vmlDrawing${sheetId}.vml`;
 	}
+	function vmlDrawingHFRelTargetFromWorksheet(sheetId) {
+		return `../drawings/vmlDrawingHF${sheetId}.vml`;
+	}
 	function drawingRelTargetFromWorksheet(drawingName) {
 		return `../drawings/${drawingName}.xml`;
 	}
@@ -15687,7 +15809,8 @@ var ExcelTS = (function(exports) {
 			});
 			const hasComments = model.commentRefs && model.commentRefs.length > 0;
 			const hasFormControls = model.formControlRefs && model.formControlRefs.length > 0;
-			if (hasComments || hasFormControls) xmlStream.leafNode("Default", {
+			const hasHeaderWatermark = model.hasHeaderWatermark === true;
+			if (hasComments || hasFormControls || hasHeaderWatermark) xmlStream.leafNode("Default", {
 				Extension: "vml",
 				ContentType: "application/vnd.openxmlformats-officedocument.vmlDrawing"
 			});
@@ -19025,6 +19148,10 @@ var ExcelTS = (function(exports) {
 				picture: { rId: rIdImage },
 				range: medium.range
 			};
+			if (medium.opacity !== void 0) {
+				const clamped = Math.max(0, Math.min(1, medium.opacity));
+				anchor.picture.alphaModFix = Math.round(clamped * 1e5);
+			}
 			if (medium.hyperlinks && medium.hyperlinks.hyperlink) {
 				const rIdHyperlink = options.nextRId(rels);
 				anchor.picture.hyperlinks = {
@@ -19225,9 +19352,13 @@ var ExcelTS = (function(exports) {
 			}
 			const backgroundMedia = [];
 			const imageMedia = [];
+			const watermarkMedia = [];
+			const headerImageMedia = [];
 			model.media.forEach((medium) => {
 				if (medium.type === "background") backgroundMedia.push(medium);
 				else if (medium.type === "image") imageMedia.push(medium);
+				else if (medium.type === "watermark") watermarkMedia.push(medium);
+				else if (medium.type === "headerImage") headerImageMedia.push(medium);
 			});
 			backgroundMedia.forEach((medium) => {
 				const rId = nextRid(rels);
@@ -19263,6 +19394,96 @@ var ExcelTS = (function(exports) {
 				drawing.anchors.push(...result.anchors);
 				drawing.rels = result.rels;
 			}
+			if (watermarkMedia.length > 0) {
+				let { drawing } = model;
+				if (!drawing) {
+					drawing = model.drawing = {
+						rId: nextRid(rels),
+						name: `drawing${++options.drawingsCount}`,
+						anchors: [],
+						rels: []
+					};
+					options.drawings.push(drawing);
+					rels.push({
+						Id: drawing.rId,
+						Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
+						Target: drawingRelTargetFromWorksheet(drawing.name)
+					});
+				}
+				for (const medium of watermarkMedia) {
+					const bookImage = options.media[medium.imageId];
+					if (!bookImage) continue;
+					const rIdImage = nextRid(drawing.rels);
+					drawing.rels.push({
+						Id: rIdImage,
+						Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+						Target: resolveMediaTarget(bookImage)
+					});
+					const rawOpacity = medium.opacity !== void 0 ? medium.opacity : .15;
+					const alphaModFix = Math.round(Math.max(0, Math.min(1, rawOpacity)) * 1e5);
+					const dims = model.dimensions;
+					const maxCol = dims ? Math.max(dims.model?.right ?? 100, 100) : 100;
+					const maxRow = dims ? Math.max(dims.model?.bottom ?? 200, 200) : 200;
+					drawing.anchors.push({
+						picture: {
+							rId: rIdImage,
+							alphaModFix
+						},
+						range: {
+							editAs: "absolute",
+							tl: {
+								nativeCol: 0,
+								nativeColOff: 0,
+								nativeRow: 0,
+								nativeRowOff: 0
+							},
+							br: {
+								nativeCol: maxCol,
+								nativeColOff: 0,
+								nativeRow: maxRow,
+								nativeRowOff: 0
+							}
+						}
+					});
+				}
+			}
+			if (headerImageMedia.length > 0) {
+				const medium = headerImageMedia[0];
+				const bookImage = options.media[medium.imageId];
+				if (bookImage) {
+					const rIdVml = nextRid(rels);
+					rels.push({
+						Id: rIdVml,
+						Type: RelType.VmlDrawing,
+						Target: vmlDrawingHFRelTargetFromWorksheet(fileIndex)
+					});
+					model.headerImage = {
+						vmlRelId: rIdVml,
+						imageId: medium.imageId,
+						bookImage,
+						headerWidth: medium.headerWidth,
+						headerHeight: medium.headerHeight
+					};
+					options.hasHeaderWatermark = true;
+					if (!model.headerFooter) model.headerFooter = {};
+					const applyTo = medium.applyTo || "all";
+					const insertG = (field) => {
+						const existing = model.headerFooter[field] || "";
+						if (existing.includes("&G")) return existing;
+						if (existing.includes("&C")) return existing.replace("&C", "&C&G");
+						return existing + "&C&G";
+					};
+					if (applyTo === "all" || applyTo === "odd") model.headerFooter.oddHeader = insertG("oddHeader");
+					if (applyTo === "all" || applyTo === "even") {
+						model.headerFooter.evenHeader = insertG("evenHeader");
+						model.headerFooter.differentOddEven = true;
+					}
+					if (applyTo === "all" || applyTo === "first") {
+						model.headerFooter.firstHeader = insertG("firstHeader");
+						model.headerFooter.differentFirst = true;
+					}
+				}
+			}
 			model.tables.forEach((table) => {
 				const rId = nextRid(rels);
 				table.rId = rId;
@@ -19392,8 +19613,12 @@ var ExcelTS = (function(exports) {
 			this.map.drawing.render(xmlStream, model.drawing);
 			this.map.picture.render(xmlStream, model.background);
 			if (model.rels) model.rels.forEach((rel) => {
-				if (rel.Type === RelType.VmlDrawing) xmlStream.leafNode("legacyDrawing", { "r:id": rel.Id });
+				if (rel.Type === RelType.VmlDrawing) {
+					if (model.headerImage && rel.Id === model.headerImage.vmlRelId) return;
+					xmlStream.leafNode("legacyDrawing", { "r:id": rel.Id });
+				}
 			});
+			if (model.headerImage) xmlStream.leafNode("legacyDrawingHF", { "r:id": model.headerImage.vmlRelId });
 			if (model.formControls && model.formControls.length > 0) {
 				xmlStream.openNode("mc:AlternateContent");
 				xmlStream.openNode("mc:Choice", { Requires: "x14" });
@@ -19561,15 +19786,17 @@ var ExcelTS = (function(exports) {
 								rels: options.drawingRels?.[drawingName] ?? drawing.rels ?? []
 							};
 							drawing.anchors.forEach((anchor) => {
-								if (anchor.medium) {
-									const image = {
-										type: "image",
-										imageId: anchor.medium.index,
-										range: anchor.range,
-										hyperlinks: anchor.picture.hyperlinks
-									};
-									model.media.push(image);
-								}
+								if (anchor.medium) if (anchor.medium.alphaModFix !== void 0 && anchor.medium.alphaModFix < 1e5) model.media.push({
+									type: "watermark",
+									imageId: anchor.medium.index,
+									opacity: anchor.medium.alphaModFix / 1e5
+								});
+								else model.media.push({
+									type: "image",
+									imageId: anchor.medium.index,
+									range: anchor.range,
+									hyperlinks: anchor.picture.hyperlinks
+								});
 							});
 						} else model.drawing = void 0;
 					} else model.drawing = void 0;
@@ -19668,7 +19895,12 @@ var ExcelTS = (function(exports) {
 				if (match) {
 					const name = match[1];
 					const mediaId = options.mediaIndex[name];
-					return options.media[mediaId];
+					const medium = options.media[mediaId];
+					if (medium && model.alphaModFix !== void 0) return {
+						...medium,
+						alphaModFix: model.alphaModFix
+					};
+					return medium;
 				}
 			}
 		}
@@ -19760,7 +19992,15 @@ var ExcelTS = (function(exports) {
 			return "a:blip";
 		}
 		render(xmlStream, model) {
-			xmlStream.leafNode(this.tag, {
+			if (model.alphaModFix !== void 0 && model.alphaModFix < 1e5) {
+				xmlStream.openNode(this.tag, {
+					"xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+					"r:embed": model.rId,
+					cstate: "print"
+				});
+				xmlStream.leafNode("a:alphaModFix", { amt: String(model.alphaModFix) });
+				xmlStream.closeNode();
+			} else xmlStream.leafNode(this.tag, {
 				"xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
 				"r:embed": model.rId,
 				cstate: "print"
@@ -19771,6 +20011,9 @@ var ExcelTS = (function(exports) {
 				case this.tag:
 					this.model = { rId: node.attributes["r:embed"] };
 					return true;
+				case "a:alphaModFix":
+					if (node.attributes.amt) this.model.alphaModFix = parseInt(node.attributes.amt, 10);
+					return true;
 				default: return true;
 			}
 		}
@@ -20065,7 +20308,10 @@ var ExcelTS = (function(exports) {
 		render(xmlStream, model) {
 			xmlStream.openNode(this.tag);
 			this.map["xdr:nvPicPr"].render(xmlStream, model);
-			this.map["xdr:blipFill"].render(xmlStream, model);
+			this.map["xdr:blipFill"].render(xmlStream, {
+				rId: model.rId,
+				alphaModFix: model.alphaModFix
+			});
 			this.map["xdr:spPr"].render(xmlStream, model);
 			xmlStream.closeNode();
 		}
@@ -22980,6 +23226,7 @@ var ExcelTS = (function(exports) {
 	var VmlDrawingXform = class VmlDrawingXform extends BaseXform {
 		constructor() {
 			super();
+			this._parsingHeaderImage = false;
 			this.map = { "v:shape": new VmlShapeXform() };
 			this.model = {
 				comments: [],
@@ -22996,8 +23243,10 @@ var ExcelTS = (function(exports) {
 			const renderModel = model || this.model;
 			const comments = renderModel.comments;
 			const formControls = renderModel.formControls;
+			const headerImage = renderModel.headerImage;
 			const hasComments = comments && comments.length > 0;
 			const hasFormControls = formControls && formControls.length > 0;
+			const hasHeaderImage = !!headerImage;
 			xmlStream.openXml(StdDocAttributes);
 			xmlStream.openNode(this.tag, VmlDrawingXform.DRAWING_ATTRIBUTES);
 			xmlStream.openNode("o:shapelayout", { "v:ext": "edit" });
@@ -23041,8 +23290,67 @@ var ExcelTS = (function(exports) {
 				});
 				xmlStream.closeNode();
 			}
+			if (hasHeaderImage) {
+				xmlStream.openNode("v:shapetype", {
+					id: "_x0000_t75",
+					coordsize: "21600,21600",
+					"o:spt": "75",
+					"o:preferrelative": "t",
+					path: "m@4@5l@4@11@9@11@9@5xe",
+					filled: "f",
+					stroked: "f"
+				});
+				xmlStream.leafNode("v:stroke", { joinstyle: "miter" });
+				xmlStream.openNode("v:formulas");
+				xmlStream.leafNode("v:f", { eqn: "if lineDrawn pixelLineWidth 0" });
+				xmlStream.leafNode("v:f", { eqn: "sum @0 1 0" });
+				xmlStream.leafNode("v:f", { eqn: "sum 0 0 @1" });
+				xmlStream.leafNode("v:f", { eqn: "prod @2 1 2" });
+				xmlStream.leafNode("v:f", { eqn: "prod @3 21600 pixelWidth" });
+				xmlStream.leafNode("v:f", { eqn: "prod @3 21600 pixelHeight" });
+				xmlStream.leafNode("v:f", { eqn: "sum @0 0 1" });
+				xmlStream.leafNode("v:f", { eqn: "prod @6 1 2" });
+				xmlStream.leafNode("v:f", { eqn: "prod @7 21600 pixelWidth" });
+				xmlStream.leafNode("v:f", { eqn: "sum @8 21600 0" });
+				xmlStream.leafNode("v:f", { eqn: "prod @7 21600 pixelHeight" });
+				xmlStream.leafNode("v:f", { eqn: "sum @10 21600 0" });
+				xmlStream.closeNode();
+				xmlStream.leafNode("v:path", {
+					"o:extrusionok": "f",
+					gradientshapeok: "t",
+					"o:connecttype": "rect"
+				});
+				xmlStream.leafNode("o:lock", {
+					"v:ext": "edit",
+					aspectratio: "t"
+				});
+				xmlStream.closeNode();
+			}
 			if (hasComments) for (let i = 0; i < comments.length; i++) this.map["v:shape"].render(xmlStream, comments[i], i);
 			if (hasFormControls) for (const control of formControls) this._renderCheckboxShape(xmlStream, control);
+			if (hasHeaderImage) this._renderHeaderImageShape(xmlStream, headerImage);
+			xmlStream.closeNode();
+		}
+		/**
+		* Render a header/footer image shape for watermark
+		*/
+		_renderHeaderImageShape(xmlStream, headerImage) {
+			const width = headerImage.width ?? 467.25;
+			const height = headerImage.height ?? 311.25;
+			xmlStream.openNode("v:shape", {
+				id: "CH",
+				"o:spid": "_x0000_s2049",
+				type: "#_x0000_t75",
+				style: `position:absolute;margin-left:0;margin-top:0;width:${width}pt;height:${height}pt;z-index:1`
+			});
+			xmlStream.leafNode("v:imagedata", {
+				"o:relid": headerImage.imageRelId,
+				"o:title": "watermark"
+			});
+			xmlStream.leafNode("o:lock", {
+				"v:ext": "edit",
+				rotation: "t"
+			});
 			xmlStream.closeNode();
 		}
 		/**
@@ -23116,9 +23424,25 @@ var ExcelTS = (function(exports) {
 						formControls: []
 					};
 					break;
+				case "v:shape":
+					if (node.attributes.type === "#_x0000_t75") {
+						this._parsingHeaderImage = true;
+						const style = node.attributes.style || "";
+						const widthMatch = /width:([0-9.]+)pt/.exec(style);
+						const heightMatch = /height:([0-9.]+)pt/.exec(style);
+						this._headerImageWidth = widthMatch ? parseFloat(widthMatch[1]) : void 0;
+						this._headerImageHeight = heightMatch ? parseFloat(heightMatch[1]) : void 0;
+					} else {
+						this.parser = this.map[node.name];
+						if (this.parser) this.parser.parseOpen(node);
+					}
+					break;
 				default:
-					this.parser = this.map[node.name];
-					if (this.parser) this.parser.parseOpen(node);
+					if (this._parsingHeaderImage && node.name === "v:imagedata") this._headerImageRelId = node.attributes["o:relid"];
+					else {
+						this.parser = this.map[node.name];
+						if (this.parser) this.parser.parseOpen(node);
+					}
 					break;
 			}
 			return true;
@@ -23135,6 +23459,17 @@ var ExcelTS = (function(exports) {
 				return true;
 			}
 			switch (name) {
+				case "v:shape":
+					if (this._parsingHeaderImage && this._headerImageRelId) this.model.headerImage = {
+						imageRelId: this._headerImageRelId,
+						width: this._headerImageWidth,
+						height: this._headerImageHeight
+					};
+					this._parsingHeaderImage = false;
+					this._headerImageRelId = void 0;
+					this._headerImageWidth = void 0;
+					this._headerImageHeight = void 0;
+					return true;
 				case this.tag: return false;
 				default: return true;
 			}
@@ -25658,7 +25993,7 @@ var ExcelTS = (function(exports) {
 	* @param data - Input data
 	* @returns 32-bit Adler-32 checksum
 	*/
-	function adler32(data) {
+	function adler32$1(data) {
 		let a = 1;
 		let b = 0;
 		const chunkSize = 5552;
@@ -27200,7 +27535,7 @@ self.onmessage = async function(event) {
 		return concatUint8Arrays([
 			getZlibHeader(level),
 			deflated,
-			buildZlibTrailer(adler32(original))
+			buildZlibTrailer(adler32$1(original))
 		]);
 	}
 	/**
@@ -35661,6 +35996,13 @@ self.onmessage = async function(event) {
 			const vmlDrawing = await new VmlDrawingXform().parseStream(entry);
 			model.vmlDrawings[vmlDrawingRelTargetFromWorksheetName(name)] = vmlDrawing;
 		}
+		async _processVmlDrawingHFEntry(entry, model, _name) {
+			const vmlDrawing = await new VmlDrawingXform().parseStream(entry);
+			if (vmlDrawing && vmlDrawing.headerImage) {
+				if (!model.vmlDrawingHF) model.vmlDrawingHF = {};
+				model.vmlDrawingHF[_name] = vmlDrawing.headerImage;
+			}
+		}
 		async _processThemeEntry(stream, model, name) {
 			await new Promise((resolve, reject) => {
 				const streamBuf = this.createStreamBuf();
@@ -35747,6 +36089,11 @@ self.onmessage = async function(event) {
 				await this._processVmlDrawingEntry(stream, model, vmlDrawingName);
 				return true;
 			}
+			const vmlHFName = getVmlDrawingHFNameFromPath(entryName);
+			if (vmlHFName) {
+				await this._processVmlDrawingHFEntry(stream, model, vmlHFName);
+				return true;
+			}
 			const commentsIndex = getCommentsIndexFromPath(entryName);
 			if (commentsIndex) {
 				await this._processCommentEntry(stream, model, `comments${commentsIndex}`);
@@ -35925,6 +36272,25 @@ self.onmessage = async function(event) {
 					comments: hasComments ? worksheet.comments : [],
 					formControls: hasFormControls ? worksheet.formControls : []
 				});
+				if (worksheet.headerImage) {
+					const hdrImage = worksheet.headerImage;
+					const bookImage = hdrImage.bookImage;
+					const imageRelTarget = `../media/${bookImage.name && bookImage.extension && bookImage.name.endsWith(`.${bookImage.extension}`) ? bookImage.name : `${bookImage.name}.${bookImage.extension}`}`;
+					await this._renderToZip(zip, vmlDrawingHFPath(fileIndex), vmlDrawingXform, {
+						comments: [],
+						formControls: [],
+						headerImage: {
+							imageRelId: "rId1",
+							width: hdrImage.headerWidth,
+							height: hdrImage.headerHeight
+						}
+					});
+					await this._renderToZip(zip, vmlDrawingHFRelsPath(fileIndex), relationshipsXform, [{
+						Id: "rId1",
+						Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+						Target: imageRelTarget
+					}]);
+				}
 				if (hasFormControls) for (const control of worksheet.formControls) await this._renderToZip(zip, ctrlPropPath(control.ctrlPropId), ctrlPropXform, control);
 			}
 		}
@@ -36036,6 +36402,7 @@ self.onmessage = async function(event) {
 			worksheetOptions.drawings = model.drawings = [];
 			worksheetOptions.commentRefs = model.commentRefs = [];
 			worksheetOptions.formControlRefs = model.formControlRefs = [];
+			model.hasHeaderWatermark = false;
 			let tableCount = 0;
 			model.tables = [];
 			model.worksheets.forEach((worksheet, index) => {
@@ -36049,6 +36416,7 @@ self.onmessage = async function(event) {
 				worksheetXform.prepare(worksheet, worksheetOptions);
 			});
 			model.hasCheckboxes = model.styles.hasCheckboxes;
+			if (worksheetOptions.hasHeaderWatermark) model.hasHeaderWatermark = true;
 			const passthrough = model.passthrough || {};
 			const passthroughManager = new PassthroughManager();
 			passthroughManager.fromRecord(passthrough);
@@ -36347,6 +36715,7 @@ self.onmessage = async function(event) {
 			this._views = options.views ?? [];
 			this.autoFilter = options.autoFilter ?? null;
 			this._media = [];
+			this._watermark = null;
 			this.sheetProtection = null;
 			this._writeOpenWorksheet();
 			this.startedData = false;
@@ -36550,6 +36919,59 @@ self.onmessage = async function(event) {
 			return this._media;
 		}
 		/**
+		* Add a watermark to the worksheet using an image from `WorkbookWriter.addImage()`.
+		* Supports overlay mode (DrawingML with transparency) and header mode (VML behind content).
+		*/
+		addWatermark(options) {
+			this._media = this._media.filter((m) => m._watermarkTag !== true);
+			const opacity = options.opacity !== void 0 ? Math.max(0, Math.min(1, options.opacity)) : .15;
+			this._watermark = {
+				imageId: String(options.imageId),
+				mode: options.mode ?? "overlay",
+				opacity,
+				headerWidth: options.headerWidth,
+				headerHeight: options.headerHeight,
+				applyTo: options.applyTo
+			};
+			if (this._watermark.mode === "overlay") {
+				const entry = {
+					type: "image",
+					imageId: String(options.imageId),
+					range: {
+						tl: {
+							nativeCol: 0,
+							nativeColOff: 0,
+							nativeRow: 0,
+							nativeRowOff: 0
+						},
+						br: {
+							nativeCol: 100,
+							nativeColOff: 0,
+							nativeRow: 200,
+							nativeRowOff: 0
+						},
+						editAs: "absolute"
+					},
+					_watermarkTag: true,
+					opacity
+				};
+				this._media.push(entry);
+			}
+		}
+		/**
+		* Get the current watermark configuration.
+		*/
+		getWatermark() {
+			return this._watermark;
+		}
+		/**
+		* Remove the watermark from the worksheet.
+		*/
+		removeWatermark() {
+			this._watermark = null;
+			this._media = this._media.filter((m) => m._watermarkTag !== true);
+		}
+		/**
 		* Parse the user-supplied range into a normalised internal model
 		* mirroring what the regular Worksheet / Image class does.
 		*/
@@ -36707,6 +37129,17 @@ self.onmessage = async function(event) {
 		}
 		_writeDrawing() {
 			if (this._media.length === 0) return;
+			for (const entry of this._media) if (entry._watermarkTag) {
+				const dims = this._dimensions.model;
+				const maxCol = dims ? Math.max(dims.right ?? 100, 100) : 100;
+				const maxRow = dims ? Math.max(dims.bottom ?? 200, 200) : 200;
+				entry.range.br = {
+					nativeCol: maxCol,
+					nativeColOff: 0,
+					nativeRow: maxRow,
+					nativeRowOff: 0
+				};
+			}
 			const drawingName = `drawing${this.id}`;
 			const drawingRId = this._sheetRelsWriter.addRelationship({
 				Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
@@ -44520,6 +44953,1198 @@ onmessage = async (ev) => {
 		return PaperSize;
 	}({});
 	//#endregion
+	//#region src/modules/excel/utils/watermark-image.ts
+	/**
+	* Zero-dependency text-to-PNG watermark image generator.
+	*
+	* Renders text into a semi-transparent PNG suitable for use as an Excel watermark.
+	* Uses a built-in bitmap font for ASCII characters — no Canvas or external fonts required.
+	* PNG data is deflate-compressed using the archive module's built-in compressor.
+	*
+	* @example
+	* ```typescript
+	* const png = createTextWatermarkImage("CONFIDENTIAL", {
+	*   fontSize: 48,
+	*   color: { r: 128, g: 128, b: 128 },
+	*   opacity: 40,
+	*   rotation: -45
+	* });
+	* const imgId = workbook.addImage({ buffer: png, extension: "png" });
+	* worksheet.addWatermark({ imageId: imgId });
+	* ```
+	*/
+	/**
+	* Generate a PNG image containing watermark text.
+	*
+	* The image has an alpha channel so the watermark is semi-transparent.
+	* Works in both Node.js and browsers with zero dependencies.
+	*/
+	function createTextWatermarkImage(text, options) {
+		const fontSize = options?.fontSize ?? 48;
+		const color = options?.color ?? {
+			r: 128,
+			g: 128,
+			b: 128
+		};
+		const opacity = Math.max(0, Math.min(100, options?.opacity ?? 40));
+		const rotation = options?.rotation ?? -45;
+		const padding = options?.padding ?? 20;
+		const { width: textW, height: textH, pixels: textPixels } = renderTextBitmap(text, Math.max(1, Math.round(fontSize / GLYPH_HEIGHT)));
+		const paddedW = textW + padding * 2;
+		const paddedH = textH + padding * 2;
+		const paddedPixels = new Uint8Array(paddedW * paddedH);
+		for (let y = 0; y < textH; y++) for (let x = 0; x < textW; x++) paddedPixels[(y + padding) * paddedW + (x + padding)] = textPixels[y * textW + x];
+		const { width: rotW, height: rotH, pixels: rotPixels } = rotateBitmap(paddedPixels, paddedW, paddedH, rotation);
+		const alpha = Math.round(opacity / 100 * 255);
+		const rgba = new Uint8Array(rotW * rotH * 4);
+		for (let i = 0; i < rotW * rotH; i++) {
+			const a = rotPixels[i];
+			if (a > 0) {
+				rgba[i * 4] = color.r;
+				rgba[i * 4 + 1] = color.g;
+				rgba[i * 4 + 2] = color.b;
+				rgba[i * 4 + 3] = Math.round(a / 255 * alpha);
+			}
+		}
+		return encodePng(rgba, rotW, rotH);
+	}
+	const GLYPH_WIDTH = 6;
+	const GLYPH_HEIGHT = 8;
+	/**
+	* Compact glyph data: each character is 8 bytes (one byte per row, 6 bits used).
+	* Bit 5 = leftmost pixel, bit 0 = rightmost pixel.
+	*/
+	const FONT_DATA = {
+		32: [
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		],
+		33: [
+			4,
+			4,
+			4,
+			4,
+			4,
+			0,
+			4,
+			0
+		],
+		34: [
+			10,
+			10,
+			10,
+			0,
+			0,
+			0,
+			0,
+			0
+		],
+		35: [
+			10,
+			10,
+			31,
+			10,
+			31,
+			10,
+			10,
+			0
+		],
+		36: [
+			4,
+			15,
+			20,
+			14,
+			5,
+			30,
+			4,
+			0
+		],
+		37: [
+			24,
+			25,
+			2,
+			4,
+			8,
+			19,
+			3,
+			0
+		],
+		38: [
+			12,
+			18,
+			20,
+			8,
+			21,
+			18,
+			13,
+			0
+		],
+		39: [
+			4,
+			4,
+			8,
+			0,
+			0,
+			0,
+			0,
+			0
+		],
+		40: [
+			2,
+			4,
+			8,
+			8,
+			8,
+			4,
+			2,
+			0
+		],
+		41: [
+			8,
+			4,
+			2,
+			2,
+			2,
+			4,
+			8,
+			0
+		],
+		42: [
+			0,
+			4,
+			21,
+			14,
+			21,
+			4,
+			0,
+			0
+		],
+		43: [
+			0,
+			4,
+			4,
+			31,
+			4,
+			4,
+			0,
+			0
+		],
+		44: [
+			0,
+			0,
+			0,
+			0,
+			0,
+			4,
+			4,
+			8
+		],
+		45: [
+			0,
+			0,
+			0,
+			31,
+			0,
+			0,
+			0,
+			0
+		],
+		46: [
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			4,
+			0
+		],
+		47: [
+			0,
+			1,
+			2,
+			4,
+			8,
+			16,
+			0,
+			0
+		],
+		48: [
+			14,
+			17,
+			19,
+			21,
+			25,
+			17,
+			14,
+			0
+		],
+		49: [
+			4,
+			12,
+			4,
+			4,
+			4,
+			4,
+			14,
+			0
+		],
+		50: [
+			14,
+			17,
+			1,
+			2,
+			4,
+			8,
+			31,
+			0
+		],
+		51: [
+			31,
+			2,
+			4,
+			2,
+			1,
+			17,
+			14,
+			0
+		],
+		52: [
+			2,
+			6,
+			10,
+			18,
+			31,
+			2,
+			2,
+			0
+		],
+		53: [
+			31,
+			16,
+			30,
+			1,
+			1,
+			17,
+			14,
+			0
+		],
+		54: [
+			6,
+			8,
+			16,
+			30,
+			17,
+			17,
+			14,
+			0
+		],
+		55: [
+			31,
+			1,
+			2,
+			4,
+			8,
+			8,
+			8,
+			0
+		],
+		56: [
+			14,
+			17,
+			17,
+			14,
+			17,
+			17,
+			14,
+			0
+		],
+		57: [
+			14,
+			17,
+			17,
+			15,
+			1,
+			2,
+			12,
+			0
+		],
+		58: [
+			0,
+			0,
+			4,
+			0,
+			0,
+			4,
+			0,
+			0
+		],
+		59: [
+			0,
+			0,
+			4,
+			0,
+			0,
+			4,
+			4,
+			8
+		],
+		60: [
+			2,
+			4,
+			8,
+			16,
+			8,
+			4,
+			2,
+			0
+		],
+		61: [
+			0,
+			0,
+			31,
+			0,
+			31,
+			0,
+			0,
+			0
+		],
+		62: [
+			8,
+			4,
+			2,
+			1,
+			2,
+			4,
+			8,
+			0
+		],
+		63: [
+			14,
+			17,
+			1,
+			2,
+			4,
+			0,
+			4,
+			0
+		],
+		64: [
+			14,
+			17,
+			23,
+			21,
+			23,
+			16,
+			14,
+			0
+		],
+		65: [
+			14,
+			17,
+			17,
+			31,
+			17,
+			17,
+			17,
+			0
+		],
+		66: [
+			30,
+			17,
+			17,
+			30,
+			17,
+			17,
+			30,
+			0
+		],
+		67: [
+			14,
+			17,
+			16,
+			16,
+			16,
+			17,
+			14,
+			0
+		],
+		68: [
+			28,
+			18,
+			17,
+			17,
+			17,
+			18,
+			28,
+			0
+		],
+		69: [
+			31,
+			16,
+			16,
+			30,
+			16,
+			16,
+			31,
+			0
+		],
+		70: [
+			31,
+			16,
+			16,
+			30,
+			16,
+			16,
+			16,
+			0
+		],
+		71: [
+			14,
+			17,
+			16,
+			23,
+			17,
+			17,
+			15,
+			0
+		],
+		72: [
+			17,
+			17,
+			17,
+			31,
+			17,
+			17,
+			17,
+			0
+		],
+		73: [
+			14,
+			4,
+			4,
+			4,
+			4,
+			4,
+			14,
+			0
+		],
+		74: [
+			7,
+			2,
+			2,
+			2,
+			2,
+			18,
+			12,
+			0
+		],
+		75: [
+			17,
+			18,
+			20,
+			24,
+			20,
+			18,
+			17,
+			0
+		],
+		76: [
+			16,
+			16,
+			16,
+			16,
+			16,
+			16,
+			31,
+			0
+		],
+		77: [
+			17,
+			27,
+			21,
+			21,
+			17,
+			17,
+			17,
+			0
+		],
+		78: [
+			17,
+			25,
+			21,
+			19,
+			17,
+			17,
+			17,
+			0
+		],
+		79: [
+			14,
+			17,
+			17,
+			17,
+			17,
+			17,
+			14,
+			0
+		],
+		80: [
+			30,
+			17,
+			17,
+			30,
+			16,
+			16,
+			16,
+			0
+		],
+		81: [
+			14,
+			17,
+			17,
+			17,
+			21,
+			18,
+			13,
+			0
+		],
+		82: [
+			30,
+			17,
+			17,
+			30,
+			20,
+			18,
+			17,
+			0
+		],
+		83: [
+			15,
+			16,
+			16,
+			14,
+			1,
+			1,
+			30,
+			0
+		],
+		84: [
+			31,
+			4,
+			4,
+			4,
+			4,
+			4,
+			4,
+			0
+		],
+		85: [
+			17,
+			17,
+			17,
+			17,
+			17,
+			17,
+			14,
+			0
+		],
+		86: [
+			17,
+			17,
+			17,
+			17,
+			17,
+			10,
+			4,
+			0
+		],
+		87: [
+			17,
+			17,
+			17,
+			21,
+			21,
+			27,
+			17,
+			0
+		],
+		88: [
+			17,
+			17,
+			10,
+			4,
+			10,
+			17,
+			17,
+			0
+		],
+		89: [
+			17,
+			17,
+			10,
+			4,
+			4,
+			4,
+			4,
+			0
+		],
+		90: [
+			31,
+			1,
+			2,
+			4,
+			8,
+			16,
+			31,
+			0
+		],
+		91: [
+			14,
+			8,
+			8,
+			8,
+			8,
+			8,
+			14,
+			0
+		],
+		92: [
+			0,
+			16,
+			8,
+			4,
+			2,
+			1,
+			0,
+			0
+		],
+		93: [
+			14,
+			2,
+			2,
+			2,
+			2,
+			2,
+			14,
+			0
+		],
+		94: [
+			4,
+			10,
+			17,
+			0,
+			0,
+			0,
+			0,
+			0
+		],
+		95: [
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			31,
+			0
+		],
+		96: [
+			8,
+			4,
+			2,
+			0,
+			0,
+			0,
+			0,
+			0
+		],
+		97: [
+			0,
+			0,
+			14,
+			1,
+			15,
+			17,
+			15,
+			0
+		],
+		98: [
+			16,
+			16,
+			22,
+			25,
+			17,
+			17,
+			30,
+			0
+		],
+		99: [
+			0,
+			0,
+			14,
+			16,
+			16,
+			17,
+			14,
+			0
+		],
+		100: [
+			1,
+			1,
+			13,
+			19,
+			17,
+			17,
+			15,
+			0
+		],
+		101: [
+			0,
+			0,
+			14,
+			17,
+			31,
+			16,
+			14,
+			0
+		],
+		102: [
+			6,
+			9,
+			8,
+			28,
+			8,
+			8,
+			8,
+			0
+		],
+		103: [
+			0,
+			0,
+			15,
+			17,
+			15,
+			1,
+			14,
+			0
+		],
+		104: [
+			16,
+			16,
+			22,
+			25,
+			17,
+			17,
+			17,
+			0
+		],
+		105: [
+			4,
+			0,
+			12,
+			4,
+			4,
+			4,
+			14,
+			0
+		],
+		106: [
+			2,
+			0,
+			6,
+			2,
+			2,
+			18,
+			12,
+			0
+		],
+		107: [
+			16,
+			16,
+			18,
+			20,
+			24,
+			20,
+			18,
+			0
+		],
+		108: [
+			12,
+			4,
+			4,
+			4,
+			4,
+			4,
+			14,
+			0
+		],
+		109: [
+			0,
+			0,
+			26,
+			21,
+			21,
+			17,
+			17,
+			0
+		],
+		110: [
+			0,
+			0,
+			22,
+			25,
+			17,
+			17,
+			17,
+			0
+		],
+		111: [
+			0,
+			0,
+			14,
+			17,
+			17,
+			17,
+			14,
+			0
+		],
+		112: [
+			0,
+			0,
+			30,
+			17,
+			30,
+			16,
+			16,
+			0
+		],
+		113: [
+			0,
+			0,
+			13,
+			19,
+			15,
+			1,
+			1,
+			0
+		],
+		114: [
+			0,
+			0,
+			22,
+			25,
+			16,
+			16,
+			16,
+			0
+		],
+		115: [
+			0,
+			0,
+			14,
+			16,
+			14,
+			1,
+			30,
+			0
+		],
+		116: [
+			8,
+			8,
+			28,
+			8,
+			8,
+			9,
+			6,
+			0
+		],
+		117: [
+			0,
+			0,
+			17,
+			17,
+			17,
+			19,
+			13,
+			0
+		],
+		118: [
+			0,
+			0,
+			17,
+			17,
+			17,
+			10,
+			4,
+			0
+		],
+		119: [
+			0,
+			0,
+			17,
+			17,
+			21,
+			21,
+			10,
+			0
+		],
+		120: [
+			0,
+			0,
+			17,
+			10,
+			4,
+			10,
+			17,
+			0
+		],
+		121: [
+			0,
+			0,
+			17,
+			17,
+			15,
+			1,
+			14,
+			0
+		],
+		122: [
+			0,
+			0,
+			31,
+			2,
+			4,
+			8,
+			31,
+			0
+		],
+		123: [
+			2,
+			4,
+			4,
+			8,
+			4,
+			4,
+			2,
+			0
+		],
+		124: [
+			4,
+			4,
+			4,
+			4,
+			4,
+			4,
+			4,
+			0
+		],
+		125: [
+			8,
+			4,
+			4,
+			2,
+			4,
+			4,
+			8,
+			0
+		],
+		126: [
+			0,
+			0,
+			8,
+			21,
+			2,
+			0,
+			0,
+			0
+		]
+	};
+	/** Render text string to a grayscale bitmap (0 = transparent, 255 = opaque). */
+	function renderTextBitmap(text, scale) {
+		const charW = GLYPH_WIDTH * scale;
+		const charH = GLYPH_HEIGHT * scale;
+		const width = text.length * charW;
+		const height = charH;
+		const pixels = new Uint8Array(width * height);
+		for (let ci = 0; ci < text.length; ci++) {
+			const glyph = FONT_DATA[text.charCodeAt(ci)] ?? FONT_DATA[63];
+			const xOff = ci * charW;
+			for (let row = 0; row < GLYPH_HEIGHT; row++) {
+				const bits = glyph[row];
+				for (let col = 0; col < GLYPH_WIDTH; col++) if (bits & 1 << GLYPH_WIDTH - 1 - col) for (let sy = 0; sy < scale; sy++) for (let sx = 0; sx < scale; sx++) {
+					const px = xOff + col * scale + sx;
+					const py = row * scale + sy;
+					if (px < width && py < height) pixels[py * width + px] = 255;
+				}
+			}
+		}
+		return {
+			width,
+			height,
+			pixels
+		};
+	}
+	/** Rotate a grayscale bitmap by the given angle in degrees. */
+	function rotateBitmap(pixels, srcW, srcH, angleDeg) {
+		if (angleDeg === 0) return {
+			width: srcW,
+			height: srcH,
+			pixels
+		};
+		const rad = angleDeg * Math.PI / 180;
+		const cos = Math.cos(rad);
+		const sin = Math.sin(rad);
+		const corners = [
+			{
+				x: 0,
+				y: 0
+			},
+			{
+				x: srcW,
+				y: 0
+			},
+			{
+				x: srcW,
+				y: srcH
+			},
+			{
+				x: 0,
+				y: srcH
+			}
+		];
+		let minX = Infinity;
+		let minY = Infinity;
+		let maxX = -Infinity;
+		let maxY = -Infinity;
+		for (const c of corners) {
+			const rx = c.x * cos - c.y * sin;
+			const ry = c.x * sin + c.y * cos;
+			minX = Math.min(minX, rx);
+			minY = Math.min(minY, ry);
+			maxX = Math.max(maxX, rx);
+			maxY = Math.max(maxY, ry);
+		}
+		const dstW = Math.ceil(maxX - minX);
+		const dstH = Math.ceil(maxY - minY);
+		const dst = new Uint8Array(dstW * dstH);
+		const invCos = cos;
+		const invSin = -sin;
+		for (let dy = 0; dy < dstH; dy++) for (let dx = 0; dx < dstW; dx++) {
+			const wx = dx + minX;
+			const wy = dy + minY;
+			const sx = Math.round(wx * invCos - wy * invSin);
+			const sy = Math.round(wx * invSin + wy * invCos);
+			if (sx >= 0 && sx < srcW && sy >= 0 && sy < srcH) dst[dy * dstW + dx] = pixels[sy * srcW + sx];
+		}
+		return {
+			width: dstW,
+			height: dstH,
+			pixels: dst
+		};
+	}
+	/** Encode RGBA pixel data to a PNG file. */
+	function encodePng(rgba, width, height) {
+		const rawRowSize = 1 + width * 4;
+		const rawData = new Uint8Array(rawRowSize * height);
+		for (let y = 0; y < height; y++) {
+			rawData[y * rawRowSize] = 0;
+			rawData.set(rgba.subarray(y * width * 4, (y + 1) * width * 4), y * rawRowSize + 1);
+		}
+		const deflated = zlibCompress(rawData);
+		const sig = new Uint8Array([
+			137,
+			80,
+			78,
+			71,
+			13,
+			10,
+			26,
+			10
+		]);
+		const ihdr = new Uint8Array(13);
+		writeU32BE(ihdr, 0, width);
+		writeU32BE(ihdr, 4, height);
+		ihdr[8] = 8;
+		ihdr[9] = 6;
+		ihdr[10] = 0;
+		ihdr[11] = 0;
+		ihdr[12] = 0;
+		const ihdrChunk = pngChunk(1229472850, ihdr);
+		const idatChunk = pngChunk(1229209940, deflated);
+		const iendChunk = pngChunk(1229278788, new Uint8Array(0));
+		const result = new Uint8Array(sig.length + ihdrChunk.length + idatChunk.length + iendChunk.length);
+		let offset = 0;
+		result.set(sig, offset);
+		offset += sig.length;
+		result.set(ihdrChunk, offset);
+		offset += ihdrChunk.length;
+		result.set(idatChunk, offset);
+		offset += idatChunk.length;
+		result.set(iendChunk, offset);
+		return result;
+	}
+	/** Build a PNG chunk: length(4) + type(4) + data + crc32(4). */
+	function pngChunk(type, data) {
+		const chunk = new Uint8Array(12 + data.length);
+		writeU32BE(chunk, 0, data.length);
+		writeU32BE(chunk, 4, type);
+		chunk.set(data, 8);
+		const crc = crc32(chunk.subarray(4, 8 + data.length));
+		writeU32BE(chunk, 8 + data.length, crc);
+		return chunk;
+	}
+	/** Write a 32-bit big-endian unsigned int. */
+	function writeU32BE(buf, offset, value) {
+		buf[offset] = value >>> 24 & 255;
+		buf[offset + 1] = value >>> 16 & 255;
+		buf[offset + 2] = value >>> 8 & 255;
+		buf[offset + 3] = value & 255;
+	}
+	/** Wrap raw data in a zlib stream with deflate compression. */
+	function zlibCompress(data) {
+		const deflated = deflateRawCompressed(data, 6);
+		const adler = adler32(data);
+		const result = new Uint8Array(2 + deflated.length + 4);
+		result[0] = 120;
+		result[1] = 1;
+		result.set(deflated, 2);
+		writeU32BE(result, 2 + deflated.length, adler);
+		return result;
+	}
+	/** Compute Adler-32 checksum. */
+	function adler32(data) {
+		let a = 1;
+		let b = 0;
+		for (let i = 0; i < data.length; i++) {
+			a = (a + data[i]) % 65521;
+			b = (b + a) % 65521;
+		}
+		return b << 16 | a;
+	}
+	/** CRC32 lookup table. */
+	const CRC_TABLE = /* @__PURE__ */ (() => {
+		const table = new Uint32Array(256);
+		for (let n = 0; n < 256; n++) {
+			let c = n;
+			for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+			table[n] = c;
+		}
+		return table;
+	})();
+	/** Compute CRC32 checksum. */
+	function crc32(data) {
+		let crc = 4294967295;
+		for (let i = 0; i < data.length; i++) crc = CRC_TABLE[(crc ^ data[i]) & 255] ^ crc >>> 8;
+		return (crc ^ 4294967295) >>> 0;
+	}
+	//#endregion
 	//#region src/modules/pdf/types.ts
 	/**
 	* Type definitions for the PDF module.
@@ -45612,7 +47237,8 @@ onmessage = async (ev) => {
 		addPage(options) {
 			const objNum = this.allocObject();
 			const mediaBox = `[0 0 ${pdfNumber(options.width)} ${pdfNumber(options.height)}]`;
-			const dict = new PdfDict().set("Type", "/Page").set("Parent", pdfRef(options.parentRef)).set("MediaBox", mediaBox).set("Contents", pdfRef(options.contentsRef)).set("Resources", pdfRef(options.resourcesRef));
+			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.annotRefs && options.annotRefs.length > 0) dict.set("Annots", "[" + options.annotRefs.map((r) => pdfRef(r)).join(" ") + "]");
 			this.addObject(objNum, dict);
 			return objNum;
@@ -45861,6 +47487,396 @@ onmessage = async (ev) => {
 		return result;
 	}
 	//#endregion
+	//#region src/modules/pdf/core/pdf-stream.ts
+	/**
+	* PDF content stream builder.
+	*
+	* Provides a high-level API for constructing PDF content streams using
+	* PDF graphics operators. Content streams control what is drawn on a page:
+	* text, lines, rectangles, colors, etc.
+	*
+	* @see PDF Reference 1.7, Chapter 4 - Graphics
+	* @see PDF Reference 1.7, Chapter 5 - Text
+	*/
+	/**
+	* Builds a PDF content stream using graphics and text operators.
+	*
+	* PDF uses a postfix notation where operands precede the operator.
+	* For example: `100 200 m` means "move to point (100, 200)".
+	*
+	* Color model: PDF uses separate color state for stroking (lines/borders)
+	* and non-stroking (fills/text). We provide methods for both.
+	*/
+	var PdfContentStream = class {
+		constructor() {
+			this.parts = [];
+		}
+		/**
+		* Save the current graphics state (push onto state stack).
+		* Must be balanced with a corresponding restore().
+		*/
+		save() {
+			this.parts.push("q");
+			return this;
+		}
+		/**
+		* Restore the previously saved graphics state (pop from state stack).
+		*/
+		restore() {
+			this.parts.push("Q");
+			return this;
+		}
+		/**
+		* Set the current graphics state from an ExtGState resource.
+		* Used for transparency (alpha), blend modes, etc.
+		*/
+		setGraphicsState(name) {
+			this.parts.push(`/${name} gs`);
+			return this;
+		}
+		/**
+		* Set the stroking color (used for lines, borders).
+		*/
+		setStrokeColor(color) {
+			this.parts.push(`${pdfNumber(color.r)} ${pdfNumber(color.g)} ${pdfNumber(color.b)} RG`);
+			return this;
+		}
+		/**
+		* Set the non-stroking color (used for fills, text).
+		*/
+		setFillColor(color) {
+			this.parts.push(`${pdfNumber(color.r)} ${pdfNumber(color.g)} ${pdfNumber(color.b)} rg`);
+			return this;
+		}
+		/**
+		* Set the line width for stroking operations.
+		*/
+		setLineWidth(width) {
+			this.parts.push(`${pdfNumber(width)} w`);
+			return this;
+		}
+		/**
+		* Set the line dash pattern.
+		* @param dashArray - Array of dash/gap lengths. Empty = solid line.
+		* @param phase - Starting phase offset.
+		*/
+		setDashPattern(dashArray, phase = 0) {
+			const arr = dashArray.map(pdfNumber).join(" ");
+			this.parts.push(`[${arr}] ${pdfNumber(phase)} d`);
+			return this;
+		}
+		/**
+		* Set the line cap style.
+		* 0 = butt cap, 1 = round cap, 2 = projecting square cap
+		*/
+		setLineCap(style) {
+			this.parts.push(`${style} J`);
+			return this;
+		}
+		/**
+		* Set the line join style.
+		* 0 = miter join, 1 = round join, 2 = bevel join
+		*/
+		setLineJoin(style) {
+			this.parts.push(`${style} j`);
+			return this;
+		}
+		/**
+		* Begin a new subpath by moving to the given point.
+		*/
+		moveTo(x, y) {
+			this.parts.push(`${pdfNumber(x)} ${pdfNumber(y)} m`);
+			return this;
+		}
+		/**
+		* Append a straight line segment from the current point to (x, y).
+		*/
+		lineTo(x, y) {
+			this.parts.push(`${pdfNumber(x)} ${pdfNumber(y)} l`);
+			return this;
+		}
+		/**
+		* Append a rectangle to the current path.
+		* PDF convention: (x, y) is the lower-left corner.
+		*/
+		rect(x, y, width, height) {
+			this.parts.push(`${pdfNumber(x)} ${pdfNumber(y)} ${pdfNumber(width)} ${pdfNumber(height)} re`);
+			return this;
+		}
+		/**
+		* Stroke the current path.
+		*/
+		stroke() {
+			this.parts.push("S");
+			return this;
+		}
+		/**
+		* Fill the current path using the nonzero winding number rule.
+		*/
+		fill() {
+			this.parts.push("f");
+			return this;
+		}
+		/**
+		* Fill and then stroke the current path.
+		*/
+		fillAndStroke() {
+			this.parts.push("B");
+			return this;
+		}
+		/**
+		* Close the current subpath by appending a line from current point to start.
+		*/
+		closePath() {
+			this.parts.push("h");
+			return this;
+		}
+		/**
+		* End the path without filling or stroking (used for clipping).
+		*/
+		endPath() {
+			this.parts.push("n");
+			return this;
+		}
+		/**
+		* Set the current path as the clipping boundary (nonzero winding rule).
+		* Must be followed by endPath() or a painting operator.
+		*/
+		clip() {
+			this.parts.push("W");
+			return this;
+		}
+		/**
+		* Begin a text object.
+		*/
+		beginText() {
+			this.parts.push("BT");
+			return this;
+		}
+		/**
+		* End the current text object.
+		*/
+		endText() {
+			this.parts.push("ET");
+			return this;
+		}
+		/**
+		* Set the font and size for subsequent text operations.
+		* @param fontName - The font resource name (e.g., "F1")
+		* @param size - Font size in points
+		*/
+		setFont(fontName, size) {
+			this.parts.push(`/${fontName} ${pdfNumber(size)} Tf`);
+			return this;
+		}
+		/**
+		* Set the text matrix (position and transform for text).
+		* For simple positioning, use Td instead.
+		* @param a - Horizontal scaling
+		* @param b - Vertical skew
+		* @param c - Horizontal skew
+		* @param d - Vertical scaling
+		* @param e - Horizontal translation
+		* @param f - Vertical translation
+		*/
+		setTextMatrix(a, b, c, d, e, f) {
+			this.parts.push(`${pdfNumber(a)} ${pdfNumber(b)} ${pdfNumber(c)} ${pdfNumber(d)} ${pdfNumber(e)} ${pdfNumber(f)} Tm`);
+			return this;
+		}
+		/**
+		* Move to the start of the next line, offset from the start of the current line.
+		*/
+		moveText(tx, ty) {
+			this.parts.push(`${pdfNumber(tx)} ${pdfNumber(ty)} Td`);
+			return this;
+		}
+		/**
+		* Set the text leading (line spacing) for T* operator.
+		*/
+		setTextLeading(leading) {
+			this.parts.push(`${pdfNumber(leading)} TL`);
+			return this;
+		}
+		/**
+		* Show a text string. The string is escaped for PDF.
+		*/
+		showText(text) {
+			if (hasNonAscii(text)) return this.showTextWinAnsi(text);
+			this.parts.push(`(${escapeTextForPdf(text)}) Tj`);
+			return this;
+		}
+		/**
+		* Show a text string encoded as WinAnsi hex string.
+		* Used for Type1 fonts where non-ASCII characters need single-byte encoding.
+		*/
+		showTextWinAnsi(text) {
+			let hex = "<";
+			for (let i = 0; i < text.length; i++) {
+				const cp = text.codePointAt(i);
+				if (cp > 65535) i++;
+				const byte = unicodeToWinAnsi(cp);
+				hex += byte.toString(16).padStart(2, "0");
+			}
+			hex += ">";
+			this.parts.push(`${hex} Tj`);
+			return this;
+		}
+		/**
+		* Show a text string using a pre-encoded hex string (for CIDFonts).
+		* The hexString should be in the format `<0012003A...>`.
+		*/
+		showTextHex(hexString) {
+			this.parts.push(`${hexString} Tj`);
+			return this;
+		}
+		/**
+		* Move to the next line and show a text string.
+		*/
+		nextLineShowText(text) {
+			if (hasNonAscii(text)) {
+				let hex = "<";
+				for (let i = 0; i < text.length; i++) {
+					const cp = text.codePointAt(i);
+					if (cp > 65535) i++;
+					const byte = unicodeToWinAnsi(cp);
+					hex += byte.toString(16).padStart(2, "0");
+				}
+				hex += ">";
+				this.parts.push(`${hex} '`);
+				return this;
+			}
+			this.parts.push(`(${escapeTextForPdf(text)}) '`);
+			return this;
+		}
+		/**
+		* Set the text rise (baseline offset), used for superscript/subscript.
+		*/
+		setTextRise(rise) {
+			this.parts.push(`${pdfNumber(rise)} Ts`);
+			return this;
+		}
+		/**
+		* Set character spacing (extra space between characters).
+		*/
+		setCharacterSpacing(spacing) {
+			this.parts.push(`${pdfNumber(spacing)} Tc`);
+			return this;
+		}
+		/**
+		* Set word spacing (extra space for space character).
+		*/
+		setWordSpacing(spacing) {
+			this.parts.push(`${pdfNumber(spacing)} Tw`);
+			return this;
+		}
+		/**
+		* Draw an XObject (image) at the given position and size.
+		* The image must be registered as a resource with the given name.
+		*/
+		drawImage(name, x, y, width, height) {
+			return this.save().concat(width, 0, 0, height, x, y).doXObject(name).restore();
+		}
+		/**
+		* Apply a transformation matrix (cm operator).
+		*/
+		concat(a, b, c, d, e, f) {
+			this.parts.push(`${pdfNumber(a)} ${pdfNumber(b)} ${pdfNumber(c)} ${pdfNumber(d)} ${pdfNumber(e)} ${pdfNumber(f)} cm`);
+			return this;
+		}
+		/**
+		* Invoke a named XObject (Do operator).
+		*/
+		doXObject(name) {
+			this.parts.push(`/${name} Do`);
+			return this;
+		}
+		/**
+		* Draw a filled rectangle.
+		*/
+		fillRect(x, y, width, height, color) {
+			return this.save().setFillColor(color).rect(x, y, width, height).fill().restore();
+		}
+		/**
+		* Draw a stroked line.
+		*/
+		drawLine(x1, y1, x2, y2, color, lineWidth, dashPattern = []) {
+			this.save().setStrokeColor(color).setLineWidth(lineWidth);
+			if (dashPattern.length > 0) this.setDashPattern(dashPattern);
+			return this.moveTo(x1, y1).lineTo(x2, y2).stroke().restore();
+		}
+		/**
+		* Get the content stream as a string.
+		*/
+		toString() {
+			return this.parts.join("\n");
+		}
+		/**
+		* Get the content stream as a Uint8Array (UTF-8 encoded).
+		*/
+		toUint8Array() {
+			return new TextEncoder().encode(this.toString());
+		}
+	};
+	/**
+	* Escape a text string for use inside a PDF text operator.
+	* PDF text strings are delimited by parentheses.
+	*/
+	function escapeTextForPdf(text) {
+		return text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)").replace(/\r\n/g, "\\n").replace(/\r/g, "\\n").replace(/\n/g, "\\n");
+	}
+	/**
+	* Check if a string contains any non-ASCII characters (code point > 127).
+	*/
+	function hasNonAscii(text) {
+		for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) > 127) return true;
+		return false;
+	}
+	/**
+	* Map from Unicode code point to WinAnsi (Windows-1252) byte value.
+	* Only the 0x80-0x9F range differs from Latin-1; everything else maps 1:1
+	* for code points 0x00-0xFF.
+	*/
+	const UNICODE_TO_WINANSI = new Map([
+		[8364, 128],
+		[8218, 130],
+		[402, 131],
+		[8222, 132],
+		[8230, 133],
+		[8224, 134],
+		[8225, 135],
+		[710, 136],
+		[8240, 137],
+		[352, 138],
+		[8249, 139],
+		[338, 140],
+		[381, 142],
+		[8216, 145],
+		[8217, 146],
+		[8220, 147],
+		[8221, 148],
+		[8226, 149],
+		[8211, 150],
+		[8212, 151],
+		[732, 152],
+		[8482, 153],
+		[353, 154],
+		[8250, 155],
+		[339, 156],
+		[382, 158],
+		[376, 159]
+	]);
+	/**
+	* Convert a Unicode code point to a WinAnsi byte value.
+	* Returns 0x3F ('?') for unmappable characters.
+	*/
+	function unicodeToWinAnsi(cp) {
+		if (cp < 128) return cp;
+		if (cp >= 160 && cp <= 255) return cp;
+		const mapped = UNICODE_TO_WINANSI.get(cp);
+		if (mapped !== void 0) return mapped;
+		return 63;
+	}
+	//#endregion
 	//#region src/modules/pdf/font/metrics.ts
 	/**
 	* Character width metrics for the 14 PDF standard Type 1 fonts.
@@ -47778,396 +49794,6 @@ onmessage = async (ev) => {
 		}
 	}
 	//#endregion
-	//#region src/modules/pdf/core/pdf-stream.ts
-	/**
-	* PDF content stream builder.
-	*
-	* Provides a high-level API for constructing PDF content streams using
-	* PDF graphics operators. Content streams control what is drawn on a page:
-	* text, lines, rectangles, colors, etc.
-	*
-	* @see PDF Reference 1.7, Chapter 4 - Graphics
-	* @see PDF Reference 1.7, Chapter 5 - Text
-	*/
-	/**
-	* Builds a PDF content stream using graphics and text operators.
-	*
-	* PDF uses a postfix notation where operands precede the operator.
-	* For example: `100 200 m` means "move to point (100, 200)".
-	*
-	* Color model: PDF uses separate color state for stroking (lines/borders)
-	* and non-stroking (fills/text). We provide methods for both.
-	*/
-	var PdfContentStream = class {
-		constructor() {
-			this.parts = [];
-		}
-		/**
-		* Save the current graphics state (push onto state stack).
-		* Must be balanced with a corresponding restore().
-		*/
-		save() {
-			this.parts.push("q");
-			return this;
-		}
-		/**
-		* Restore the previously saved graphics state (pop from state stack).
-		*/
-		restore() {
-			this.parts.push("Q");
-			return this;
-		}
-		/**
-		* Set the current graphics state from an ExtGState resource.
-		* Used for transparency (alpha), blend modes, etc.
-		*/
-		setGraphicsState(name) {
-			this.parts.push(`/${name} gs`);
-			return this;
-		}
-		/**
-		* Set the stroking color (used for lines, borders).
-		*/
-		setStrokeColor(color) {
-			this.parts.push(`${pdfNumber(color.r)} ${pdfNumber(color.g)} ${pdfNumber(color.b)} RG`);
-			return this;
-		}
-		/**
-		* Set the non-stroking color (used for fills, text).
-		*/
-		setFillColor(color) {
-			this.parts.push(`${pdfNumber(color.r)} ${pdfNumber(color.g)} ${pdfNumber(color.b)} rg`);
-			return this;
-		}
-		/**
-		* Set the line width for stroking operations.
-		*/
-		setLineWidth(width) {
-			this.parts.push(`${pdfNumber(width)} w`);
-			return this;
-		}
-		/**
-		* Set the line dash pattern.
-		* @param dashArray - Array of dash/gap lengths. Empty = solid line.
-		* @param phase - Starting phase offset.
-		*/
-		setDashPattern(dashArray, phase = 0) {
-			const arr = dashArray.map(pdfNumber).join(" ");
-			this.parts.push(`[${arr}] ${pdfNumber(phase)} d`);
-			return this;
-		}
-		/**
-		* Set the line cap style.
-		* 0 = butt cap, 1 = round cap, 2 = projecting square cap
-		*/
-		setLineCap(style) {
-			this.parts.push(`${style} J`);
-			return this;
-		}
-		/**
-		* Set the line join style.
-		* 0 = miter join, 1 = round join, 2 = bevel join
-		*/
-		setLineJoin(style) {
-			this.parts.push(`${style} j`);
-			return this;
-		}
-		/**
-		* Begin a new subpath by moving to the given point.
-		*/
-		moveTo(x, y) {
-			this.parts.push(`${pdfNumber(x)} ${pdfNumber(y)} m`);
-			return this;
-		}
-		/**
-		* Append a straight line segment from the current point to (x, y).
-		*/
-		lineTo(x, y) {
-			this.parts.push(`${pdfNumber(x)} ${pdfNumber(y)} l`);
-			return this;
-		}
-		/**
-		* Append a rectangle to the current path.
-		* PDF convention: (x, y) is the lower-left corner.
-		*/
-		rect(x, y, width, height) {
-			this.parts.push(`${pdfNumber(x)} ${pdfNumber(y)} ${pdfNumber(width)} ${pdfNumber(height)} re`);
-			return this;
-		}
-		/**
-		* Stroke the current path.
-		*/
-		stroke() {
-			this.parts.push("S");
-			return this;
-		}
-		/**
-		* Fill the current path using the nonzero winding number rule.
-		*/
-		fill() {
-			this.parts.push("f");
-			return this;
-		}
-		/**
-		* Fill and then stroke the current path.
-		*/
-		fillAndStroke() {
-			this.parts.push("B");
-			return this;
-		}
-		/**
-		* Close the current subpath by appending a line from current point to start.
-		*/
-		closePath() {
-			this.parts.push("h");
-			return this;
-		}
-		/**
-		* End the path without filling or stroking (used for clipping).
-		*/
-		endPath() {
-			this.parts.push("n");
-			return this;
-		}
-		/**
-		* Set the current path as the clipping boundary (nonzero winding rule).
-		* Must be followed by endPath() or a painting operator.
-		*/
-		clip() {
-			this.parts.push("W");
-			return this;
-		}
-		/**
-		* Begin a text object.
-		*/
-		beginText() {
-			this.parts.push("BT");
-			return this;
-		}
-		/**
-		* End the current text object.
-		*/
-		endText() {
-			this.parts.push("ET");
-			return this;
-		}
-		/**
-		* Set the font and size for subsequent text operations.
-		* @param fontName - The font resource name (e.g., "F1")
-		* @param size - Font size in points
-		*/
-		setFont(fontName, size) {
-			this.parts.push(`/${fontName} ${pdfNumber(size)} Tf`);
-			return this;
-		}
-		/**
-		* Set the text matrix (position and transform for text).
-		* For simple positioning, use Td instead.
-		* @param a - Horizontal scaling
-		* @param b - Vertical skew
-		* @param c - Horizontal skew
-		* @param d - Vertical scaling
-		* @param e - Horizontal translation
-		* @param f - Vertical translation
-		*/
-		setTextMatrix(a, b, c, d, e, f) {
-			this.parts.push(`${pdfNumber(a)} ${pdfNumber(b)} ${pdfNumber(c)} ${pdfNumber(d)} ${pdfNumber(e)} ${pdfNumber(f)} Tm`);
-			return this;
-		}
-		/**
-		* Move to the start of the next line, offset from the start of the current line.
-		*/
-		moveText(tx, ty) {
-			this.parts.push(`${pdfNumber(tx)} ${pdfNumber(ty)} Td`);
-			return this;
-		}
-		/**
-		* Set the text leading (line spacing) for T* operator.
-		*/
-		setTextLeading(leading) {
-			this.parts.push(`${pdfNumber(leading)} TL`);
-			return this;
-		}
-		/**
-		* Show a text string. The string is escaped for PDF.
-		*/
-		showText(text) {
-			if (hasNonAscii(text)) return this.showTextWinAnsi(text);
-			this.parts.push(`(${escapeTextForPdf(text)}) Tj`);
-			return this;
-		}
-		/**
-		* Show a text string encoded as WinAnsi hex string.
-		* Used for Type1 fonts where non-ASCII characters need single-byte encoding.
-		*/
-		showTextWinAnsi(text) {
-			let hex = "<";
-			for (let i = 0; i < text.length; i++) {
-				const cp = text.codePointAt(i);
-				if (cp > 65535) i++;
-				const byte = unicodeToWinAnsi(cp);
-				hex += byte.toString(16).padStart(2, "0");
-			}
-			hex += ">";
-			this.parts.push(`${hex} Tj`);
-			return this;
-		}
-		/**
-		* Show a text string using a pre-encoded hex string (for CIDFonts).
-		* The hexString should be in the format `<0012003A...>`.
-		*/
-		showTextHex(hexString) {
-			this.parts.push(`${hexString} Tj`);
-			return this;
-		}
-		/**
-		* Move to the next line and show a text string.
-		*/
-		nextLineShowText(text) {
-			if (hasNonAscii(text)) {
-				let hex = "<";
-				for (let i = 0; i < text.length; i++) {
-					const cp = text.codePointAt(i);
-					if (cp > 65535) i++;
-					const byte = unicodeToWinAnsi(cp);
-					hex += byte.toString(16).padStart(2, "0");
-				}
-				hex += ">";
-				this.parts.push(`${hex} '`);
-				return this;
-			}
-			this.parts.push(`(${escapeTextForPdf(text)}) '`);
-			return this;
-		}
-		/**
-		* Set the text rise (baseline offset), used for superscript/subscript.
-		*/
-		setTextRise(rise) {
-			this.parts.push(`${pdfNumber(rise)} Ts`);
-			return this;
-		}
-		/**
-		* Set character spacing (extra space between characters).
-		*/
-		setCharacterSpacing(spacing) {
-			this.parts.push(`${pdfNumber(spacing)} Tc`);
-			return this;
-		}
-		/**
-		* Set word spacing (extra space for space character).
-		*/
-		setWordSpacing(spacing) {
-			this.parts.push(`${pdfNumber(spacing)} Tw`);
-			return this;
-		}
-		/**
-		* Draw an XObject (image) at the given position and size.
-		* The image must be registered as a resource with the given name.
-		*/
-		drawImage(name, x, y, width, height) {
-			return this.save().concat(width, 0, 0, height, x, y).doXObject(name).restore();
-		}
-		/**
-		* Apply a transformation matrix (cm operator).
-		*/
-		concat(a, b, c, d, e, f) {
-			this.parts.push(`${pdfNumber(a)} ${pdfNumber(b)} ${pdfNumber(c)} ${pdfNumber(d)} ${pdfNumber(e)} ${pdfNumber(f)} cm`);
-			return this;
-		}
-		/**
-		* Invoke a named XObject (Do operator).
-		*/
-		doXObject(name) {
-			this.parts.push(`/${name} Do`);
-			return this;
-		}
-		/**
-		* Draw a filled rectangle.
-		*/
-		fillRect(x, y, width, height, color) {
-			return this.save().setFillColor(color).rect(x, y, width, height).fill().restore();
-		}
-		/**
-		* Draw a stroked line.
-		*/
-		drawLine(x1, y1, x2, y2, color, lineWidth, dashPattern = []) {
-			this.save().setStrokeColor(color).setLineWidth(lineWidth);
-			if (dashPattern.length > 0) this.setDashPattern(dashPattern);
-			return this.moveTo(x1, y1).lineTo(x2, y2).stroke().restore();
-		}
-		/**
-		* Get the content stream as a string.
-		*/
-		toString() {
-			return this.parts.join("\n");
-		}
-		/**
-		* Get the content stream as a Uint8Array (UTF-8 encoded).
-		*/
-		toUint8Array() {
-			return new TextEncoder().encode(this.toString());
-		}
-	};
-	/**
-	* Escape a text string for use inside a PDF text operator.
-	* PDF text strings are delimited by parentheses.
-	*/
-	function escapeTextForPdf(text) {
-		return text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)").replace(/\r\n/g, "\\n").replace(/\r/g, "\\n").replace(/\n/g, "\\n");
-	}
-	/**
-	* Check if a string contains any non-ASCII characters (code point > 127).
-	*/
-	function hasNonAscii(text) {
-		for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) > 127) return true;
-		return false;
-	}
-	/**
-	* Map from Unicode code point to WinAnsi (Windows-1252) byte value.
-	* Only the 0x80-0x9F range differs from Latin-1; everything else maps 1:1
-	* for code points 0x00-0xFF.
-	*/
-	const UNICODE_TO_WINANSI = new Map([
-		[8364, 128],
-		[8218, 130],
-		[402, 131],
-		[8222, 132],
-		[8230, 133],
-		[8224, 134],
-		[8225, 135],
-		[710, 136],
-		[8240, 137],
-		[352, 138],
-		[8249, 139],
-		[338, 140],
-		[381, 142],
-		[8216, 145],
-		[8217, 146],
-		[8220, 147],
-		[8221, 148],
-		[8226, 149],
-		[8211, 150],
-		[8212, 151],
-		[732, 152],
-		[8482, 153],
-		[353, 154],
-		[8250, 155],
-		[339, 156],
-		[382, 158],
-		[376, 159]
-	]);
-	/**
-	* Convert a Unicode code point to a WinAnsi byte value.
-	* Returns 0x3F ('?') for unmappable characters.
-	*/
-	function unicodeToWinAnsi(cp) {
-		if (cp < 128) return cp;
-		if (cp >= 160 && cp <= 255) return cp;
-		const mapped = UNICODE_TO_WINANSI.get(cp);
-		if (mapped !== void 0) return mapped;
-		return 63;
-	}
-	//#endregion
 	//#region src/modules/pdf/render/constants.ts
 	/**
 	* Line-height multiplier applied to the font size.
@@ -48248,13 +49874,38 @@ onmessage = async (ev) => {
 			stream.restore();
 		} else stream.fillRect(cell.rect.x, cell.rect.y, cell.rect.width, cell.rect.height, cell.fillColor);
 	}
+	/**
+	* Convert Excel textRotation to standard signed degrees.
+	* Excel uses 1-90 for CCW and 91-180 for CW (where 91 = -1°, 180 = -90°).
+	* Returns 0 for non-numeric values (e.g. "vertical").
+	*/
+	function excelRotationToDegrees(textRotation) {
+		if (typeof textRotation !== "number") return 0;
+		return textRotation <= 90 ? textRotation : -(textRotation - 90);
+	}
+	/**
+	* Compute the horizontal slant offset for parallelogram borders.
+	* For general rotation angles (not 0°/90°), Excel renders cell borders as a
+	* parallelogram whose left/right edges tilt to match the text rotation angle.
+	* Returns 0 for straight borders (no rotation, 90°, -90°, or vertical stacked).
+	*/
+	function computeSlantOffset(textRotation, height) {
+		const degrees = excelRotationToDegrees(textRotation);
+		if (degrees === 0) return 0;
+		const absDeg = Math.abs(degrees);
+		if (absDeg < .01 || absDeg > 89.99) return 0;
+		const radians = absDeg * Math.PI / 180;
+		const offset = height * Math.cos(radians) / Math.sin(radians);
+		return degrees < 0 ? -offset : offset;
+	}
 	function drawCellBorders(stream, cell) {
-		const { rect, borders } = cell;
+		const { rect, borders, textRotation } = cell;
 		const { x, y, width, height } = rect;
-		if (borders.top) drawBorderLine(stream, borders.top, x, y + height, x + width, y + height, true);
+		const slant = computeSlantOffset(textRotation, height);
+		if (borders.top) drawBorderLine(stream, borders.top, x + slant, y + height, x + width + slant, y + height, true);
 		if (borders.bottom) drawBorderLine(stream, borders.bottom, x, y, x + width, y, true);
-		if (borders.left) drawBorderLine(stream, borders.left, x, y, x, y + height, false);
-		if (borders.right) drawBorderLine(stream, borders.right, x + width, y, x + width, y + height, false);
+		if (borders.left) drawBorderLine(stream, borders.left, x, y, x + slant, y + height, false);
+		if (borders.right) drawBorderLine(stream, borders.right, x + width, y, x + width + slant, y + height, false);
 	}
 	function drawBorderLine(stream, border, x1, y1, x2, y2, isHorizontal) {
 		if (border.isDouble) {
@@ -48280,7 +49931,14 @@ onmessage = async (ev) => {
 		const indentPts = cell.indent * 10 * scaleFactor;
 		const clipWidth = rect.width + (cell.textOverflowWidth || 0);
 		stream.save();
-		stream.rect(rect.x, rect.y, clipWidth, rect.height);
+		const slantClip = computeSlantOffset(cell.textRotation, rect.height);
+		if (slantClip !== 0) {
+			stream.moveTo(rect.x, rect.y);
+			stream.lineTo(rect.x + clipWidth, rect.y);
+			stream.lineTo(rect.x + clipWidth + slantClip, rect.y + rect.height);
+			stream.lineTo(rect.x + slantClip, rect.y + rect.height);
+			stream.closePath();
+		} else stream.rect(rect.x, rect.y, clipWidth, rect.height);
 		stream.clip();
 		stream.endPath();
 		const textAlpha = cell.textColor.a;
@@ -48444,9 +50102,7 @@ onmessage = async (ev) => {
 		const padH = 3 * scaleFactor;
 		const padV = 2 * scaleFactor;
 		const resourceName = fontManager.hasEmbeddedFont() ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(resolvePdfFontName(cell.fontFamily, cell.bold, cell.italic));
-		let degrees;
-		if (typeof cell.textRotation === "number") degrees = cell.textRotation <= 90 ? cell.textRotation : -(cell.textRotation - 90);
-		else degrees = 0;
+		const degrees = excelRotationToDegrees(cell.textRotation);
 		const radians = degrees * Math.PI / 180;
 		const cos = Math.cos(radians);
 		const sin = Math.sin(radians);
@@ -48491,7 +50147,7 @@ onmessage = async (ev) => {
 		const { rect, horizontalAlign, verticalAlign } = cell;
 		const totalColumnsWidth = lines.length * lineHeight;
 		let startX;
-		if (horizontalAlign === "center" || lines.length === 1) startX = rect.x + rect.width / 2 - totalColumnsWidth / 2 + ascent;
+		if (horizontalAlign === "center") startX = rect.x + rect.width / 2 - totalColumnsWidth / 2 + ascent;
 		else if (horizontalAlign === "right") startX = rect.x + rect.width - padH - totalColumnsWidth + ascent;
 		else startX = rect.x + padH + ascent;
 		for (let i = 0; i < lines.length; i++) {
@@ -48499,9 +50155,9 @@ onmessage = async (ev) => {
 			const lineWidth = fontManager.measureText(line, resourceName, fontSize);
 			const colX = startX + i * lineHeight;
 			let ty;
-			if (verticalAlign === "top") ty = rect.y + padV;
+			if (verticalAlign === "top") ty = rect.y + rect.height - padV - lineWidth;
 			else if (verticalAlign === "middle") ty = rect.y + (rect.height - lineWidth) / 2;
-			else ty = rect.y + rect.height - padV - lineWidth;
+			else ty = rect.y + padV;
 			ty = Math.max(ty, rect.y + padV);
 			stream.beginText();
 			stream.setFont(resourceName, fontSize);
@@ -48515,7 +50171,7 @@ onmessage = async (ev) => {
 		const { rect, horizontalAlign, verticalAlign } = cell;
 		const totalColumnsWidth = lines.length * lineHeight;
 		let startX;
-		if (horizontalAlign === "center" || lines.length === 1) startX = rect.x + rect.width / 2 + totalColumnsWidth / 2 - lineHeight + ascent;
+		if (horizontalAlign === "center") startX = rect.x + rect.width / 2 + totalColumnsWidth / 2 - lineHeight + ascent;
 		else if (horizontalAlign === "right") startX = rect.x + rect.width - padH - lineHeight + ascent;
 		else startX = rect.x + padH + totalColumnsWidth - lineHeight + ascent;
 		for (let i = 0; i < lines.length; i++) {
@@ -48536,10 +50192,31 @@ onmessage = async (ev) => {
 	}
 	/** General rotation — center a multi-line text block in the cell. */
 	function drawRotatedGeneral(stream, cell, lines, fontManager, resourceName, fontSize, lineHeight, ascent, cos, sin, indentPts) {
-		const { rect, horizontalAlign } = cell;
+		const { rect, horizontalAlign, verticalAlign } = cell;
+		const padH = 3;
+		const padV = 2;
+		let maxLineWidth = 0;
+		for (const line of lines) {
+			const w = fontManager.measureText(line, resourceName, fontSize);
+			if (w > maxLineWidth) maxLineWidth = w;
+		}
+		const totalTextHeight = lines.length * lineHeight;
+		const absSin = Math.abs(sin);
+		const absCos = Math.abs(cos);
+		const rotatedWidth = maxLineWidth * absCos + totalTextHeight * absSin;
+		const rotatedHeight = maxLineWidth * absSin + totalTextHeight * absCos;
+		const slantShift = computeSlantOffset(cell.textRotation, rect.height) / 2;
 		const indentOffset = horizontalAlign === "left" ? indentPts / 2 : horizontalAlign === "right" ? -indentPts / 2 : 0;
-		const cx = rect.x + rect.width / 2 + indentOffset;
-		const cy = rect.y + rect.height / 2;
+		let cy;
+		if (verticalAlign === "top") cy = rect.y + rect.height - padV - rotatedHeight / 2;
+		else if (verticalAlign === "bottom") cy = rect.y + padV + rotatedHeight / 2;
+		else cy = rect.y + rect.height / 2;
+		const verticalRatio = rect.height > 0 ? (cy - rect.y) / rect.height : .5;
+		const slantAtCy = slantShift * 2 * verticalRatio;
+		let cx;
+		if (horizontalAlign === "right") cx = rect.x + rect.width - padH - rotatedWidth / 2 + indentOffset + slantAtCy;
+		else if (horizontalAlign === "left") cx = rect.x + padH + rotatedWidth / 2 + indentOffset + slantAtCy;
+		else cx = rect.x + rect.width / 2 + indentOffset + slantAtCy;
 		for (let i = 0; i < lines.length; i++) {
 			const line = lines[i];
 			const lineWidth = fontManager.measureText(line, resourceName, fontSize);
@@ -48566,7 +50243,8 @@ onmessage = async (ev) => {
 	* Newlines (\n) start a new column to the right.
 	*/
 	function drawVerticalStackedText(stream, cell, fontManager, _indentPts, scaleFactor = 1) {
-		const { rect, text, fontSize } = cell;
+		const { rect, text, fontSize, horizontalAlign, verticalAlign } = cell;
+		const padH = 3 * scaleFactor;
 		const padV = 2 * scaleFactor;
 		const resourceName = fontManager.hasEmbeddedFont() ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(resolvePdfFontName(cell.fontFamily, cell.bold, cell.italic));
 		const charHeight = fontSize * 1.3;
@@ -48574,12 +50252,19 @@ onmessage = async (ev) => {
 		const columns = text.split(/\r?\n/);
 		const columnWidth = fontSize * 1.4;
 		const totalColumnsWidth = columns.length * columnWidth;
-		const startX = rect.x + rect.width / 2 - totalColumnsWidth / 2 + columnWidth / 2;
+		let startX;
+		if (horizontalAlign === "center") startX = rect.x + rect.width / 2 - totalColumnsWidth / 2 + columnWidth / 2;
+		else if (horizontalAlign === "right") startX = rect.x + rect.width - padH - totalColumnsWidth + columnWidth / 2;
+		else startX = rect.x + padH + columnWidth / 2;
 		stream.setFillColor(cell.textColor);
 		for (let colIdx = 0; colIdx < columns.length; colIdx++) {
 			const colText = columns[colIdx];
 			const colX = startX + colIdx * columnWidth;
-			let currentY = rect.y + rect.height - padV - ascent;
+			const totalTextHeight = colText.length * charHeight;
+			let currentY;
+			if (verticalAlign === "middle") currentY = rect.y + rect.height / 2 + totalTextHeight / 2 - ascent;
+			else if (verticalAlign === "bottom") currentY = rect.y + padV + totalTextHeight - ascent;
+			else currentY = rect.y + rect.height - padV - ascent;
 			for (const ch of colText) {
 				if (currentY < rect.y + padV) break;
 				const charWidth = fontManager.measureText(ch, resourceName, fontSize);
@@ -48729,6 +50414,234 @@ onmessage = async (ev) => {
 		stream.endText();
 		stream.restore();
 	}
+	/** Default values for text watermarks. */
+	const TEXT_WM_DEFAULTS = {
+		fontSize: 54,
+		color: {
+			r: .75,
+			g: .75,
+			b: .75
+		},
+		opacity: .15,
+		rotation: -45,
+		fontFamily: "Helvetica",
+		bold: false,
+		italic: false,
+		repeatSpacingX: 200,
+		repeatSpacingY: 200
+	};
+	/** Default values for image watermarks. */
+	const IMAGE_WM_DEFAULTS = {
+		opacity: .15,
+		rotation: 0,
+		scale: .5,
+		repeatSpacingX: 200,
+		repeatSpacingY: 200
+	};
+	/** Minimum allowed spacing for repeat patterns (prevents infinite loops). */
+	const MIN_REPEAT_SPACING = 10;
+	/**
+	* Render a watermark onto a PDF content stream.
+	* This should be called BEFORE the cell/grid content is rendered so the
+	* watermark sits behind everything (under-content).
+	*/
+	function renderWatermark(stream, page, watermark, fontManager) {
+		if (watermark.type === "text") return renderTextWatermark(stream, page, normalizeTextWatermark(watermark), fontManager);
+		return renderImageWatermark(stream, page, normalizeImageWatermark(watermark));
+	}
+	/** Clamp/normalize text watermark options to safe ranges. */
+	function normalizeTextWatermark(wm) {
+		return {
+			...wm,
+			opacity: clamp01(wm.opacity ?? TEXT_WM_DEFAULTS.opacity),
+			fontSize: Math.max(1, wm.fontSize ?? TEXT_WM_DEFAULTS.fontSize),
+			repeatSpacingX: Math.max(MIN_REPEAT_SPACING, wm.repeatSpacingX ?? TEXT_WM_DEFAULTS.repeatSpacingX),
+			repeatSpacingY: Math.max(MIN_REPEAT_SPACING, wm.repeatSpacingY ?? TEXT_WM_DEFAULTS.repeatSpacingY)
+		};
+	}
+	/** Clamp/normalize image watermark options to safe ranges. */
+	function normalizeImageWatermark(wm) {
+		return {
+			...wm,
+			opacity: clamp01(wm.opacity ?? IMAGE_WM_DEFAULTS.opacity),
+			scale: Math.max(.01, wm.scale ?? IMAGE_WM_DEFAULTS.scale),
+			width: wm.width !== void 0 ? Math.max(1, wm.width) : void 0,
+			height: wm.height !== void 0 ? Math.max(1, wm.height) : void 0,
+			repeatSpacingX: Math.max(MIN_REPEAT_SPACING, wm.repeatSpacingX ?? IMAGE_WM_DEFAULTS.repeatSpacingX),
+			repeatSpacingY: Math.max(MIN_REPEAT_SPACING, wm.repeatSpacingY ?? IMAGE_WM_DEFAULTS.repeatSpacingY)
+		};
+	}
+	/** Clamp a number to the 0..1 range. */
+	function clamp01(v) {
+		return Math.max(0, Math.min(1, v));
+	}
+	/**
+	* Render a text watermark on a single page.
+	*/
+	function renderTextWatermark(stream, page, watermark, fontManager) {
+		const fontSize = watermark.fontSize ?? TEXT_WM_DEFAULTS.fontSize;
+		const color = watermark.color ?? TEXT_WM_DEFAULTS.color;
+		const opacity = watermark.opacity ?? TEXT_WM_DEFAULTS.opacity;
+		const rotation = watermark.rotation ?? TEXT_WM_DEFAULTS.rotation;
+		const fontFamily = watermark.fontFamily ?? TEXT_WM_DEFAULTS.fontFamily;
+		const bold = watermark.bold ?? TEXT_WM_DEFAULTS.bold;
+		const italic = watermark.italic ?? TEXT_WM_DEFAULTS.italic;
+		const resourceName = fontManager.hasEmbeddedFont() ? fontManager.getEmbeddedResourceName() : fontManager.ensureFont(resolvePdfFontName(fontFamily, bold, italic));
+		const textWidth = fontManager.measureText(watermark.text, resourceName, fontSize);
+		const textHeight = fontSize * .7;
+		const radians = rotation * Math.PI / 180;
+		const cos = Math.cos(radians);
+		const sin = Math.sin(radians);
+		const needsAlpha = opacity < 1;
+		const gsName = needsAlpha ? alphaGsName(opacity) : "";
+		const drawSingleWatermark = (cx, cy) => {
+			const halfW = textWidth / 2;
+			const halfH = textHeight / 2;
+			const tx = cx - halfW * cos + halfH * sin;
+			const ty = cy - halfW * sin - halfH * cos;
+			stream.save();
+			if (needsAlpha) stream.setGraphicsState(gsName);
+			stream.setFillColor(color);
+			stream.beginText();
+			stream.setFont(resourceName, fontSize);
+			stream.setTextMatrix(cos, sin, -sin, cos, tx, ty);
+			const hex = fontManager.encodeText(watermark.text, resourceName);
+			if (hex) stream.showTextHex(hex);
+			else stream.showText(watermark.text);
+			stream.endText();
+			stream.restore();
+		};
+		if (watermark.repeat) {
+			const spacingX = watermark.repeatSpacingX ?? TEXT_WM_DEFAULTS.repeatSpacingX;
+			const spacingY = watermark.repeatSpacingY ?? TEXT_WM_DEFAULTS.repeatSpacingY;
+			renderRepeatedPattern(page.width, page.height, spacingX, spacingY, drawSingleWatermark);
+		} else {
+			const { cx, cy } = resolveWatermarkCenter(page, watermark.position);
+			drawSingleWatermark(cx, cy);
+		}
+		return {
+			alphaValues: needsAlpha ? [opacity] : [],
+			imageXObjects: []
+		};
+	}
+	/**
+	* Render an image watermark on a single page.
+	*/
+	function renderImageWatermark(stream, page, watermark) {
+		const opacity = watermark.opacity ?? IMAGE_WM_DEFAULTS.opacity;
+		const rotation = watermark.rotation ?? IMAGE_WM_DEFAULTS.rotation;
+		const scale = watermark.scale ?? IMAGE_WM_DEFAULTS.scale;
+		const needsAlpha = opacity < 1;
+		let imgWidth;
+		let imgHeight;
+		if (watermark.width !== void 0 && watermark.height !== void 0) {
+			imgWidth = watermark.width;
+			imgHeight = watermark.height;
+		} else {
+			const dims = parseImageDimensions(watermark.data, watermark.format);
+			const targetSize = Math.min(page.width, page.height) * scale;
+			const maxDim = Math.max(dims.width, dims.height);
+			const ratio = maxDim > 0 ? targetSize / maxDim : 1;
+			imgWidth = dims.width * ratio;
+			imgHeight = dims.height * ratio;
+		}
+		const radians = rotation * Math.PI / 180;
+		const cos = Math.cos(radians);
+		const sin = Math.sin(radians);
+		const gsName = needsAlpha ? alphaGsName(opacity) : "";
+		const imgName = "WmImg";
+		const drawSingleWatermark = (cx, cy) => {
+			stream.save();
+			if (needsAlpha) stream.setGraphicsState(gsName);
+			const halfW = imgWidth / 2;
+			const halfH = imgHeight / 2;
+			const tx = cx - halfW * cos + halfH * sin;
+			const ty = cy - halfW * sin - halfH * cos;
+			stream.concat(imgWidth * cos, imgWidth * sin, -imgHeight * sin, imgHeight * cos, tx, ty);
+			stream.doXObject(imgName);
+			stream.restore();
+		};
+		if (watermark.repeat) {
+			const spacingX = watermark.repeatSpacingX ?? IMAGE_WM_DEFAULTS.repeatSpacingX;
+			const spacingY = watermark.repeatSpacingY ?? IMAGE_WM_DEFAULTS.repeatSpacingY;
+			renderRepeatedPattern(page.width, page.height, spacingX, spacingY, drawSingleWatermark);
+		} else {
+			const { cx, cy } = resolveWatermarkCenter(page, watermark.position);
+			drawSingleWatermark(cx, cy);
+		}
+		return {
+			alphaValues: needsAlpha ? [opacity] : [],
+			imageXObjects: [{
+				name: imgName,
+				data: watermark.data,
+				format: watermark.format
+			}]
+		};
+	}
+	/**
+	* Parse image dimensions from raw JPEG or PNG data without a full decode.
+	*/
+	function parseImageDimensions(data, format) {
+		if (format === "png") return parsePngDimensions(data);
+		return parseJpegDimensions(data);
+	}
+	/** Read width/height from a PNG IHDR chunk (bytes 16-23). */
+	function parsePngDimensions(data) {
+		if (data.length >= 24 && data[12] === 73 && data[13] === 72 && data[14] === 68 && data[15] === 82) return {
+			width: data[16] << 24 | data[17] << 16 | data[18] << 8 | data[19],
+			height: data[20] << 24 | data[21] << 16 | data[22] << 8 | data[23]
+		};
+		return {
+			width: 1,
+			height: 1
+		};
+	}
+	/** Read width/height from JPEG SOF marker. */
+	function parseJpegDimensions(data) {
+		let offset = 2;
+		while (offset < data.length - 1) {
+			while (offset < data.length && data[offset] === 255 && data[offset + 1] === 255) offset++;
+			if (offset >= data.length - 1 || data[offset] !== 255) break;
+			const marker = data[offset + 1];
+			if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204 && offset + 8 < data.length) return {
+				width: data[offset + 7] << 8 | data[offset + 8],
+				height: data[offset + 5] << 8 | data[offset + 6]
+			};
+			if (offset + 3 >= data.length) break;
+			const segLen = data[offset + 2] << 8 | data[offset + 3];
+			offset += 2 + segLen;
+		}
+		return {
+			width: 1,
+			height: 1
+		};
+	}
+	/**
+	* Resolve the center position for a watermark on a given page.
+	*/
+	function resolveWatermarkCenter(page, position) {
+		if (!position || position === "center") return {
+			cx: page.width / 2,
+			cy: page.height / 2
+		};
+		return {
+			cx: position.x,
+			cy: position.y
+		};
+	}
+	/**
+	* Render a repeated pattern of watermarks across the entire page.
+	* Uses a staggered grid for a natural diagonal tiling effect.
+	*/
+	function renderRepeatedPattern(pageWidth, pageHeight, spacingX, spacingY, drawFn) {
+		const margin = Math.max(pageWidth, pageHeight) * .5;
+		let rowIndex = 0;
+		for (let y = -margin; y < pageHeight + margin; y += spacingY) {
+			const offsetX = rowIndex % 2 === 1 ? spacingX / 2 : 0;
+			for (let x = -margin; x < pageWidth + margin; x += spacingX) drawFn(x + offsetX, y);
+			rowIndex++;
+		}
+	}
 	//#endregion
 	//#region src/modules/pdf/render/layout-engine.ts
 	const DEFAULT_COLUMN_WIDTH = 8.43;
@@ -49631,7 +51544,15 @@ onmessage = async (ev) => {
 		ensureAtLeastOnePage(allPages, documentOptions, sheets);
 		fixPageNumbers(allPages);
 		trackFontsForHeaders(allPages, fontManager);
-		const { pageObjNums, sheetFirstPage, pagesTreeObjNum } = await renderAllPages(allPages, fontManager, writer, fontManager.writeFontResources(writer));
+		const watermark = documentOptions.watermark;
+		if (watermark && watermark.type === "text") {
+			const wmFontFamily = watermark.fontFamily ?? "Helvetica";
+			const wmBold = watermark.bold ?? false;
+			const wmItalic = watermark.italic ?? false;
+			if (fontManager.hasEmbeddedFont()) fontManager.trackText(watermark.text);
+			else fontManager.ensureFont(resolvePdfFontName(wmFontFamily, wmBold, wmItalic));
+		}
+		const { pageObjNums, sheetFirstPage, pagesTreeObjNum } = await renderAllPages(allPages, fontManager, writer, fontManager.writeFontResources(writer), watermark);
 		return buildFinalPdf(writer, pageObjNums, pagesTreeObjNum, sheetFirstPage, documentOptions, workbook, options);
 	}
 	function ensureAtLeastOnePage(allPages, documentOptions, sheets) {
@@ -49664,13 +51585,13 @@ onmessage = async (ev) => {
 			for (const page of allPages) if (page.options.showSheetNames) fontManager.ensureFont(resolvePdfFontName(page.options.defaultFontFamily, true, false));
 		}
 	}
-	async function renderAllPages(allPages, fontManager, writer, fontObjectMap) {
+	async function renderAllPages(allPages, fontManager, writer, fontObjectMap, watermark) {
 		const pageObjNums = [];
 		const pagesTreeObjNum = writer.allocObject();
 		const sheetFirstPage = /* @__PURE__ */ new Map();
 		const totalPages = allPages.length;
 		for (let i = 0; i < allPages.length; i++) {
-			renderSinglePage(allPages[i], fontManager, writer, fontObjectMap, totalPages, pageObjNums, pagesTreeObjNum, sheetFirstPage);
+			renderSinglePage(allPages[i], fontManager, writer, fontObjectMap, totalPages, pageObjNums, pagesTreeObjNum, sheetFirstPage, watermark);
 			if (i < allPages.length - 1) await yieldToEventLoop();
 		}
 		return {
@@ -49679,7 +51600,7 @@ onmessage = async (ev) => {
 			pagesTreeObjNum
 		};
 	}
-	function renderSinglePage(page, fontManager, writer, fontObjectMap, totalPages, pageObjNums, pagesTreeObjNum, sheetFirstPage) {
+	function renderSinglePage(page, fontManager, writer, fontObjectMap, totalPages, pageObjNums, pagesTreeObjNum, sheetFirstPage, watermark) {
 		try {
 			const { stream: contentStream, alphaValues } = renderPage(page, page.options, fontManager, totalPages);
 			const imageXObjects = /* @__PURE__ */ new Map();
@@ -49690,9 +51611,24 @@ onmessage = async (ev) => {
 				imageXObjects.set(imgName, imgObjNum);
 				contentStream.drawImage(imgName, img.rect.x, img.rect.y, img.rect.width, img.rect.height);
 			}
+			let watermarkContentObjNum;
+			if (watermark && isWatermarkApplicable(watermark, page)) {
+				const wmContentStream = new PdfContentStream();
+				const wmResult = renderWatermark(wmContentStream, page, watermark, fontManager);
+				for (const alpha of wmResult.alphaValues) alphaValues.add(alpha);
+				for (const wmImg of wmResult.imageXObjects) {
+					const imgObjNum = writeImageXObject(writer, wmImg.data, wmImg.format);
+					imageXObjects.set(wmImg.name, imgObjNum);
+				}
+				watermarkContentObjNum = writer.allocObject();
+				writer.addStreamObject(watermarkContentObjNum, new PdfDict(), wmContentStream);
+			}
 			const contentObjNum = writer.allocObject();
-			const contentDict = new PdfDict();
-			writer.addStreamObject(contentObjNum, contentDict, contentStream);
+			writer.addStreamObject(contentObjNum, new PdfDict(), contentStream);
+			let contentsRef;
+			if (watermarkContentObjNum) if ((watermark?.placement ?? "under") === "over") contentsRef = `[${pdfRef(contentObjNum)} ${pdfRef(watermarkContentObjNum)}]`;
+			else contentsRef = `[${pdfRef(watermarkContentObjNum)} ${pdfRef(contentObjNum)}]`;
+			else contentsRef = pdfRef(contentObjNum);
 			const resourcesObjNum = writer.allocObject();
 			const fontDictStr = fontManager.buildFontDictString(fontObjectMap);
 			const resourcesDict = new PdfDict().set("Font", fontDictStr);
@@ -49726,7 +51662,7 @@ onmessage = async (ev) => {
 				parentRef: pagesTreeObjNum,
 				width: page.width,
 				height: page.height,
-				contentsRef: contentObjNum,
+				contentsRef,
 				resourcesRef: resourcesObjNum,
 				annotRefs: annotRefs.length > 0 ? annotRefs : void 0
 			});
@@ -49805,7 +51741,8 @@ onmessage = async (ev) => {
 			title: options?.title ?? "",
 			author: options?.author ?? "",
 			subject: options?.subject ?? "",
-			creator: options?.creator ?? "excelts"
+			creator: options?.creator ?? "excelts",
+			watermark: options?.watermark
 		};
 	}
 	/** Map PaperSize enum values to PDF page sizes. */
@@ -49872,6 +51809,20 @@ onmessage = async (ev) => {
 		return outlinesObjNum;
 	}
 	/**
+	* Check if a watermark should be applied to a specific page based on
+	* optional page number and sheet name filters.
+	*/
+	function isWatermarkApplicable(watermark, page) {
+		if (watermark.pages && watermark.pages.length > 0) {
+			if (!watermark.pages.includes(page.pageNumber)) return false;
+		}
+		if (watermark.sheets && watermark.sheets.length > 0) {
+			const sheetLower = page.sheetName.toLowerCase();
+			if (!watermark.sheets.some((s) => s.toLowerCase() === sheetLower)) return false;
+		}
+		return true;
+	}
+	/**
 	* Write a JPEG or PNG image as a PDF XObject Image.
 	*/
 	function writeImageXObject(writer, data, format) {
@@ -49883,7 +51834,7 @@ onmessage = async (ev) => {
 	*/
 	function writeJpegImageXObject(writer, data) {
 		const objNum = writer.allocObject();
-		const dims = getJpegDimensions(data);
+		const dims = parseImageDimensions(data, "jpeg");
 		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");
 		writer.addStreamObject(objNum, dict, data);
 		return objNum;
@@ -49904,37 +51855,6 @@ onmessage = async (ev) => {
 		writer.addStreamObject(objNum, dict, png.pixels);
 		return objNum;
 	}
-	/**
-	* Extract width and height from a JPEG file header.
-	* Scans for SOF markers (SOF0-SOF3, SOF5-SOF7, SOF9-SOF11, SOF13-SOF15)
-	* which all share the same frame header layout.
-	* Handles 0xFF padding bytes per JPEG spec.
-	*/
-	function getJpegDimensions(data) {
-		let offset = 2;
-		while (offset < data.length - 1) {
-			while (offset < data.length && data[offset] === 255 && data[offset + 1] === 255) offset++;
-			if (offset >= data.length - 1 || data[offset] !== 255) break;
-			const marker = data[offset + 1];
-			if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
-				if (offset + 8 < data.length) {
-					const height = data[offset + 5] << 8 | data[offset + 6];
-					return {
-						width: data[offset + 7] << 8 | data[offset + 8],
-						height
-					};
-				}
-				break;
-			}
-			if (offset + 3 >= data.length) break;
-			const segLen = data[offset + 2] << 8 | data[offset + 3];
-			offset += 2 + segLen;
-		}
-		return {
-			width: 1,
-			height: 1
-		};
-	}
 	//#endregion
 	//#region src/modules/pdf/pdf.ts
 	/**
@@ -50509,6 +52429,7 @@ onmessage = async (ev) => {
 	exports.concatUint8Arrays = concatUint8Arrays;
 	exports.createCsvFormatterStream = createCsvFormatterStream;
 	exports.createCsvParserStream = createCsvParserStream;
+	exports.createTextWatermarkImage = createTextWatermarkImage;
 	exports.dateToExcel = dateToExcel;
 	exports.decodeCell = decodeCell;
 	exports.decodeCol = decodeCol;