@cj-tech-master/excelts 6.2.0 → 7.0.0

package/dist/iife/excelts.iife.js

@@ -1,5 +1,5 @@
 /*!
-* @cj-tech-master/excelts v6.2.0
+* @cj-tech-master/excelts v7.0.0
 * TypeScript Excel Workbook Manager - Read and Write xlsx and csv Files.
 * (c) 2026 cjnoname
 * Released under the MIT License
@@ -4546,7 +4546,7 @@ var ExcelTS = (function(exports) {
 	* @param cell       - A cell (or cell-like object) with `.value`, `.numFmt`, and `.text`
 	* @param dateFormat - Optional custom date format override
 	*/
-	function getCellDisplayText(cell, dateFormat) {
+	function getCellDisplayText$1(cell, dateFormat) {
 		const value = cell.value;
 		const numFmt = cell.numFmt;
 		const fmt = typeof numFmt === "string" ? numFmt : numFmt?.formatCode ?? "General";
@@ -9281,7 +9281,7 @@ var ExcelTS = (function(exports) {
 			const value = cell.value;
 			if (value && typeof value === "object" && "richText" in value) return measureRichTextWidthPx(value.richText, font);
 		}
-		const displayText = getCellDisplayText(cell);
+		const displayText = getCellDisplayText$1(cell);
 		if (!displayText) return 0;
 		return measureTextWidthPx(displayText, font);
 	}
@@ -9301,7 +9301,7 @@ var ExcelTS = (function(exports) {
 			const value = cell.value;
 			if (value && typeof value === "object" && "richText" in value) return calculateRichTextAutoFitHeight(value.richText, font, alignment, columnWidthPx);
 		}
-		const displayText = getCellDisplayText(cell);
+		const displayText = getCellDisplayText$1(cell);
 		if (!displayText) return 0;
 		return calculateAutoFitHeight(displayText, font, alignment, alignment?.wrapText ? columnWidthPx : void 0);
 	}
@@ -10367,7 +10367,7 @@ var ExcelTS = (function(exports) {
 					let isEmpty = true;
 					for (let col = startCol; col <= endCol; col++) {
 						const cell = this.getCell(row, col);
-						const val = o.raw === false ? getCellDisplayText(cell, o.dateFormat).trim() : cell.value;
+						const val = o.raw === false ? getCellDisplayText$1(cell, o.dateFormat).trim() : cell.value;
 						if (val != null && val !== "") {
 							rowData[col - startCol] = val;
 							isEmpty = false;
@@ -10386,7 +10386,7 @@ var ExcelTS = (function(exports) {
 					let isEmpty = true;
 					for (let col = startCol; col <= endCol; col++) {
 						const cell = this.getCell(row, col);
-						const val = o.raw === false ? getCellDisplayText(cell, o.dateFormat).trim() : cell.value;
+						const val = o.raw === false ? getCellDisplayText$1(cell, o.dateFormat).trim() : cell.value;
 						const key = encodeCol(col - 1);
 						if (val != null && val !== "") {
 							rowData[key] = val;
@@ -10407,7 +10407,7 @@ var ExcelTS = (function(exports) {
 						const colIdx = col - startCol;
 						const key = headerOpt[colIdx] ?? `__EMPTY_${colIdx}`;
 						const cell = this.getCell(row, col);
-						const val = o.raw === false ? getCellDisplayText(cell, o.dateFormat).trim() : cell.value;
+						const val = o.raw === false ? getCellDisplayText$1(cell, o.dateFormat).trim() : cell.value;
 						if (val != null && val !== "") {
 							rowData[key] = val;
 							isEmpty = false;
@@ -10436,7 +10436,7 @@ var ExcelTS = (function(exports) {
 				let isEmpty = true;
 				for (let col = startCol; col <= endCol; col++) {
 					const cell = this.getCell(row, col);
-					const val = o.raw === false ? getCellDisplayText(cell, o.dateFormat).trim() : cell.value;
+					const val = o.raw === false ? getCellDisplayText$1(cell, o.dateFormat).trim() : cell.value;
 					const key = headers[col - startCol];
 					if (val != null && val !== "") {
 						rowData[key] = val;
@@ -41222,7 +41222,7 @@ onmessage = async (ev) => {
 	* Normalize all input types to a unified format.
 	* Handles: objects, arrays, RowHashArray, and columns config.
 	*/
-	function normalizeInput(data, options, cfg) {
+	function normalizeInput$1(data, options, cfg) {
 		const { headers, columns } = options;
 		if (data.length === 0) {
 			if (columns && columns.length > 0) return {
@@ -41338,7 +41338,7 @@ onmessage = async (ev) => {
 	*/
 	function formatCsv(data, options = {}) {
 		const cfg = createFormatConfig(options);
-		const { displayHeaders, rows } = normalizeInput(data, options, cfg);
+		const { displayHeaders, rows } = normalizeInput$1(data, options, cfg);
 		const lines = [];
 		const effectiveHeaders = displayHeaders ? deduplicateHeaders(displayHeaders) : void 0;
 		if (effectiveHeaders && cfg.writeHeaders) lines.push(formatRowWithLookup(effectiveHeaders, cfg.regex, {
@@ -42137,6 +42137,59 @@ onmessage = async (ev) => {
 		return PaperSize;
 	}({});
 	//#endregion
+	//#region src/modules/pdf/types.ts
+	/**
+	* Type definitions for the PDF module.
+	* Covers input data models, export options, page layout, and internal rendering models.
+	*
+	* The input data models (PdfWorkbook, PdfSheetData, etc.) are fully independent of
+	* the Excel module, allowing the PDF engine to be used standalone.
+	*/
+	/**
+	* Cell value type discriminator for the PDF engine.
+	*/
+	const PdfCellType = {
+		Empty: 0,
+		String: 1,
+		Number: 2,
+		Boolean: 3,
+		Date: 4,
+		RichText: 5,
+		Error: 6,
+		Formula: 7,
+		Hyperlink: 8,
+		Merge: 9
+	};
+	/**
+	* Predefined page sizes.
+	*/
+	const PageSizes = {
+		A3: {
+			width: 841.89,
+			height: 1190.55
+		},
+		A4: {
+			width: 595.28,
+			height: 841.89
+		},
+		A5: {
+			width: 419.53,
+			height: 595.28
+		},
+		LETTER: {
+			width: 612,
+			height: 792
+		},
+		LEGAL: {
+			width: 612,
+			height: 1008
+		},
+		TABLOID: {
+			width: 792,
+			height: 1224
+		}
+	};
+	//#endregion
 	//#region src/modules/pdf/core/pdf-object.ts
 	/**
 	* Low-level PDF object primitives.
@@ -44658,8 +44711,8 @@ onmessage = async (ev) => {
 	//#endregion
 	//#region src/modules/pdf/render/style-converter.ts
 	/**
-	* Convert an Excel ARGB color string to PDF RGB color.
-	* Excel uses "AARRGGBB" format (e.g., "FF000000" for black).
+	* Convert an ARGB color string to PDF RGB color.
+	* Handles "AARRGGBB" (8-char) and "RRGGBB" (6-char) formats.
 	* PDF uses 0-1 floats for each component.
 	*/
 	function argbToPdfColor(argb) {
@@ -44689,7 +44742,7 @@ onmessage = async (ev) => {
 		};
 	}
 	/**
-	* Convert an Excel Color object to PDF color.
+	* Convert a color data object to PDF color.
 	* Handles both ARGB and theme-based colors.
 	*/
 	function excelColorToPdf(color) {
@@ -44705,7 +44758,7 @@ onmessage = async (ev) => {
 		return null;
 	}
 	/**
-	* Map Excel theme color indices to PDF colors.
+	* Map theme color indices to PDF colors.
 	* These are the default Office theme colors.
 	*/
 	function themeColorToPdf(themeIndex) {
@@ -44803,7 +44856,7 @@ onmessage = async (ev) => {
 		}
 	};
 	/**
-	* Extract font properties from an Excel font for PDF rendering.
+	* Extract font properties for PDF rendering.
 	*/
 	function extractFontProperties(font, defaultFamily, defaultSize) {
 		return {
@@ -44817,25 +44870,24 @@ onmessage = async (ev) => {
 		};
 	}
 	/**
-	* Convert an Excel fill to a PDF background color.
+	* Convert a fill to a PDF background color.
 	* Only pattern fills with "solid" pattern are supported as PDF backgrounds.
 	* Other patterns are approximated or ignored.
 	*/
 	function excelFillToPdfColor(fill) {
 		if (!fill) return null;
 		if (fill.type === "pattern") {
-			const patternFill = fill;
-			if (patternFill.pattern === "solid" && patternFill.fgColor) return excelColorToPdf(patternFill.fgColor);
-			if (patternFill.pattern === "none") return null;
-			if (patternFill.fgColor) return excelColorToPdf(patternFill.fgColor);
+			if (fill.pattern === "solid" && fill.fgColor) return excelColorToPdf(fill.fgColor);
+			if (fill.pattern === "none") return null;
+			if (fill.fgColor) return excelColorToPdf(fill.fgColor);
 		}
 		if (fill.type === "gradient") {
-			if ("stops" in fill && fill.stops.length > 0) return excelColorToPdf(fill.stops[0].color);
+			if (fill.stops && fill.stops.length > 0) return excelColorToPdf(fill.stops[0].color);
 		}
 		return null;
 	}
 	/**
-	* Map Excel border styles to PDF line widths and dash patterns.
+	* Map border styles to PDF line widths.
 	*/
 	function borderStyleToLineWidth(style) {
 		switch (style) {
@@ -44856,7 +44908,7 @@ onmessage = async (ev) => {
 		}
 	}
 	/**
-	* Map Excel border styles to PDF dash patterns.
+	* Map border styles to PDF dash patterns.
 	* An empty array means a solid line.
 	*/
 	function borderStyleToDashPattern(style) {
@@ -44891,7 +44943,7 @@ onmessage = async (ev) => {
 		}
 	}
 	/**
-	* Convert a single Excel border to a PDF LayoutBorder.
+	* Convert a single border side to a PDF LayoutBorder.
 	*/
 	function convertBorder(border) {
 		if (!border || !border.style) return null;
@@ -44902,7 +44954,7 @@ onmessage = async (ev) => {
 		};
 	}
 	/**
-	* Convert Excel Borders to PDF LayoutBorders.
+	* Convert border data to PDF LayoutBorders.
 	*/
 	function excelBordersToPdf(borders) {
 		if (!borders) return {
@@ -44919,7 +44971,7 @@ onmessage = async (ev) => {
 		};
 	}
 	/**
-	* Convert Excel horizontal alignment to PDF alignment.
+	* Convert horizontal alignment to PDF alignment.
 	*/
 	function excelHAlignToPdf(alignment) {
 		if (!alignment?.horizontal) return "left";
@@ -44931,7 +44983,7 @@ onmessage = async (ev) => {
 		}
 	}
 	/**
-	* Convert Excel vertical alignment to PDF alignment.
+	* Convert vertical alignment to PDF alignment.
 	*/
 	function excelVAlignToPdf(alignment) {
 		if (!alignment?.vertical) return "bottom";
@@ -44948,9 +45000,9 @@ onmessage = async (ev) => {
 	const DEFAULT_ROW_HEIGHT = 15;
 	const MIN_COLUMN_WIDTH = 5;
 	/**
-	* Compute the layout for a worksheet across one or more PDF pages.
+	* Compute the layout for a sheet across one or more PDF pages.
 	*/
-	function layoutWorksheet(worksheet, options, fontManager) {
+	function layoutSheet(sheet, options, fontManager) {
 		const { margins } = options;
 		let pageWidth = options.pageSize.width;
 		let pageHeight = options.pageSize.height;
@@ -44960,28 +45012,20 @@ onmessage = async (ev) => {
 		const headerHeight = options.showSheetNames ? 20 : 0;
 		const footerHeight = options.showPageNumbers ? 20 : 0;
 		const availableHeight = contentHeight - headerHeight - footerHeight;
-		const printRange = getPrintRange(worksheet);
-		const { columnWidths, visibleCols } = computeColumnWidths(worksheet, printRange);
-		if (visibleCols.length === 0) return [emptyPage(pageWidth, pageHeight, worksheet.name, options)];
-		let totalTableWidth = columnWidths.reduce((sum, w) => sum + w, 0);
+		const printRange = getPrintRange(sheet);
+		const { columnWidths, visibleCols } = computeColumnWidths(sheet, printRange);
+		if (visibleCols.length === 0) return [emptyPage(pageWidth, pageHeight, sheet.name, options)];
+		const totalTableWidth = columnWidths.reduce((sum, w) => sum + w, 0);
 		let scaleFactor = options.scale;
 		if (options.fitToPage && totalTableWidth > 0) {
 			const fitScale = contentWidth / totalTableWidth;
 			if (fitScale < 1) scaleFactor *= fitScale;
 		}
 		const scaledColumnWidths = columnWidths.map((w) => w * scaleFactor);
-		totalTableWidth = scaledColumnWidths.reduce((sum, w) => sum + w, 0);
-		const columnOffsets = [];
-		let xOffset = margins.left;
-		if (totalTableWidth < contentWidth) xOffset = margins.left + (contentWidth - totalTableWidth) / 2;
-		for (let i = 0; i < scaledColumnWidths.length; i++) {
-			columnOffsets.push(xOffset);
-			xOffset += scaledColumnWidths[i];
-		}
-		const { rowHeights, visibleRows } = computeRowHeights(worksheet, scaleFactor, printRange);
-		const mergeMap = buildMergeMap(worksheet);
-		const rowPages = paginateRows(rowHeights, availableHeight, typeof options.repeatRows === "number" ? options.repeatRows : 0, buildRowBreakSet(worksheet, visibleRows));
-		const colGroups = paginateColumns(scaledColumnWidths, contentWidth, worksheet, visibleCols);
+		const { rowHeights, visibleRows } = computeRowHeights(sheet, scaleFactor, printRange);
+		const mergeMap = buildMergeMap(sheet);
+		const rowPages = paginateRows(rowHeights, availableHeight, typeof options.repeatRows === "number" ? options.repeatRows : 0, buildRowBreakSet(sheet, visibleRows));
+		const colGroups = paginateColumns(scaledColumnWidths, contentWidth, sheet, visibleCols);
 		const layoutPages = [];
 		for (const rowPage of rowPages) for (const colGroup of colGroups) {
 			const cells = [];
@@ -45007,13 +45051,11 @@ onmessage = async (ev) => {
 				const visibleRowIdx = rowPage[ri];
 				const wsRowNumber = visibleRows[visibleRowIdx];
 				for (let gci = 0; gci < colGroup.length; gci++) {
-					const ci = colGroup[gci];
-					const wsColNumber = visibleCols[ci];
+					const wsColNumber = visibleCols[colGroup[gci]];
 					const mergeKey = `${wsRowNumber}:${wsColNumber}`;
 					const mergeInfo = mergeMap.get(mergeKey);
 					if (mergeInfo && !mergeInfo.isMaster) continue;
-					const row = worksheet.findRow(wsRowNumber);
-					const cell = row ? row.findCell(wsColNumber) : void 0;
+					const cell = sheet.rows.get(wsRowNumber)?.cells.get(wsColNumber);
 					let colSpan = 1;
 					let rowSpan = 1;
 					if (mergeInfo && mergeInfo.isMaster) {
@@ -45035,7 +45077,7 @@ onmessage = async (ev) => {
 					let cellHeight = 0;
 					for (let s = 0; s < rowSpan && ri + s < pageRowHeights.length; s++) cellHeight += pageRowHeights[ri + s];
 					const rectY = cellY - cellHeight;
-					cells.push(buildLayoutCell(cell, ci, visibleRowIdx, cellX, rectY, cellWidth, cellHeight, colSpan, rowSpan, options, fontManager, scaleFactor));
+					cells.push(buildLayoutCell(cell, cellX, rectY, cellWidth, cellHeight, colSpan, rowSpan, options, fontManager, scaleFactor));
 				}
 			}
 			layoutPages.push({
@@ -45044,17 +45086,17 @@ onmessage = async (ev) => {
 				cells,
 				width: pageWidth,
 				height: pageHeight,
-				sheetName: worksheet.name,
-				worksheetCols: colGroup.map((ci) => visibleCols[ci]),
+				sheetName: sheet.name,
+				sheetCols: colGroup.map((ci) => visibleCols[ci]),
 				columnOffsets: groupColOffsets,
 				columnWidths: groupColWidths,
-				worksheetRows: rowPage.map((ri) => visibleRows[ri]),
+				sheetRows: rowPage.map((ri) => visibleRows[ri]),
 				rowYPositions,
 				rowHeights: pageRowHeights,
 				images: []
 			});
 		}
-		if (layoutPages.length > 0) assignImagesToPages(worksheet, layoutPages);
+		if (layoutPages.length > 0 && sheet.images) assignImagesToPages(sheet.images, layoutPages);
 		return layoutPages;
 	}
 	function emptyPage(width, height, sheetName, options) {
@@ -45065,26 +45107,60 @@ onmessage = async (ev) => {
 			width,
 			height,
 			sheetName,
-			worksheetCols: [],
+			sheetCols: [],
 			columnOffsets: [],
 			columnWidths: [],
-			worksheetRows: [],
+			sheetRows: [],
 			rowYPositions: [],
 			rowHeights: [],
 			images: []
 		};
 	}
 	/**
-	* Get the print area range from the worksheet's pageSetup.
+	* Parse a cell reference like "A1" into 0-indexed { c, r }.
+	*/
+	function parseCellRef(ref) {
+		const upper = ref.replace(/\$/g, "").toUpperCase();
+		let col = 0;
+		let i = 0;
+		while (i < upper.length && upper.charCodeAt(i) >= 65 && upper.charCodeAt(i) <= 90) {
+			col = col * 26 + (upper.charCodeAt(i) - 64);
+			i++;
+		}
+		const row = parseInt(upper.substring(i), 10);
+		return {
+			c: col - 1,
+			r: row - 1
+		};
+	}
+	/**
+	* Parse a range string like "A1:B2" into 0-indexed start/end.
+	*/
+	function parseRangeRef(range) {
+		const idx = range.indexOf(":");
+		if (idx === -1) {
+			const cell = parseCellRef(range);
+			return {
+				s: cell,
+				e: { ...cell }
+			};
+		}
+		return {
+			s: parseCellRef(range.slice(0, idx)),
+			e: parseCellRef(range.slice(idx + 1))
+		};
+	}
+	/**
+	* Get the print area range from the sheet's pageSetup.
 	* Returns null if no print area is set.
 	*/
-	function getPrintRange(worksheet) {
-		const printArea = worksheet.pageSetup?.printArea;
+	function getPrintRange(sheet) {
+		const printArea = sheet.pageSetup?.printArea;
 		if (!printArea || typeof printArea !== "string") return null;
 		const firstRange = printArea.split("&&")[0].trim();
 		if (!firstRange) return null;
 		try {
-			const range = decodeRange(firstRange);
+			const range = parseRangeRef(firstRange);
 			return {
 				startRow: range.s.r + 1,
 				endRow: range.e.r + 1,
@@ -45095,20 +45171,20 @@ onmessage = async (ev) => {
 			return null;
 		}
 	}
-	function computeColumnWidths(worksheet, printRange) {
-		const dimensions = worksheet.dimensions;
-		if (!(dimensions && dimensions.model.top > 0 && dimensions.model.left > 0)) return {
+	function computeColumnWidths(sheet, printRange) {
+		const bounds = sheet.bounds;
+		if (!(bounds.top > 0 && bounds.left > 0)) return {
 			columnWidths: [],
 			visibleCols: []
 		};
-		const startCol = printRange?.startCol ?? dimensions.model.left;
-		const endCol = printRange?.endCol ?? dimensions.model.right;
+		const startCol = printRange?.startCol ?? bounds.left;
+		const endCol = printRange?.endCol ?? bounds.right;
 		const columnWidths = [];
 		const visibleCols = [];
 		for (let c = startCol; c <= endCol; c++) {
-			const col = worksheet.getColumn(c);
-			if (col.hidden) continue;
-			const excelWidth = col.width ?? DEFAULT_COLUMN_WIDTH;
+			const col = sheet.columns.get(c);
+			if (col?.hidden) continue;
+			const excelWidth = col?.width ?? DEFAULT_COLUMN_WIDTH;
 			const pointWidth = Math.max(excelWidth * EXCEL_CHAR_WIDTH_TO_POINTS, MIN_COLUMN_WIDTH);
 			columnWidths.push(pointWidth);
 			visibleCols.push(c);
@@ -45118,24 +45194,24 @@ onmessage = async (ev) => {
 			visibleCols
 		};
 	}
-	function computeRowHeights(worksheet, scaleFactor, printRange) {
-		const dimensions = worksheet.dimensions;
-		if (!dimensions || dimensions.model.top <= 0) return {
+	function computeRowHeights(sheet, scaleFactor, printRange) {
+		const bounds = sheet.bounds;
+		if (bounds.top <= 0) return {
 			rowHeights: [],
 			visibleRows: []
 		};
-		const startRow = printRange?.startRow ?? dimensions.model.top;
-		const endRow = printRange?.endRow ?? dimensions.model.bottom;
+		const startRow = printRange?.startRow ?? bounds.top;
+		const endRow = printRange?.endRow ?? bounds.bottom;
 		const rowHeights = [];
 		const visibleRows = [];
 		for (let r = startRow; r <= endRow; r++) {
-			const row = worksheet.findRow(r);
+			const row = sheet.rows.get(r);
 			if (row && row.hidden) continue;
 			let height;
 			if (row?.height) height = row.height;
 			else {
 				height = DEFAULT_ROW_HEIGHT;
-				if (row) row.eachCell({ includeEmpty: false }, (cell) => {
+				if (row) for (const cell of row.cells.values()) {
 					let fontSize = cell.style?.font?.size ?? 11;
 					const rtValue = cell.value;
 					if (rtValue?.richText) for (const run of rtValue.richText) {
@@ -45146,15 +45222,15 @@ onmessage = async (ev) => {
 					const text = cell.text ?? "";
 					const lineCount = Math.max(1, (text.match(/\n/g) ?? []).length + 1);
 					let wrapLineCount = lineCount;
-					if (cell.alignment?.wrapText && lineCount === 1 && text.length > 0) {
-						const colPts = (worksheet.getColumn(cell.col).width ?? DEFAULT_COLUMN_WIDTH) * EXCEL_CHAR_WIDTH_TO_POINTS * scaleFactor;
+					if (cell.style?.alignment?.wrapText && lineCount === 1 && text.length > 0) {
+						const colPts = (sheet.columns.get(cell.col)?.width ?? DEFAULT_COLUMN_WIDTH) * EXCEL_CHAR_WIDTH_TO_POINTS * scaleFactor;
 						const avgCharWidth = fontSize * .55;
 						const charsPerLine = Math.max(1, Math.floor(colPts / avgCharWidth));
 						wrapLineCount = Math.ceil(text.length / charsPerLine);
 					}
 					const neededHeight = lineHeight * wrapLineCount;
 					if (neededHeight > height) height = neededHeight;
-				});
+				}
 			}
 			rowHeights.push(height * scaleFactor);
 			visibleRows.push(r);
@@ -45167,30 +45243,28 @@ onmessage = async (ev) => {
 	/**
 	* Build a set of visible-row indices where manual page breaks occur.
 	*/
-	function buildRowBreakSet(worksheet, visibleRows) {
+	function buildRowBreakSet(sheet, visibleRows) {
 		const breaks = /* @__PURE__ */ new Set();
-		const rowBreaks = worksheet.rowBreaks ?? [];
+		const rowBreaks = sheet.rowBreaks ?? [];
 		if (rowBreaks.length === 0) return breaks;
 		const rowToIndex = /* @__PURE__ */ new Map();
 		for (let i = 0; i < visibleRows.length; i++) rowToIndex.set(visibleRows[i], i);
 		for (const brk of rowBreaks) {
-			const idx = rowToIndex.get(brk.id);
+			const idx = rowToIndex.get(brk);
 			if (idx !== void 0) breaks.add(idx + 1);
 		}
 		return breaks;
 	}
 	/**
-	* Build a map of all merged cell regions in the worksheet.
-	* Uses the worksheet model's public mergeCells property.
+	* Build a map of all merged cell regions.
 	* Key: "row:col" (1-based), Value: merge info
 	*/
-	function buildMergeMap(worksheet) {
+	function buildMergeMap(sheet) {
 		const map = /* @__PURE__ */ new Map();
-		if (!worksheet.hasMerges) return map;
-		const mergeCells = worksheet.model.mergeCells;
-		if (!mergeCells) return map;
-		for (const rangeStr of mergeCells) {
-			const range = decodeRange(rangeStr);
+		const merges = sheet.merges;
+		if (!merges || merges.length === 0) return map;
+		for (const rangeStr of merges) {
+			const range = parseRangeRef(rangeStr);
 			const top = range.s.r + 1;
 			const left = range.s.c + 1;
 			const bottom = range.e.r + 1;
@@ -45257,18 +45331,16 @@ onmessage = async (ev) => {
 	}
 	/**
 	* Split columns into groups for horizontal pagination.
-	* Each group is an array of column indices (into the visibleCols/scaledColumnWidths arrays).
-	* If the total width fits in contentWidth and there are no colBreaks, returns a single group.
 	*/
-	function paginateColumns(columnWidths, contentWidth, worksheet, visibleCols) {
+	function paginateColumns(columnWidths, contentWidth, sheet, visibleCols) {
 		if (columnWidths.length === 0) return [[]];
 		const colBreaks = /* @__PURE__ */ new Set();
-		const wsColBreaks = worksheet.colBreaks ?? [];
+		const wsColBreaks = sheet.colBreaks ?? [];
 		if (wsColBreaks.length > 0) {
 			const colToIndex = /* @__PURE__ */ new Map();
 			for (let i = 0; i < visibleCols.length; i++) colToIndex.set(visibleCols[i], i);
 			for (const brk of wsColBreaks) {
-				const idx = colToIndex.get(brk.id);
+				const idx = colToIndex.get(brk);
 				if (idx !== void 0) colBreaks.add(idx + 1);
 			}
 		}
@@ -45288,8 +45360,8 @@ onmessage = async (ev) => {
 		if (currentGroup.length > 0) groups.push(currentGroup);
 		return groups.length > 0 ? groups : [Array.from({ length: columnWidths.length }, (_, i) => i)];
 	}
-	function buildLayoutCell(cell, _colIndex, _rowIndex, x, y, width, height, colSpan, rowSpan, options, fontManager, scaleFactor) {
-		const text = getCellText(cell);
+	function buildLayoutCell(cell, x, y, width, height, colSpan, rowSpan, options, fontManager, scaleFactor) {
+		const text = cell?.text ?? "";
 		const style = cell?.style ?? {};
 		const fontProps = extractFontProperties(style.font, options.defaultFontFamily, options.defaultFontSize);
 		const scaledFontSize = fontProps.fontSize * scaleFactor;
@@ -45328,32 +45400,17 @@ onmessage = async (ev) => {
 		};
 	}
 	/**
-	* Collect images from a worksheet and assign them to the page that contains
-	* their top-left anchor.
+	* Assign pre-collected images to the pages that contain their top-left anchor.
 	*/
-	function assignImagesToPages(worksheet, layoutPages) {
-		const wsImages = worksheet.getImages?.();
-		if (!wsImages || !Array.isArray(wsImages)) return;
-		const workbook = worksheet.workbook;
-		if (!workbook) return;
-		for (const wsImage of wsImages) {
-			if (!wsImage.range?.tl) continue;
-			const imageId = wsImage.imageId;
-			const mediaItem = workbook.getImage?.(Number(imageId));
-			if (!mediaItem) continue;
-			let data;
-			if (mediaItem.buffer instanceof Uint8Array) data = mediaItem.buffer;
-			else if (mediaItem.base64) data = base64ToUint8Array(mediaItem.base64);
-			if (!data || data.length === 0) continue;
-			const format = mediaItem.extension;
-			if (format !== "jpeg" && format !== "png") continue;
-			const tl = wsImage.range.tl;
+	function assignImagesToPages(images, layoutPages) {
+		for (const img of images) {
+			const tl = img.range.tl;
 			const tlCol = (tl.nativeCol ?? tl.col ?? 0) + 1;
 			const tlRow = (tl.nativeRow ?? tl.row ?? 0) + 1;
-			const targetPage = layoutPages.find((page) => page.worksheetCols.includes(tlCol) && page.worksheetRows.includes(tlRow));
+			const targetPage = layoutPages.find((page) => page.sheetCols.includes(tlCol) && page.sheetRows.includes(tlRow));
 			if (!targetPage) continue;
-			const pageColIndex = targetPage.worksheetCols.indexOf(tlCol);
-			const pageRowIndex = targetPage.worksheetRows.indexOf(tlRow);
+			const pageColIndex = targetPage.sheetCols.indexOf(tlCol);
+			const pageRowIndex = targetPage.sheetRows.indexOf(tlRow);
 			const baseX = targetPage.columnOffsets[pageColIndex] ?? targetPage.options.margins.left;
 			const baseY = targetPage.rowYPositions[pageRowIndex] ?? targetPage.height - targetPage.options.margins.top - (targetPage.options.showSheetNames ? 20 : 0);
 			const tlColOff = (tl.nativeColOff ?? 0) / 12700 || 0;
@@ -45362,15 +45419,15 @@ onmessage = async (ev) => {
 			const imgY = baseY - tlRowOff;
 			let imgWidth = 100;
 			let imgHeight = 100;
-			if (wsImage.range.ext) {
-				imgWidth = (wsImage.range.ext.width ?? 100) * .75;
-				imgHeight = (wsImage.range.ext.height ?? 100) * .75;
-			} else if (wsImage.range.br) {
-				const br = wsImage.range.br;
+			if (img.range.ext) {
+				imgWidth = (img.range.ext.width ?? 100) * .75;
+				imgHeight = (img.range.ext.height ?? 100) * .75;
+			} else if (img.range.br) {
+				const br = img.range.br;
 				const brCol = (br.nativeCol ?? br.col ?? 0) + 1;
 				const brRow = (br.nativeRow ?? br.row ?? 0) + 1;
-				const brPageColIndex = targetPage.worksheetCols.indexOf(brCol);
-				const brPageRowIndex = targetPage.worksheetRows.indexOf(brRow);
+				const brPageColIndex = targetPage.sheetCols.indexOf(brCol);
+				const brPageRowIndex = targetPage.sheetRows.indexOf(brRow);
 				const brBaseX = brPageColIndex >= 0 ? targetPage.columnOffsets[brPageColIndex] : imgX + (targetPage.columnWidths[pageColIndex] ?? 100);
 				const brBaseY = brPageRowIndex >= 0 ? targetPage.rowYPositions[brPageRowIndex] : imgY - (targetPage.rowHeights[pageRowIndex] ?? 100);
 				const brColOff = (br.nativeColOff ?? 0) / 12700 || 0;
@@ -45381,8 +45438,8 @@ onmessage = async (ev) => {
 				imgHeight = imgY - brY;
 			}
 			targetPage.images.push({
-				data,
-				format,
+				data: img.data,
+				format: img.format,
 				rect: {
 					x: imgX,
 					y: imgY - imgHeight,
@@ -45393,49 +45450,11 @@ onmessage = async (ev) => {
 		}
 	}
 	/**
-	* Extract display text from a cell, applying numFmt formatting.
-	*/
-	function getCellText(cell) {
-		if (!cell) return "";
-		switch (cell.type) {
-			case ValueType.Null:
-			case ValueType.Merge: return "";
-			case ValueType.RichText: return cell.text;
-			case ValueType.Hyperlink: return cell.text;
-			case ValueType.Error: return cell.value?.error ?? cell.text;
-			case ValueType.Formula: {
-				const result = cell.result;
-				if (result !== void 0 && result !== null) {
-					if (typeof result === "object" && "error" in result) return result.error;
-					return formatCellValueSafe(result, cell.style?.numFmt);
-				}
-				return cell.text;
-			}
-			default: {
-				const value = cell.value;
-				if (value === null || value === void 0) return "";
-				return formatCellValueSafe(value, cell.style?.numFmt);
-			}
-		}
-	}
-	/**
-	* Safely format a cell value using its numFmt.
-	* Falls back to toString if formatting fails or no format is specified.
-	*/
-	function formatCellValueSafe(value, numFmt) {
-		const fmt = typeof numFmt === "string" ? numFmt : numFmt?.formatCode;
-		if (fmt && (typeof value === "number" || value instanceof Date || typeof value === "boolean")) try {
-			return formatCellValue(value, fmt);
-		} catch {}
-		if (value instanceof Date) return value.toLocaleDateString();
-		return String(value);
-	}
-	/**
 	* Build rich text runs from a RichText cell.
 	* Returns null for non-RichText cells.
 	*/
 	function buildRichTextRuns(cell, options, fontManager, scaleFactor) {
-		if (!cell || cell.type !== ValueType.RichText) return null;
+		if (!cell || cell.type !== PdfCellType.RichText) return null;
 		const rtValue = cell.value;
 		if (!rtValue?.richText || rtValue.richText.length === 0) return null;
 		return rtValue.richText.map((run) => {
@@ -46508,54 +46527,27 @@ onmessage = async (ev) => {
 		};
 	}
 	//#endregion
-	//#region src/modules/pdf/types.ts
+	//#region src/modules/pdf/render/pdf-exporter.ts
 	/**
-	* Predefined page sizes.
+	* PDF Exporter - Main orchestrator for PDF document generation.
+	*
+	* Coordinates the layout engine, page renderer, font manager, and PDF writer
+	* to produce a complete PDF document from a PdfWorkbook data structure.
+	*
+	* This module is fully independent of the Excel module.
+	* It is used internally by the public `pdf()` and `excelToPdf()` APIs.
 	*/
-	const PageSizes = {
-		A3: {
-			width: 841.89,
-			height: 1190.55
-		},
-		A4: {
-			width: 595.28,
-			height: 841.89
-		},
-		A5: {
-			width: 419.53,
-			height: 595.28
-		},
-		LETTER: {
-			width: 612,
-			height: 792
-		},
-		LEGAL: {
-			width: 612,
-			height: 1008
-		},
-		TABLOID: {
-			width: 792,
-			height: 1224
-		}
-	};
-	//#endregion
-	//#region src/modules/pdf/render/pdf-exporter.ts
 	/**
-	* Export a workbook to PDF format.
+	* Export a PdfWorkbook to PDF format.
 	*
-	* @param workbook - The workbook to export
+	* @param workbook - The workbook data to export
 	* @param options - Export options controlling layout, pagination, and appearance
 	* @returns PDF file as a Uint8Array
-	* @throws {PdfError} If the workbook has no worksheets or export fails
-	*
-	* @example
-	* ```typescript
-	* const pdf = exportPdf(workbook, { fitToPage: true, showGridLines: true });
-	* ```
+	* @throws {PdfError} If the workbook has no sheets or export fails
 	*/
 	function exportPdf(workbook, options) {
-		const worksheets = selectWorksheets(workbook, options?.sheets);
-		if (worksheets.length === 0) throw new PdfError("No worksheets to export. The workbook is empty or no sheets matched.");
+		const sheets = selectSheets(workbook, options?.sheets);
+		if (sheets.length === 0) throw new PdfError("No sheets to export. The workbook is empty or no sheets matched.");
 		const fontManager = new FontManager();
 		const writer = new PdfWriter();
 		if (options?.font) try {
@@ -46565,24 +46557,24 @@ onmessage = async (ev) => {
 			throw new PdfRenderError("Failed to parse TrueType font", { cause: err });
 		}
 		const allPages = [];
-		for (const worksheet of worksheets) try {
-			const pages = layoutWorksheet(worksheet, resolveOptions(options, worksheet), fontManager);
+		for (const sheet of sheets) try {
+			const pages = layoutSheet(sheet, resolveOptions(options, sheet), fontManager);
 			allPages.push(...pages);
 		} catch (err) {
-			throw new PdfRenderError(`Failed to layout worksheet "${worksheet.name}"`, { cause: err });
+			throw new PdfRenderError(`Failed to layout sheet "${sheet.name}"`, { cause: err });
 		}
-		const documentOptions = resolveOptions(options, worksheets[0]);
+		const documentOptions = resolveOptions(options, sheets[0]);
 		if (allPages.length === 0) allPages.push({
 			pageNumber: 1,
 			options: documentOptions,
 			cells: [],
 			width: documentOptions.pageSize.width,
 			height: documentOptions.pageSize.height,
-			sheetName: worksheets[0]?.name ?? "Sheet1",
-			worksheetCols: [],
+			sheetName: sheets[0]?.name ?? "Sheet1",
+			sheetCols: [],
 			columnOffsets: [],
 			columnWidths: [],
-			worksheetRows: [],
+			sheetRows: [],
 			rowYPositions: [],
 			rowHeights: [],
 			images: []
@@ -46674,34 +46666,10 @@ onmessage = async (ev) => {
 		return writer.build();
 	}
 	/**
-	* Class-based API for PDF export (wraps {@link exportPdf}).
-	*
-	* @example
-	* ```typescript
-	* const exporter = new PdfExporter(workbook);
-	* const pdfBuffer = exporter.export({ fitToPage: true });
-	* ```
+	* Select which sheets to export based on the options.
 	*/
-	var PdfExporter = class {
-		constructor(workbook) {
-			this.workbook = workbook;
-		}
-		/**
-		* Export the workbook as a PDF document.
-		*
-		* @param options - Export options controlling layout, pagination, and appearance
-		* @returns PDF file as a Uint8Array
-		* @throws {PdfError} If the workbook has no worksheets or export fails
-		*/
-		export(options) {
-			return exportPdf(this.workbook, options);
-		}
-	};
-	/**
-	* Select which worksheets to export based on the options.
-	*/
-	function selectWorksheets(workbook, sheets) {
-		const allSheets = workbook.worksheets;
+	function selectSheets(workbook, sheets) {
+		const allSheets = workbook.sheets;
 		if (!sheets || sheets.length === 0) return allSheets.filter((ws) => ws.state !== "hidden" && ws.state !== "veryHidden");
 		const result = [];
 		for (const selector of sheets) if (typeof selector === "string") {
@@ -46716,8 +46684,8 @@ onmessage = async (ev) => {
 	/**
 	* Resolve user options with defaults.
 	*/
-	function resolveOptions(options, worksheet) {
-		const ps = worksheet?.pageSetup;
+	function resolveOptions(options, sheet) {
+		const ps = sheet?.pageSetup;
 		const pageSize = resolvePageSize(options?.pageSize, ps?.paperSize);
 		const orientation = options?.orientation ?? (ps?.orientation === "landscape" ? "landscape" : "portrait");
 		const margins = resolveMargins(options?.margins, ps?.margins);
@@ -46750,10 +46718,7 @@ onmessage = async (ev) => {
 			creator: options?.creator ?? "excelts"
 		};
 	}
-	/**
-	* Resolve the page size from options.
-	*/
-	/** Map Excel PaperSize enum values to PDF page sizes. */
+	/** Map PaperSize enum values to PDF page sizes. */
 	const PAPER_SIZE_MAP = {
 		1: PageSizes.LETTER,
 		5: PageSizes.LEGAL,
@@ -46771,8 +46736,8 @@ onmessage = async (ev) => {
 		return PageSizes.A4;
 	}
 	/**
-	* Resolve margins with defaults. Worksheet margins are in inches, convert to points (×72).
-	* When partial PDF margins are specified, unset sides fall back to worksheet margins,
+	* Resolve margins with defaults. Sheet margins are in inches, convert to points (×72).
+	* When partial PDF margins are specified, unset sides fall back to sheet margins,
 	* then to the default 72pt (1 inch).
 	*/
 	function resolveMargins(margins, wsMargins) {
@@ -46797,7 +46762,7 @@ onmessage = async (ev) => {
 	}
 	/**
 	* Build a PDF outlines tree for sheet-level navigation.
-	* Creates one bookmark entry per worksheet, pointing to the first page.
+	* Creates one bookmark entry per sheet, pointing to the first page.
 	*/
 	function buildOutlines(writer, sheetFirstPage, pageObjNums) {
 		const outlinesObjNum = writer.allocObject();
@@ -46881,6 +46846,518 @@ onmessage = async (ev) => {
 		};
 	}
 	//#endregion
+	//#region src/modules/pdf/pdf.ts
+	/**
+	* Simplified PDF generation API.
+	*
+	* Provides a concise way to create PDFs from plain data — no need to manually
+	* construct Map objects, compute bounds, or specify cell types.
+	*
+	* @example Simplest — pass a 2D array:
+	* ```typescript
+	* import { pdf } from "@cj-tech-master/excelts/pdf";
+	*
+	* const bytes = pdf([
+	*   ["Product", "Revenue"],
+	*   ["Widget", 1000],
+	*   ["Gadget", 2500]
+	* ]);
+	* ```
+	*
+	* @example With options:
+	* ```typescript
+	* const bytes = pdf([
+	*   ["Name", "Score"],
+	*   ["Alice", 95],
+	*   ["Bob", 87]
+	* ], { showGridLines: true, title: "Scores" });
+	* ```
+	*
+	* @example Multiple sheets:
+	* ```typescript
+	* const bytes = pdf({
+	*   sheets: [
+	*     { name: "Sales", data: [["Product", "Revenue"], ["Widget", 1000]] },
+	*     { name: "Costs", data: [["Item", "Amount"], ["Rent", 500]] }
+	*   ]
+	* });
+	* ```
+	*
+	* @example With column widths and styles:
+	* ```typescript
+	* const bytes = pdf({
+	*   name: "Report",
+	*   columns: [{ width: 25 }, { width: 15 }],
+	*   data: [
+	*     ["Product", "Revenue"],
+	*     ["Widget", "$1,000"]
+	*   ]
+	* });
+	* ```
+	*/
+	/**
+	* Generate a PDF.
+	*
+	* Accepts anything from a plain 2D array to a multi-sheet workbook.
+	*
+	* @param input   - 2D array, sheet object, or workbook object
+	* @param options - PDF export options (page size, margins, etc.)
+	* @returns PDF file as Uint8Array
+	*/
+	function pdf(input, options) {
+		return exportPdf(normalizeInput(input), options);
+	}
+	function normalizeInput(input) {
+		if (Array.isArray(input)) return { sheets: [normalizeSheet({ data: input })] };
+		if ("sheets" in input) return {
+			title: input.title,
+			creator: input.author,
+			sheets: input.sheets.map((s, i) => normalizeSheet(s, i))
+		};
+		return { sheets: [normalizeSheet(input)] };
+	}
+	function normalizeSheet(sheet, index) {
+		const data = sheet.data;
+		const sheetName = sheet.name ?? `Sheet${(index ?? 0) + 1}`;
+		const columnHeaders = sheet.columns?.map((c) => typeof c === "number" ? void 0 : c.header);
+		const hasHeaders = columnHeaders?.some((h) => h !== void 0) ?? false;
+		let maxCols = 0;
+		for (const row of data) if (row.length > maxCols) maxCols = row.length;
+		let colCount = Math.max(maxCols, sheet.columns?.length ?? 0);
+		let totalRows = data.length + (hasHeaders ? 1 : 0);
+		if (sheet.images) for (const img of sheet.images) {
+			const imgCol = img.col + 1;
+			const imgRow = img.row + 1;
+			if (imgCol > colCount) colCount = imgCol;
+			if (imgRow > totalRows) totalRows = imgRow;
+		}
+		if (colCount === 0) return {
+			name: sheetName,
+			bounds: {
+				top: 0,
+				left: 0,
+				bottom: 0,
+				right: 0
+			},
+			columns: /* @__PURE__ */ new Map(),
+			rows: /* @__PURE__ */ new Map()
+		};
+		const columns = /* @__PURE__ */ new Map();
+		if (sheet.columns) for (let i = 0; i < sheet.columns.length; i++) {
+			const col = sheet.columns[i];
+			const width = typeof col === "number" ? col : col.width;
+			columns.set(i + 1, { width: width ?? 12 });
+		}
+		for (let c = 1; c <= colCount; c++) if (!columns.has(c)) columns.set(c, { width: 12 });
+		const rows = /* @__PURE__ */ new Map();
+		let rowOffset = 1;
+		if (hasHeaders && columnHeaders) {
+			const cells = /* @__PURE__ */ new Map();
+			for (let c = 0; c < columnHeaders.length; c++) {
+				const text = columnHeaders[c];
+				if (text === void 0) continue;
+				cells.set(c + 1, {
+					type: PdfCellType.String,
+					value: text,
+					text,
+					col: c + 1,
+					style: { font: { bold: true } }
+				});
+			}
+			rows.set(1, { cells });
+			rowOffset = 2;
+		}
+		for (let r = 0; r < data.length; r++) {
+			const rowNum = r + rowOffset;
+			const row = data[r];
+			const cells = /* @__PURE__ */ new Map();
+			for (let c = 0; c < row.length; c++) {
+				const cell = normalizeCell(row[c], c + 1);
+				if (cell) cells.set(c + 1, cell);
+			}
+			rows.set(rowNum, { cells });
+		}
+		let images;
+		if (sheet.images && sheet.images.length > 0) {
+			images = sheet.images.map((img) => ({
+				data: img.data,
+				format: img.format,
+				range: {
+					tl: {
+						col: img.col,
+						row: img.row
+					},
+					ext: {
+						width: img.width,
+						height: img.height
+					}
+				}
+			}));
+			for (let c = 1; c <= colCount; c++) if (!columns.has(c)) columns.set(c, { width: 12 });
+			for (let r = 1; r <= totalRows; r++) if (!rows.has(r)) rows.set(r, { cells: /* @__PURE__ */ new Map() });
+		}
+		return {
+			name: sheetName,
+			bounds: {
+				top: 1,
+				left: 1,
+				bottom: totalRows,
+				right: colCount
+			},
+			columns,
+			rows,
+			images
+		};
+	}
+	function normalizeCell(value, col) {
+		if (value === null || value === void 0) return null;
+		if (typeof value === "object" && !(value instanceof Date) && "value" in value) {
+			const cell = value;
+			const inner = normalizeCell(cell.value, col);
+			if (!inner) return null;
+			const style = {};
+			if (cell.bold || cell.italic || cell.fontSize || cell.fontColor) style.font = {
+				bold: cell.bold,
+				italic: cell.italic,
+				size: cell.fontSize,
+				color: cell.fontColor ? { argb: cell.fontColor } : void 0
+			};
+			if (cell.fillColor) style.fill = {
+				type: "pattern",
+				pattern: "solid",
+				fgColor: { argb: cell.fillColor }
+			};
+			if (cell.align) style.alignment = { horizontal: cell.align };
+			inner.style = style;
+			return inner;
+		}
+		if (typeof value === "string") return {
+			type: PdfCellType.String,
+			value,
+			text: value,
+			col
+		};
+		if (typeof value === "number") return {
+			type: PdfCellType.Number,
+			value,
+			text: String(value),
+			col
+		};
+		if (typeof value === "boolean") return {
+			type: PdfCellType.Boolean,
+			value,
+			text: value ? "TRUE" : "FALSE",
+			col
+		};
+		if (value instanceof Date) return {
+			type: PdfCellType.Date,
+			value,
+			text: value.toLocaleDateString(),
+			col
+		};
+		return null;
+	}
+	//#endregion
+	//#region src/modules/pdf/excel-bridge.ts
+	/**
+	* Export an Excel Workbook directly to PDF.
+	*
+	* This is a convenience function that converts the Workbook to the PDF module's
+	* data model and then generates the PDF.
+	*
+	* @param workbook - An Excel Workbook instance
+	* @param options  - PDF export options
+	* @returns PDF file as a Uint8Array
+	*/
+	function excelToPdf(workbook, options) {
+		return exportPdf(excelWorkbookToPdf(workbook), options);
+	}
+	/**
+	* Convert an Excel Workbook to the internal PdfWorkbook data structure.
+	*/
+	function excelWorkbookToPdf(workbook) {
+		return {
+			title: workbook.title || void 0,
+			creator: workbook.creator || void 0,
+			subject: workbook.subject || void 0,
+			sheets: workbook.worksheets.map((ws) => convertSheet(ws, workbook))
+		};
+	}
+	function convertSheet(ws, workbook) {
+		const dimensions = ws.dimensions;
+		const hasData = dimensions && dimensions.model.top > 0 && dimensions.model.left > 0;
+		const bounds = hasData ? {
+			top: dimensions.model.top,
+			left: dimensions.model.left,
+			bottom: dimensions.model.bottom,
+			right: dimensions.model.right
+		} : {
+			top: 0,
+			left: 0,
+			bottom: 0,
+			right: 0
+		};
+		const columns = /* @__PURE__ */ new Map();
+		if (hasData) for (let c = bounds.left; c <= bounds.right; c++) {
+			const col = ws.getColumn(c);
+			columns.set(c, {
+				hidden: col.hidden || void 0,
+				width: col.width ?? void 0
+			});
+		}
+		const rows = /* @__PURE__ */ new Map();
+		if (hasData) for (let r = bounds.top; r <= bounds.bottom; r++) {
+			const row = ws.findRow(r);
+			if (!row) continue;
+			const cells = /* @__PURE__ */ new Map();
+			row.eachCell({ includeEmpty: false }, (cell) => {
+				cells.set(cell.col, convertCell(cell));
+			});
+			rows.set(r, {
+				hidden: row.hidden || void 0,
+				height: row.height ?? void 0,
+				cells
+			});
+		}
+		const merges = ws.hasMerges && ws.model.mergeCells ? [...ws.model.mergeCells] : void 0;
+		const ps = ws.pageSetup;
+		const pageSetup = ps ? {
+			orientation: ps.orientation,
+			paperSize: ps.paperSize,
+			margins: ps.margins ? {
+				left: ps.margins.left,
+				right: ps.margins.right,
+				top: ps.margins.top,
+				bottom: ps.margins.bottom
+			} : void 0,
+			scale: ps.scale,
+			printTitlesRow: ps.printTitlesRow,
+			showGridLines: ps.showGridLines,
+			printArea: ps.printArea
+		} : void 0;
+		const rowBreaks = ws.rowBreaks?.map((b) => b.id);
+		const colBreaks = ws.colBreaks?.map((b) => b.id);
+		const images = collectImages(ws, workbook);
+		if (images) {
+			for (const img of images) {
+				const tl = img.range.tl;
+				const tlCol = (tl.nativeCol ?? tl.col ?? 0) + 1;
+				const tlRow = (tl.nativeRow ?? tl.row ?? 0) + 1;
+				if (bounds.top === 0 && bounds.left === 0) {
+					bounds.top = 1;
+					bounds.left = 1;
+				}
+				if (tlCol > bounds.right) bounds.right = tlCol;
+				if (tlRow > bounds.bottom) bounds.bottom = tlRow;
+				if (img.range.br) {
+					const br = img.range.br;
+					const brCol = (br.nativeCol ?? br.col ?? 0) + 1;
+					const brRow = (br.nativeRow ?? br.row ?? 0) + 1;
+					if (brCol > bounds.right) bounds.right = brCol;
+					if (brRow > bounds.bottom) bounds.bottom = brRow;
+				}
+			}
+			for (let c = bounds.left; c <= bounds.right; c++) if (!columns.has(c)) {
+				const col = ws.getColumn(c);
+				columns.set(c, {
+					hidden: col.hidden || void 0,
+					width: col.width ?? void 0
+				});
+			}
+			for (let r = bounds.top; r <= bounds.bottom; r++) if (!rows.has(r)) rows.set(r, { cells: /* @__PURE__ */ new Map() });
+		}
+		return {
+			name: ws.name,
+			state: ws.state ?? "visible",
+			bounds,
+			columns,
+			rows,
+			merges,
+			pageSetup,
+			rowBreaks,
+			colBreaks,
+			images
+		};
+	}
+	function convertCell(cell) {
+		const type = mapValueType(cell.type);
+		const text = getCellDisplayText(cell);
+		const style = convertCellStyle(cell.style);
+		return {
+			type,
+			value: convertCellValue(cell),
+			text,
+			style,
+			hyperlink: cell.hyperlink || void 0,
+			result: cell.result ?? void 0,
+			col: cell.col
+		};
+	}
+	function mapValueType(vt) {
+		switch (vt) {
+			case ValueType.Null: return PdfCellType.Empty;
+			case ValueType.Merge: return PdfCellType.Merge;
+			case ValueType.Number: return PdfCellType.Number;
+			case ValueType.String:
+			case ValueType.SharedString: return PdfCellType.String;
+			case ValueType.Date: return PdfCellType.Date;
+			case ValueType.Hyperlink: return PdfCellType.Hyperlink;
+			case ValueType.Formula: return PdfCellType.Formula;
+			case ValueType.RichText: return PdfCellType.RichText;
+			case ValueType.Boolean: return PdfCellType.Boolean;
+			case ValueType.Error: return PdfCellType.Error;
+			default: return PdfCellType.String;
+		}
+	}
+	/**
+	* Get display text for a cell, applying numFmt formatting.
+	*/
+	function getCellDisplayText(cell) {
+		if (!cell) return "";
+		switch (cell.type) {
+			case ValueType.Null:
+			case ValueType.Merge: return "";
+			case ValueType.RichText:
+			case ValueType.Hyperlink: return cell.text ?? "";
+			case ValueType.Error: return cell.value?.error ?? cell.text ?? "";
+			case ValueType.Formula: {
+				const result = cell.result;
+				if (result !== void 0 && result !== null) {
+					if (typeof result === "object" && "error" in result) return result.error;
+					return formatCellValueSafe(result, cell.style?.numFmt);
+				}
+				return cell.text ?? "";
+			}
+			default: {
+				const value = cell.value;
+				if (value === null || value === void 0) return "";
+				return formatCellValueSafe(value, cell.style?.numFmt);
+			}
+		}
+	}
+	function formatCellValueSafe(value, numFmt) {
+		const fmt = typeof numFmt === "string" ? numFmt : numFmt?.formatCode;
+		if (fmt && (typeof value === "number" || value instanceof Date || typeof value === "boolean")) try {
+			return formatCellValue(value, fmt);
+		} catch {}
+		if (value instanceof Date) return value.toLocaleDateString();
+		return String(value);
+	}
+	function convertCellValue(cell) {
+		if (cell.type === ValueType.RichText) {
+			const rtValue = cell.value;
+			if (rtValue?.richText) return { richText: rtValue.richText.map((run) => ({
+				text: run.text,
+				font: run.font ? convertFontStyle(run.font) : void 0
+			})) };
+		}
+		return cell.value;
+	}
+	function convertCellStyle(style) {
+		if (!style) return;
+		return {
+			font: style.font ? convertFontStyle(style.font) : void 0,
+			numFmt: style.numFmt,
+			fill: style.fill ? convertFill(style.fill) : void 0,
+			border: style.border ? convertBorders(style.border) : void 0,
+			alignment: style.alignment ? convertAlignment(style.alignment) : void 0
+		};
+	}
+	function convertFontStyle(font) {
+		return {
+			name: font.name,
+			size: font.size,
+			bold: font.bold,
+			italic: font.italic,
+			strike: font.strike,
+			underline: font.underline,
+			color: font.color ? convertColor(font.color) : void 0
+		};
+	}
+	function convertColor(color) {
+		return {
+			argb: color.argb,
+			theme: color.theme,
+			tint: color.tint
+		};
+	}
+	function convertFill(fill) {
+		const result = {
+			type: fill.type ?? "pattern",
+			pattern: fill.pattern,
+			fgColor: fill.fgColor ? convertColor(fill.fgColor) : void 0
+		};
+		if (fill.stops) result.stops = fill.stops.map((s) => ({ color: convertColor(s.color) }));
+		return result;
+	}
+	function convertBorderSide(border) {
+		return {
+			style: border.style,
+			color: border.color ? convertColor(border.color) : void 0
+		};
+	}
+	function convertBorders(borders) {
+		return {
+			top: borders.top ? convertBorderSide(borders.top) : void 0,
+			right: borders.right ? convertBorderSide(borders.right) : void 0,
+			bottom: borders.bottom ? convertBorderSide(borders.bottom) : void 0,
+			left: borders.left ? convertBorderSide(borders.left) : void 0
+		};
+	}
+	function convertAlignment(alignment) {
+		return {
+			horizontal: alignment.horizontal,
+			vertical: alignment.vertical,
+			wrapText: alignment.wrapText,
+			indent: alignment.indent,
+			textRotation: alignment.textRotation
+		};
+	}
+	function collectImages(ws, workbook) {
+		const wsImages = ws.getImages?.();
+		if (!wsImages || !Array.isArray(wsImages) || wsImages.length === 0) return;
+		const images = [];
+		for (const wsImage of wsImages) {
+			if (!wsImage.range?.tl) continue;
+			const imageId = wsImage.imageId;
+			const mediaItem = workbook.getImage?.(Number(imageId));
+			if (!mediaItem) continue;
+			let data;
+			if (mediaItem.buffer instanceof Uint8Array) data = mediaItem.buffer;
+			else if (mediaItem.base64) data = base64ToUint8Array(mediaItem.base64);
+			if (!data || data.length === 0) continue;
+			const format = mediaItem.extension;
+			if (format !== "jpeg" && format !== "png") continue;
+			images.push({
+				data,
+				format,
+				range: {
+					tl: {
+						col: wsImage.range.tl.col ?? 0,
+						row: wsImage.range.tl.row ?? 0,
+						nativeCol: wsImage.range.tl.nativeCol,
+						nativeRow: wsImage.range.tl.nativeRow,
+						nativeColOff: wsImage.range.tl.nativeColOff,
+						nativeRowOff: wsImage.range.tl.nativeRowOff
+					},
+					br: wsImage.range.br ? {
+						col: wsImage.range.br.col ?? 0,
+						row: wsImage.range.br.row ?? 0,
+						nativeCol: wsImage.range.br.nativeCol,
+						nativeRow: wsImage.range.br.nativeRow,
+						nativeColOff: wsImage.range.br.nativeColOff,
+						nativeRowOff: wsImage.range.br.nativeRowOff
+					} : void 0,
+					ext: wsImage.range.ext ? {
+						width: wsImage.range.ext.width,
+						height: wsImage.range.ext.height
+					} : void 0
+				}
+			});
+		}
+		return images.length > 0 ? images : void 0;
+	}
+	//#endregion
 	exports.Anchor = Anchor;
 	exports.BaseError = BaseError;
 	exports.Cell = Cell;
@@ -46911,7 +47388,6 @@ onmessage = async (ev) => {
 	exports.PageSizes = PageSizes;
 	exports.PaperSize = PaperSize;
 	exports.PdfError = PdfError;
-	exports.PdfExporter = PdfExporter;
 	exports.PdfFontError = PdfFontError;
 	exports.PdfRenderError = PdfRenderError;
 	exports.PdfStructureError = PdfStructureError;
@@ -46947,12 +47423,13 @@ onmessage = async (ev) => {
 	exports.encodeRow = encodeRow;
 	exports.errorToJSON = errorToJSON;
 	exports.excelToDate = excelToDate;
-	exports.exportPdf = exportPdf;
+	exports.excelToPdf = excelToPdf;
 	exports.getErrorChain = getErrorChain;
 	exports.getRootCause = getRootCause;
 	exports.getSupportedFormats = getSupportedFormats;
 	exports.isExcelError = isExcelError;
 	exports.isPdfError = isPdfError;
+	exports.pdf = pdf;
 	exports.stringToUint8Array = stringToUint8Array;
 	exports.toError = toError;
 	exports.toUint8Array = toUint8Array;