@pdfme/schemas 6.2.3-dev.6 → 6.2.3-dev.7

package/dist/{dynamicTemplate-Zqt6kNsE.js → dynamicTemplate-BJxwjEWl.js}

@@ -1,5 +1,394 @@
 import { A as getBoxVerticalInset, D as getBoxContentArea, E as createBoxDimension, F as ALIGN_LEFT, I as ALIGN_RIGHT, N as ALIGN_CENTER, O as getBoxDimensionPropPanelSchema, V as DEFAULT_FONT_COLOR, b as splitTextToSize, g as getFontKitFont, it as VERTICAL_ALIGN_MIDDLE, l as getTableBodyRange, o as createTableBodySplitRange, rt as VERTICAL_ALIGN_BOTTOM, x as widthOfTextAtSize, z as DEFAULT_ALIGNMENT } from "./splitRange-B6311Noc.js";
 import { cloneDeep, getDefaultFont, getFallbackFontName, isBlankPdf, mm2pt, pt2mm } from "@pdfme/common";
+import { Buffer } from "buffer";
+import jpegJsModule from "jpeg-js";
+import UPNGModule from "@pdf-lib/upng";
+//#region src/graphics/imagehelper.ts
+var decoder = new TextDecoder();
+var toUTF8String = (input, start = 0, end = input.length) => decoder.decode(input.slice(start, end));
+var toHexString = (input, start = 0, end = input.length) => input.slice(start, end).reduce((memo, i) => memo + ("0" + i.toString(16)).slice(-2), "");
+var readUInt16BE = (input, offset = 0) => input[offset] * 256 + input[offset + 1];
+var readUInt32BE = (input, offset = 0) => input[offset] * 2 ** 24 + input[offset + 1] * 2 ** 16 + input[offset + 2] * 256 + input[offset + 3];
+var extractSize = (input, index) => {
+	return {
+		height: readUInt16BE(input, index),
+		width: readUInt16BE(input, index + 2)
+	};
+};
+var validateInput = (input, index) => {
+	if (index > input.length) throw new TypeError("Corrupt JPG, exceeded buffer limits");
+	if (input[index] !== 255) throw new TypeError("Invalid JPG, marker table corrupted");
+};
+var JPG = {
+	validate: (input) => toHexString(input, 0, 2) === "ffd8",
+	calculate(input) {
+		input = input.slice(4);
+		let next;
+		while (input.length) {
+			const i = readUInt16BE(input, 0);
+			validateInput(input, i);
+			next = input[i + 1];
+			if (next === 192 || next === 193 || next === 194) return extractSize(input, i + 5);
+			input = input.slice(i + 2);
+		}
+		throw new TypeError("Invalid JPG, no size found");
+	}
+};
+var pngSignature = "PNG\r\n\n";
+var pngImageHeaderChunkName = "IHDR";
+var pngFriedChunkName = "CgBI";
+var typeHandlers = {
+	jpg: JPG,
+	png: {
+		validate(input) {
+			if (pngSignature === toUTF8String(input, 1, 8)) {
+				let chunkName = toUTF8String(input, 12, 16);
+				if (chunkName === pngFriedChunkName) chunkName = toUTF8String(input, 28, 32);
+				if (chunkName !== pngImageHeaderChunkName) throw new TypeError("Invalid PNG");
+				return true;
+			}
+			return false;
+		},
+		calculate(input) {
+			if (toUTF8String(input, 12, 16) === pngFriedChunkName) return {
+				height: readUInt32BE(input, 36),
+				width: readUInt32BE(input, 32)
+			};
+			return {
+				height: readUInt32BE(input, 20),
+				width: readUInt32BE(input, 16)
+			};
+		}
+	}
+};
+function detector(input) {
+	const firstBytes = {
+		137: "png",
+		255: "jpg"
+	};
+	const byte = input[0];
+	if (byte in firstBytes) {
+		const type = firstBytes[byte];
+		if (type && typeHandlers[type].validate(input)) return type;
+	}
+	return Object.keys(typeHandlers).find((key) => typeHandlers[key].validate(input));
+}
+/**
+* FNV-1a 32-bit fingerprint of an image data URL.
+* Image embed cache keys are `${type}:${length}:${hash}` and must keep this hash.
+*/
+var hashImageDataUrl = (value) => {
+	let hash = 2166136261;
+	for (let i = 0; i < value.length; i++) {
+		hash ^= value.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16).padStart(8, "0");
+};
+var getImageDimension = (value) => {
+	if (typeof value !== "string") return imageSize(Buffer.from(value));
+	const idx = value.indexOf(";base64,");
+	const imgBase64 = value.substring(idx + 8, value.length);
+	return imageSize(Buffer.from(imgBase64, "base64"));
+};
+var imageSize = (imgBuffer) => {
+	const type = detector(imgBuffer);
+	if (typeof type !== "undefined" && type in typeHandlers) {
+		const size = typeHandlers[type].calculate(imgBuffer);
+		if (size !== void 0) return size;
+	}
+	throw new TypeError("[@pdfme/schemas/images] Unsupported file type: " + (type === void 0 ? "undefined" : type));
+};
+//#endregion
+//#region src/graphics/orientation.ts
+var isJpegJsApi = (value) => !!value && typeof value === "object" && typeof value.decode === "function" && typeof value.encode === "function";
+var isUPNGApi = (value) => !!value && typeof value === "object" && typeof value.decode === "function" && typeof value.toRGBA8 === "function" && typeof value.encode === "function";
+var resolveExport = (value, guard, label) => {
+	let current = value;
+	while (current && typeof current === "object") {
+		if (guard(current)) return current;
+		current = current.default;
+	}
+	throw new TypeError(`Failed to resolve ${label} exports`);
+};
+var jpegJs = resolveExport(jpegJsModule, isJpegJsApi, "jpeg-js");
+var UPNG = resolveExport(UPNGModule, isUPNGApi, "@pdf-lib/upng");
+var JPEG_ENCODE_QUALITY = 90;
+var JPEG_MAX_MEMORY_MB = 512;
+var JPEG_SOI_0 = 255;
+var JPEG_SOI_1 = 216;
+var PNG_SIGNATURE = new Uint8Array([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+var toArrayBuffer = (bytes) => {
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy.buffer;
+};
+var isPngSignature = (bytes) => {
+	if (bytes.length < PNG_SIGNATURE.length) return false;
+	for (let i = 0; i < PNG_SIGNATURE.length; i++) if (bytes[i] !== PNG_SIGNATURE[i]) return false;
+	return true;
+};
+var detectImageFormat = (bytes) => {
+	if (bytes.length >= 2 && bytes[0] === JPEG_SOI_0 && bytes[1] === JPEG_SOI_1) return "jpeg";
+	if (isPngSignature(bytes)) return "png";
+	return "other";
+};
+/** TIFF/IFD0: returns 1..8 or undefined. Never throws. */
+var parseTiffOrientation = (tiff) => {
+	try {
+		if (tiff.length < 8) return void 0;
+		const le = tiff[0] === 73 && tiff[1] === 73;
+		if (!le && !(tiff[0] === 77 && tiff[1] === 77)) return void 0;
+		const view = new DataView(tiff.buffer, tiff.byteOffset, tiff.byteLength);
+		if (view.getUint16(2, le) !== 42) return void 0;
+		const ifd = view.getUint32(4, le);
+		if (ifd + 2 > tiff.length) return void 0;
+		const n = view.getUint16(ifd, le);
+		for (let i = 0; i < n; i++) {
+			const entry = ifd + 2 + i * 12;
+			if (entry + 12 > tiff.length) return void 0;
+			if (view.getUint16(entry, le) !== 274) continue;
+			if (view.getUint16(entry + 2, le) !== 3) return void 0;
+			if (view.getUint32(entry + 4, le) !== 1) return void 0;
+			const val = view.getUint16(entry + 8, le);
+			return val >= 1 && val <= 8 ? val : void 0;
+		}
+		return;
+	} catch {
+		return;
+	}
+};
+var isExifApp1Payload = (segment) => segment.length >= 6 && segment[0] === 69 && segment[1] === 120 && segment[2] === 105 && segment[3] === 102 && segment[4] === 0 && segment[5] === 0;
+/** Standalone JPEG markers have no length field (TEM, RST0–7, SOI). */
+var isStandaloneJpegMarker = (marker) => marker === 1 || marker >= 208 && marker <= 216;
+/**
+* JPEG: scan APP1 'Exif\0\0' segments; stop at SOS/EOI.
+* Skips 0xFF fill/padding and standalone markers. If an Exif APP1 has no
+* valid Orientation, keep scanning for a later one.
+*/
+var getJpegOrientation = (bytes) => {
+	if (bytes.length < 2 || bytes[0] !== JPEG_SOI_0 || bytes[1] !== JPEG_SOI_1) return void 0;
+	let pos = 2;
+	while (pos < bytes.length) {
+		if (bytes[pos] !== 255) return void 0;
+		while (pos < bytes.length && bytes[pos] === 255) pos++;
+		if (pos >= bytes.length) return void 0;
+		const marker = bytes[pos++];
+		if (isStandaloneJpegMarker(marker)) continue;
+		if (marker === 218 || marker === 217) return void 0;
+		if (pos + 2 > bytes.length) return void 0;
+		const size = bytes[pos] << 8 | bytes[pos + 1];
+		if (size < 2 || pos + size > bytes.length) return void 0;
+		if (marker === 225 && size >= 8) {
+			const segment = bytes.subarray(pos + 2, pos + size);
+			if (isExifApp1Payload(segment)) {
+				const orientation = parseTiffOrientation(segment.subarray(6));
+				if (orientation !== void 0) return orientation;
+			}
+		}
+		pos += size;
+	}
+};
+/**
+* PNG: scan chunks for eXIf (raw TIFF payload). Skip IDAT and other
+* ancillary chunks; eXIf may appear after image data. Stop at IEND.
+*/
+var getPngOrientation = (bytes) => {
+	if (!isPngSignature(bytes)) return void 0;
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let pos = 8;
+	while (pos + 12 <= bytes.length) {
+		const length = view.getUint32(pos);
+		if (pos + 12 + length > bytes.length) return void 0;
+		const type = String.fromCharCode(bytes[pos + 4], bytes[pos + 5], bytes[pos + 6], bytes[pos + 7]);
+		if (type === "eXIf") return parseTiffOrientation(bytes.subarray(pos + 8, pos + 8 + length));
+		if (type === "IEND") return void 0;
+		pos += 12 + length;
+	}
+};
+var orientationSwapsDimensions = (orientation) => orientation >= 5;
+/**
+* Map source (x, y) into destination (dx, dy) for EXIF orientations 2–8.
+* Orientations 5–8 swap width and height.
+*/
+var transformRgba = (src, width, height, orientation) => {
+	const swap = orientationSwapsDimensions(orientation);
+	const destWidth = swap ? height : width;
+	const destHeight = swap ? width : height;
+	const dest = new Uint8Array(destWidth * destHeight * 4);
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+		let dx = x;
+		let dy = y;
+		switch (orientation) {
+			case 2:
+				dx = width - 1 - x;
+				dy = y;
+				break;
+			case 3:
+				dx = width - 1 - x;
+				dy = height - 1 - y;
+				break;
+			case 4:
+				dx = x;
+				dy = height - 1 - y;
+				break;
+			case 5:
+				dx = y;
+				dy = x;
+				break;
+			case 6:
+				dx = height - 1 - y;
+				dy = x;
+				break;
+			case 7:
+				dx = height - 1 - y;
+				dy = width - 1 - x;
+				break;
+			case 8:
+				dx = y;
+				dy = width - 1 - x;
+		}
+		const srcIndex = (y * width + x) * 4;
+		const destIndex = (dy * destWidth + dx) * 4;
+		dest[destIndex] = src[srcIndex];
+		dest[destIndex + 1] = src[srcIndex + 1];
+		dest[destIndex + 2] = src[srcIndex + 2];
+		dest[destIndex + 3] = src[srcIndex + 3];
+	}
+	return {
+		data: dest,
+		width: destWidth,
+		height: destHeight
+	};
+};
+var bakeJpegOrientation = (bytes) => {
+	const orientation = getJpegOrientation(bytes);
+	if (!orientation || orientation === 1) return bytes;
+	const raw = jpegJs.decode(bytes, {
+		useTArray: true,
+		formatAsRGBA: true,
+		maxMemoryUsageInMB: JPEG_MAX_MEMORY_MB
+	});
+	const transformed = transformRgba(raw.data, raw.width, raw.height, orientation);
+	return new Uint8Array(jpegJs.encode({
+		data: transformed.data,
+		width: transformed.width,
+		height: transformed.height
+	}, JPEG_ENCODE_QUALITY).data);
+};
+var bakePngOrientation = (bytes) => {
+	const orientation = getPngOrientation(bytes);
+	if (!orientation || orientation === 1) return bytes;
+	const img = UPNG.decode(toArrayBuffer(bytes));
+	const transformed = transformRgba(new Uint8Array(UPNG.toRGBA8(img)[0]), img.width, img.height, orientation);
+	return new Uint8Array(UPNG.encode([toArrayBuffer(transformed.data)], transformed.width, transformed.height, 0));
+};
+/**
+* One normalize path for JPEG and PNG. Tag absent/1 is a byte-identical
+* passthrough. Tag 2–8 decodes, transforms pixels, and re-encodes without
+* an orientation tag. May throw on decode/encode failure — callers fall back.
+*/
+var normalizeImageOrientation = (bytes) => {
+	const kind = detectImageFormat(bytes);
+	if (kind === "jpeg") return bakeJpegOrientation(bytes);
+	if (kind === "png") return bakePngOrientation(bytes);
+	return bytes;
+};
+var TABLE_IMAGE_DATA_URL_PATTERN = /^data:image\/(png|jpe?g);base64,/i;
+//#endregion
+//#region src/tables/types.ts
+var TABLE_CELL_TYPES = ["text", "image"];
+//#endregion
+//#region src/tables/imageCell.ts
+var DIMENSION_CACHE_PREFIX = "tableImageDim:";
+var WARN_CACHE_PREFIX = "tableImageWarned:";
+var FAILED_DIMENSION = null;
+var isTableCellType = (value) => typeof value === "string" && TABLE_CELL_TYPES.some((cellType) => cellType === value);
+var isDimension = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return typeof record.width === "number" && typeof record.height === "number";
+};
+var dataUrlToBytes = (value) => {
+	const index = value.indexOf(";base64,");
+	const base64 = index >= 0 ? value.slice(index + 8) : value;
+	return new Uint8Array(Buffer.from(base64, "base64"));
+};
+var applyOrientation = (dimension, bytes) => {
+	const format = detectImageFormat(bytes);
+	const orientation = format === "jpeg" ? getJpegOrientation(bytes) : format === "png" ? getPngOrientation(bytes) : void 0;
+	if (orientation !== void 0 && orientationSwapsDimensions(orientation)) return {
+		width: dimension.height,
+		height: dimension.width
+	};
+	return dimension;
+};
+var isTableImageDataUrl = (value) => TABLE_IMAGE_DATA_URL_PATTERN.test(value);
+var imageCacheSuffix = (value) => `${value.length}:${hashImageDataUrl(value)}`;
+var resolveImageDimension = (value, cache) => {
+	if (!isTableImageDataUrl(value)) return void 0;
+	const key = `${DIMENSION_CACHE_PREFIX}${imageCacheSuffix(value)}`;
+	const cached = cache.get(key);
+	if (cached === FAILED_DIMENSION) return void 0;
+	if (isDimension(cached)) return cached;
+	try {
+		const bytes = dataUrlToBytes(value);
+		const dimension = applyOrientation(getImageDimension(bytes), bytes);
+		cache.set(key, dimension);
+		return dimension;
+	} catch {
+		cache.set(key, FAILED_DIMENSION);
+		return;
+	}
+};
+var warnInvalidTableImageOnce = (value, columnIndex, cache) => {
+	if (value == null || value === "") return;
+	const key = `${WARN_CACHE_PREFIX}${imageCacheSuffix(value)}`;
+	if (cache.has(key)) return;
+	cache.set(key, true);
+	console.warn(`[@pdfme/schemas/table] unsupported image in column ${columnIndex}; only PNG/JPEG data URL is supported`);
+};
+var normalizeTableCellType = (value, columnIndex, cache) => {
+	if (value == null) return void 0;
+	if (isTableCellType(value)) return value;
+	const warnKey = `tableCellTypeWarned:${String(value)}`;
+	if (!cache.has(warnKey)) {
+		cache.set(warnKey, true);
+		console.warn(`[@pdfme/schemas/table] unsupported cell type "${String(value)}" in column ${columnIndex}; treating as text`);
+	}
+	return "text";
+};
+var normalizeTableImageHeightMode = (value) => value === "fixed" || value === "auto" ? value : void 0;
+var normalizeTableImageHeight = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+var getTableImageObjectPosition = (alignment, verticalAlignment) => {
+	return `${alignment === "center" || alignment === "right" ? alignment : "left"} ${verticalAlignment === "top" ? "top" : verticalAlignment === "bottom" ? "bottom" : "center"}`;
+};
+var resolveFixedTableImageHeight = (imageHeight) => typeof imageHeight === "number" && Number.isFinite(imageHeight) && imageHeight > 0 ? imageHeight : 20;
+/**
+* Fixed height is kept for empty and invalid values so rows in the column stay aligned.
+* Auto height is 0 unless a PNG/JPEG data URL resolves.
+*/
+var resolveTableImageContentHeight = (arg) => {
+	const mode = arg.mode ?? "fixed";
+	if (!arg.value) return mode === "auto" ? 0 : resolveFixedTableImageHeight(arg.imageHeight);
+	const dimension = resolveImageDimension(arg.value, arg.cache);
+	if (!dimension || dimension.width <= 0) {
+		warnInvalidTableImageOnce(arg.value, arg.columnIndex, arg.cache);
+		return mode === "auto" ? 0 : resolveFixedTableImageHeight(arg.imageHeight);
+	}
+	if (mode === "auto") return arg.contentWidth * dimension.height / dimension.width;
+	return resolveFixedTableImageHeight(arg.imageHeight);
+};
+//#endregion
 //#region \0@oxc-project+runtime@0.151.0/helpers/esm/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
@@ -50,6 +439,7 @@ var Cell = class {
 		_defineProperty(this, "wrappedWidth", 0);
 		_defineProperty(this, "minReadableWidth", 0);
 		_defineProperty(this, "minWidth", 0);
+		_defineProperty(this, "imageContentHeight", 0);
 		_defineProperty(this, "width", 0);
 		_defineProperty(this, "height", 0);
 		_defineProperty(this, "x", 0);
@@ -60,8 +450,13 @@ var Cell = class {
 		const splitRegex = /\r\n|\r|\n/g;
 		this.text = raw.split(splitRegex);
 	}
+	isImage() {
+		return this.section !== "head" && this.styles.cellType === "image";
+	}
 	getContentHeight() {
-		const height = (Array.isArray(this.text) ? this.text.length : 1) * (pt2mm(this.styles.fontSize) * this.styles.lineHeight) + getBoxVerticalInset(getCellBoxStyle(this));
+		const verticalInset = getBoxVerticalInset(getCellBoxStyle(this));
+		if (this.isImage()) return Math.max(this.imageContentHeight + verticalInset, this.styles.minCellHeight);
+		const height = (Array.isArray(this.text) ? this.text.length : 1) * (pt2mm(this.styles.fontSize) * this.styles.lineHeight) + verticalInset;
 		return Math.max(height, this.styles.minCellHeight);
 	}
 	padding(name) {
@@ -128,11 +523,12 @@ var Table = class Table {
 		this.body = content.body;
 	}
 	static async create(arg) {
-		const { input, content, font, _cache } = arg;
+		const { input, content, font, basePdf, _cache } = arg;
 		const table = new Table(input, content);
 		await calculateWidths({
 			table,
 			font,
+			basePdf,
 			_cache
 		});
 		return table;
@@ -154,7 +550,7 @@ var Table = class Table {
 	}
 };
 async function calculateWidths(arg) {
-	const { table, font, _cache } = arg;
+	const { table, font, basePdf, _cache } = arg;
 	const getFontKitFontByFontName = (fontName) => getFontKitFont(fontName, font, _cache);
 	await calculate(table, getFontKitFontByFontName);
 	const resizableColumns = [];
@@ -173,7 +569,7 @@ async function calculateWidths(arg) {
 	if (resizeWidth) resizeWidth = resizeColumns(resizableColumns, resizeWidth, (column) => column.minWidth);
 	resizeWidth = Math.abs(resizeWidth);
 	applyColSpans(table);
-	await fitContent(table, getFontKitFontByFontName);
+	await fitContent(table, getFontKitFontByFontName, basePdf, _cache);
 	applyRowSpans(table);
 }
 function applyRowSpans(table) {
@@ -229,7 +625,15 @@ function applyColSpans(table) {
 		}
 	}
 }
-async function fitContent(table, getFontKitFontByFontName) {
+var autoImageHeightLimit = (table, cell, basePdf) => {
+	if (!isBlankPdf(basePdf)) return void 0;
+	const [paddingTop, , paddingBottom] = basePdf.padding;
+	const pageContentHeight = basePdf.height - paddingTop - paddingBottom;
+	const headHeight = table.settings.templateShowHead ? table.head.reduce((sum, row) => sum + row.height, 0) : 0;
+	const verticalInset = getBoxVerticalInset(getCellBoxStyle(cell));
+	return pageContentHeight - headHeight - verticalInset - 1;
+};
+async function fitContent(table, getFontKitFontByFontName, basePdf, cache) {
 	const rowSpanHeight = {
 		count: 0,
 		height: 0
@@ -238,7 +642,6 @@ async function fitContent(table, getFontKitFontByFontName) {
 		for (const column of table.columns) {
 			const cell = row.cells[column.index];
 			if (!cell) continue;
-			const fontKitFont = await getFontKitFontByFontName(cell.styles.fontName);
 			const contentArea = getBoxContentArea({
 				position: {
 					x: 0,
@@ -248,13 +651,31 @@ async function fitContent(table, getFontKitFontByFontName) {
 				height: cell.height,
 				...getCellBoxStyle(cell)
 			});
-			cell.text = splitTextToSize({
-				value: cell.raw,
-				characterSpacing: cell.styles.characterSpacing,
-				boxWidthInPt: mm2pt(contentArea.width),
-				fontSize: cell.styles.fontSize,
-				fontKitFont
-			});
+			if (cell.isImage()) {
+				cell.text = [];
+				let imageContentHeight = resolveTableImageContentHeight({
+					value: cell.raw,
+					mode: cell.styles.imageHeightMode,
+					imageHeight: cell.styles.imageHeight,
+					contentWidth: contentArea.width,
+					columnIndex: column.index,
+					cache
+				});
+				if ((cell.styles.imageHeightMode ?? "fixed") === "auto") {
+					const limit = autoImageHeightLimit(table, cell, basePdf);
+					if (limit !== void 0) imageContentHeight = Math.min(imageContentHeight, Math.max(0, limit));
+				}
+				cell.imageContentHeight = imageContentHeight;
+			} else {
+				const fontKitFont = await getFontKitFontByFontName(cell.styles.fontName);
+				cell.text = splitTextToSize({
+					value: cell.raw,
+					characterSpacing: cell.styles.characterSpacing,
+					boxWidthInPt: mm2pt(contentArea.width),
+					fontSize: cell.styles.fontSize,
+					fontKitFont
+				});
+			}
 			cell.contentHeight = cell.getContentHeight();
 			let realContentHeight = cell.contentHeight;
 			if (rowSpanHeight && rowSpanHeight.count > 0) {
@@ -291,6 +712,13 @@ async function calculate(table, getFontKitFontByFontName) {
 		const cell = row.cells[column.index];
 		if (!cell) continue;
 		const hPadding = cell.padding("right") + cell.padding("left");
+		if (cell.isImage()) {
+			cell.contentWidth = hPadding;
+			cell.minReadableWidth = hPadding;
+			cell.minWidth = cell.styles.cellWidth;
+			cell.wrappedWidth = cell.styles.cellWidth;
+			continue;
+		}
 		const fontKitFont = await getFontKitFontByFontName(cell.styles.fontName);
 		cell.contentWidth = getStringWidth(cell, fontKitFont) + hPadding;
 		cell.minReadableWidth = getStringWidth(Object.assign(cell, { text: cell.text.join(" ").split(/\s+/) }), fontKitFont) + hPadding;
@@ -404,24 +832,43 @@ function mapCellStyle(style) {
 	};
 	return Object.fromEntries(Object.entries(mapping).filter(([, value]) => value !== void 0));
 }
-function getTableOptions(schema, body) {
+function getTableOptions(schema, body, cache) {
 	const columnStylesWidth = schema.headWidthPercentages.reduce((acc, cur, i) => ({
 		...acc,
 		[i]: { cellWidth: schema.width * (cur / 100) }
 	}), {});
-	const columnStylesAlignment = Object.entries(schema.columnStyles.alignment || {}).reduce((acc, [key, value]) => ({
+	const alignmentMap = schema.columnStyles.alignment || {};
+	const cellTypeMap = schema.columnStyles.cellType || {};
+	const imageHeightModeMap = schema.columnStyles.imageHeightMode || {};
+	const imageHeightMap = schema.columnStyles.imageHeight || {};
+	const columnStylesAlignment = Object.entries(alignmentMap).reduce((acc, [key, value]) => ({
 		...acc,
 		[key]: { alignment: value }
 	}), {});
-	const allKeys = /* @__PURE__ */ new Set([...Object.keys(columnStylesWidth).map(Number), ...Object.keys(columnStylesAlignment).map(Number)]);
+	const allKeys = /* @__PURE__ */ new Set([
+		...Object.keys(columnStylesWidth).map(Number),
+		...Object.keys(columnStylesAlignment).map(Number),
+		...Object.keys(cellTypeMap).map(Number),
+		...Object.keys(imageHeightModeMap).map(Number),
+		...Object.keys(imageHeightMap).map(Number)
+	]);
 	const columnStyles = Array.from(allKeys).reduce((acc, key) => {
 		const widthStyle = columnStylesWidth[key] || {};
 		const alignmentStyle = columnStylesAlignment[key] || {};
+		const cellType = normalizeTableCellType(cellTypeMap[key], key, cache);
+		const imageHeightMode = normalizeTableImageHeightMode(imageHeightModeMap[key]);
+		const imageHeight = normalizeTableImageHeight(imageHeightMap[key]);
+		const imageStyle = {
+			...cellType ? { cellType } : {},
+			...imageHeightMode ? { imageHeightMode } : {},
+			...imageHeight !== void 0 ? { imageHeight } : {}
+		};
 		return {
 			...acc,
 			[key]: {
 				...widthStyle,
-				...alignmentStyle
+				...alignmentStyle,
+				...imageStyle
 			}
 		};
 	}, {});
@@ -471,14 +918,15 @@ function parseContent4Input(options) {
 		body
 	};
 }
-function parseInput(schema, body) {
-	const options = getTableOptions(schema, body);
+function parseInput(schema, body, cache, templateShowHead) {
+	const options = getTableOptions(schema, body, cache);
 	const styles = parseStyles(options);
 	const settings = {
 		startY: options.startY,
 		margin: options.margin,
 		tableWidth: options.tableWidth,
 		showHead: options.showHead,
+		templateShowHead,
 		tableLineWidth: options.tableLineWidth ?? 0,
 		tableLineColor: options.tableLineColor ?? ""
 	};
@@ -498,14 +946,16 @@ function createSingleTable(body, args) {
 		schema.bodyStyles.alternateBackgroundColor = schema.bodyStyles.backgroundColor;
 		schema.bodyStyles.backgroundColor = alternateBackgroundColor;
 	}
+	const templateShowHead = schema.showHead !== false;
 	schema.showHead = schema.showHead === false ? false : !schema.__isSplit || schema.repeatHead === true;
-	const input = parseInput(schema, body);
+	const input = parseInput(schema, body, _cache, templateShowHead);
 	const font = options.font || getDefaultFont();
 	const content = parseContent4Table(input, getFallbackFontName(font));
 	return Table.create({
 		input,
 		content,
 		font,
+		basePdf,
 		_cache
 	});
 }
@@ -750,9 +1200,11 @@ var getDynamicHeightsForTable = async (value, args) => {
 	const initialPageIndex = Math.max(0, Math.floor((schema.position.y - paddingTop) / pageContentHeight));
 	const headRowCount = schema.showHead ? table.head.length : 0;
 	const SAFETY_MARGIN = .5;
+	const EPSILON = .01;
 	let currentPageIndex = initialPageIndex;
 	let currentPageY = schema.position.y;
 	let rowsOnCurrentPage = 0;
+	let headerTravelsWithBody = false;
 	const result = [];
 	for (let i = 0; i < baseHeights.length; i++) {
 		const isBodyRow = i >= headRowCount;
@@ -760,26 +1212,37 @@ var getDynamicHeightsForTable = async (value, args) => {
 		while (true) {
 			const currentPageStartY = getPageStartY(currentPageIndex);
 			const remainingHeight = currentPageStartY + pageContentHeight - currentPageY;
-			const totalRowHeight = rowHeight + (isBodyRow && rowsOnCurrentPage === 0 && currentPageIndex > initialPageIndex ? headerHeight : 0);
-			if (totalRowHeight > remainingHeight - SAFETY_MARGIN) {
+			const totalRowHeight = rowHeight + (isBodyRow && rowsOnCurrentPage === 0 && currentPageIndex > initialPageIndex && !headerTravelsWithBody ? headerHeight : 0);
+			if (totalRowHeight > remainingHeight - SAFETY_MARGIN + EPSILON) {
 				if (rowsOnCurrentPage === 0 && Math.abs(currentPageY - currentPageStartY) < SAFETY_MARGIN) {
 					result.push(totalRowHeight);
 					currentPageY += totalRowHeight;
 					rowsOnCurrentPage++;
+					headerTravelsWithBody = false;
 					break;
 				}
+				const headerWouldBeAlone = !headerTravelsWithBody && currentPageIndex === initialPageIndex && isBodyRow && headRowCount > 0 && result.length === headRowCount && rowsOnCurrentPage === headRowCount;
 				currentPageIndex++;
-				currentPageY = getPageStartY(currentPageIndex);
-				rowsOnCurrentPage = 0;
+				if (headerWouldBeAlone) {
+					headerTravelsWithBody = true;
+					currentPageY = getPageStartY(currentPageIndex) + headerHeight;
+					rowsOnCurrentPage = headRowCount;
+				} else {
+					headerTravelsWithBody = false;
+					currentPageY = getPageStartY(currentPageIndex);
+					rowsOnCurrentPage = 0;
+				}
 				continue;
 			}
 			result.push(totalRowHeight);
 			currentPageY += totalRowHeight;
 			rowsOnCurrentPage++;
+			if (isBodyRow) headerTravelsWithBody = false;
 			if (currentPageY >= currentPageStartY + pageContentHeight - SAFETY_MARGIN) {
 				currentPageIndex++;
 				currentPageY = getPageStartY(currentPageIndex);
 				rowsOnCurrentPage = 0;
+				headerTravelsWithBody = false;
 			}
 			break;
 		}
@@ -803,6 +1266,6 @@ var getDynamicLayoutForTable = async (value, args) => {
 	};
 };
 //#endregion
-export { getCellPropPanelSchema as a, remapColumnStylesOnRemove as c, createSingleTable as d, getBodyWithSchemaRange as i, HEX_COLOR_PATTERN as l, getDynamicLayoutForTable as n, getColumnStylesPropPanelSchema as o, getBody as r, getDefaultCellStyles as s, getDynamicHeightsForTable as t, OPAQUE_HEX_COLOR_PATTERN as u };
+export { hashImageDataUrl as _, getCellPropPanelSchema as a, remapColumnStylesOnRemove as c, createSingleTable as d, getTableImageObjectPosition as f, normalizeImageOrientation as g, detectImageFormat as h, getBodyWithSchemaRange as i, HEX_COLOR_PATTERN as l, warnInvalidTableImageOnce as m, getDynamicLayoutForTable as n, getColumnStylesPropPanelSchema as o, resolveImageDimension as p, getBody as r, getDefaultCellStyles as s, getDynamicHeightsForTable as t, OPAQUE_HEX_COLOR_PATTERN as u };
 
-//# sourceMappingURL=dynamicTemplate-Zqt6kNsE.js.map
+//# sourceMappingURL=dynamicTemplate-BJxwjEWl.js.map