reamkit 0.1.0-alpha.0

package/dist/esm/converter/index.js

@@ -0,0 +1,2 @@
+import "./docx-to-pdf.js";
+import "./xlsx-to-pdf.js";

package/dist/esm/converter/xlsx-to-pdf.d.ts

@@ -0,0 +1,13 @@
+import { FontBytesByVariant } from '../font/index.js';
+import { FetchLike } from '../fonts/index.js';
+import { SignatureOptions, StyledRenderOptions } from '../pdf/index.js';
+export interface ConvertXlsxOptions extends Omit<StyledRenderOptions, 'registry' | 'styles'> {
+    readonly fontBytes?: Uint8Array;
+    readonly fonts?: FontBytesByVariant;
+    readonly fontFamily?: string;
+    readonly fontFetch?: FetchLike;
+    readonly embedSource?: boolean;
+    readonly signature?: SignatureOptions;
+}
+export declare function convertXlsxToPdf(xlsx: Uint8Array, options?: ConvertXlsxOptions): Promise<Uint8Array>;
+export declare function convertXlsxToPdfSync(xlsx: Uint8Array, options: ConvertXlsxOptions): Uint8Array;

package/dist/esm/converter/xlsx-to-pdf.js

@@ -0,0 +1,515 @@
+import { FontRegistry } from "../font/font-registry.js";
+import { fetchFontSet } from "../fonts/remote-fonts.js";
+import { OpcPackage } from "../opc/package.js";
+import { parseCoreProperties } from "../opc/core-properties.js";
+import "../opc/index.js";
+import { EMPTY_STYLE_SHEET } from "../ooxml/wordproc/styles-parser.js";
+import "../ooxml/wordproc/index.js";
+import { signPdf } from "../pdf/signature.js";
+import { renderStyledPdf } from "../pdf/styled-page-renderer.js";
+import "../pdf/index.js";
+import { parseAreaRef, parseTitleRowRange } from "../ooxml/spreadsheet/defined-name-ref.js";
+import { parseSharedStrings } from "../ooxml/spreadsheet/shared-strings-parser.js";
+import { parseWorkbook } from "../ooxml/spreadsheet/workbook-parser.js";
+import { parseWorksheet } from "../ooxml/spreadsheet/worksheet-parser.js";
+import { EMPTY_XLSX_STYLES, parseXlsxStyles } from "../ooxml/spreadsheet/styles-parser.js";
+import { applyNumberFormat } from "../ooxml/spreadsheet/number-format.js";
+import "../ooxml/spreadsheet/index.js";
+//#region src/converter/xlsx-to-pdf.ts
+var WORKBOOK_PART = "xl/workbook.xml";
+var SHARED_STRINGS_PART = "xl/sharedStrings.xml";
+var STYLES_PART = "xl/styles.xml";
+var CORE_PROPS_PART = "docProps/core.xml";
+var TWIPS_PER_EXCEL_CHAR = 105;
+var DEFAULT_COL_TWIPS = 960;
+var DEFAULT_ROW_TWIPS = 300;
+var TWIPS_PER_POINT = 20;
+var TWIPS_PER_INCH = 1440;
+var PAPER_SIZES_TWIPS = new Map([
+	[1, [12240, 15840]],
+	[3, [15840, 24480]],
+	[5, [12240, 20160]],
+	[8, [16838, 23811]],
+	[9, [11906, 16838]],
+	[11, [8392, 11906]],
+	[70, [5953, 8392]]
+]);
+var DEFAULT_PAPER_TWIPS = [11906, 16838];
+async function convertXlsxToPdf(xlsx, options = {}) {
+	const { signature } = options;
+	const renderOptions = signature ? {
+		...options,
+		signaturePlaceholder: signature
+	} : options;
+	let pdf;
+	if (renderOptions.fonts ?? renderOptions.fontBytes) pdf = convertXlsxToPdfSync(xlsx, renderOptions);
+	else {
+		const fonts = await fetchFontSet({
+			...options.fontFamily ? { family: options.fontFamily } : {},
+			...options.fontFetch ? { fetch: options.fontFetch } : {}
+		});
+		pdf = convertXlsxToPdfSync(xlsx, {
+			...renderOptions,
+			fonts
+		});
+	}
+	return signature ? signPdf(pdf, signature) : pdf;
+}
+function convertXlsxToPdfSync(xlsx, options) {
+	const fonts = options.fonts ?? (options.fontBytes ? { regular: options.fontBytes } : void 0);
+	if (!fonts) throw new Error("convertXlsxToPdfSync requires options.fonts or options.fontBytes");
+	const registry = FontRegistry.fromBytes(fonts);
+	const pkg = OpcPackage.open(xlsx);
+	const workbookData = pkg.getPart(WORKBOOK_PART);
+	if (!workbookData) throw new Error("Not a valid xlsx: missing xl/workbook.xml");
+	const { sheets, date1904, definedNames } = parseWorkbook(workbookData);
+	if (sheets.length === 0) throw new Error("xlsx has no sheets");
+	const sharedStringsData = pkg.getPart(SHARED_STRINGS_PART);
+	const sharedStrings = sharedStringsData ? parseSharedStrings(sharedStringsData) : [];
+	const stylesData = pkg.getPart(STYLES_PART);
+	const styles = stylesData ? parseXlsxStyles(stylesData) : EMPTY_XLSX_STYLES;
+	const workbookRels = pkg.getPartRelationships(WORKBOOK_PART);
+	const body = [];
+	let firstSheetSection;
+	for (let sheetIdx = 0; sheetIdx < sheets.length; sheetIdx++) {
+		const sheet = sheets[sheetIdx];
+		const sheetRel = workbookRels.find((r) => r.id === sheet.relationshipId);
+		if (!sheetRel) continue;
+		const resolved = pkg.resolveRelatedPart(WORKBOOK_PART, sheetRel);
+		if (!resolved) continue;
+		const worksheet = parseWorksheet(resolved.data);
+		if (sheetIdx === 0) firstSheetSection = sectionFromWorksheet(worksheet);
+		if (sheetIdx > 0) body.push({
+			kind: "paragraph",
+			paragraph: {
+				properties: { pageBreakBefore: true },
+				runs: []
+			}
+		});
+		const printArea = resolvePrintArea(definedNames, sheetIdx);
+		const titleRows = resolvePrintTitleRows(definedNames, sheetIdx);
+		const gridLines = worksheet.printOptions?.gridLines === true;
+		body.push(...worksheetToBody(worksheet, sharedStrings, styles, date1904, {
+			...printArea ? { printArea } : {},
+			...titleRows ? { titleRows } : {},
+			gridLines
+		}));
+	}
+	const coreData = pkg.getPart(CORE_PROPS_PART);
+	const coreProps = coreData ? parseCoreProperties(coreData) : void 0;
+	const { fontBytes: _ignoreA, fonts: _ignoreB, section: sectionOverride, info: callerInfo, embedSource, attachments: callerAttachments, signature: _ignoreSig, ...renderOptions } = options;
+	const section = sectionOverride ?? firstSheetSection;
+	const info = mergeInfo(coreProps, callerInfo);
+	const attachments = [...callerAttachments ?? []];
+	if (embedSource && options.pdfA?.startsWith("PDF/A-3")) attachments.push({
+		name: "source.xlsx",
+		bytes: xlsx,
+		mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+		relationship: "Source",
+		description: "Source Excel workbook"
+	});
+	return renderStyledPdf(body, {
+		registry,
+		styles: EMPTY_STYLE_SHEET,
+		...section ? { section } : {},
+		...info ? { info } : {},
+		...attachments.length > 0 ? { attachments } : {},
+		...renderOptions
+	});
+}
+function mergeInfo(core, caller) {
+	if (!core && !caller) return void 0;
+	return {
+		...core?.title ? { title: core.title } : {},
+		...core?.creator ? { author: core.creator } : {},
+		...core?.subject ? { subject: core.subject } : {},
+		...core?.keywords ? { keywords: core.keywords } : {},
+		...core?.created ? { creationDate: core.created } : {},
+		...core?.modified ? { modificationDate: core.modified } : {},
+		...caller
+	};
+}
+function sectionFromWorksheet(worksheet) {
+	const pageSize = pageSizeFromSetup(worksheet.pageSetup);
+	const margins = marginsFromXlsx(worksheet.pageMargins);
+	if (!pageSize && !margins) return void 0;
+	return {
+		...pageSize ? { pageSize } : {},
+		...margins ? { margins } : {},
+		headers: [],
+		footers: []
+	};
+}
+function pageSizeFromSetup(setup) {
+	if (!setup) return void 0;
+	const paper = setup.paperSize !== void 0 ? PAPER_SIZES_TWIPS.get(setup.paperSize) ?? DEFAULT_PAPER_TWIPS : DEFAULT_PAPER_TWIPS;
+	const [w, h] = setup.orientation === "landscape" ? [paper[1], paper[0]] : paper;
+	const orientation = setup.orientation === "landscape" ? "landscape" : "portrait";
+	if (setup.paperSize === void 0 && setup.orientation !== "landscape") return void 0;
+	return {
+		widthTwips: w,
+		heightTwips: h,
+		orientation
+	};
+}
+function marginsFromXlsx(margins) {
+	if (!margins) return void 0;
+	return {
+		topTwips: Math.round(margins.topInches * TWIPS_PER_INCH),
+		rightTwips: Math.round(margins.rightInches * TWIPS_PER_INCH),
+		bottomTwips: Math.round(margins.bottomInches * TWIPS_PER_INCH),
+		leftTwips: Math.round(margins.leftInches * TWIPS_PER_INCH),
+		...margins.headerInches !== void 0 ? { headerTwips: Math.round(margins.headerInches * TWIPS_PER_INCH) } : {},
+		...margins.footerInches !== void 0 ? { footerTwips: Math.round(margins.footerInches * TWIPS_PER_INCH) } : {}
+	};
+}
+var PRINT_AREA_NAME = "_xlnm.Print_Area";
+var PRINT_TITLES_NAME = "_xlnm.Print_Titles";
+function resolvePrintArea(definedNames, sheetIdx) {
+	for (const dn of definedNames) if (dn.name === PRINT_AREA_NAME && dn.localSheetId === sheetIdx) return parseAreaRef(dn.value);
+}
+function resolvePrintTitleRows(definedNames, sheetIdx) {
+	for (const dn of definedNames) if (dn.name === PRINT_TITLES_NAME && dn.localSheetId === sheetIdx) return parseTitleRowRange(dn.value);
+}
+var MIN_PRINT_SCALE = .1;
+function sheetContentWidthTwips(worksheet) {
+	const pageWidthTwips = pageSizeFromSetup(worksheet.pageSetup)?.widthTwips ?? DEFAULT_PAPER_TWIPS[0];
+	const margins = marginsFromXlsx(worksheet.pageMargins);
+	const left = margins?.leftTwips ?? TWIPS_PER_INCH;
+	const right = margins?.rightTwips ?? TWIPS_PER_INCH;
+	return Math.max(TWIPS_PER_INCH / 2, pageWidthTwips - left - right);
+}
+function sheetContentHeightTwips(worksheet) {
+	const pageHeightTwips = pageSizeFromSetup(worksheet.pageSetup)?.heightTwips ?? DEFAULT_PAPER_TWIPS[1];
+	const margins = marginsFromXlsx(worksheet.pageMargins);
+	const top = margins?.topTwips ?? TWIPS_PER_INCH;
+	const bottom = margins?.bottomTwips ?? TWIPS_PER_INCH;
+	return Math.max(TWIPS_PER_INCH / 2, pageHeightTwips - top - bottom);
+}
+function computePrintScale(worksheet, totalGridTwips, contentWidthTwips, totalGridHeightTwips, contentHeightTwips) {
+	const setup = worksheet.pageSetup;
+	let s = 1;
+	if (worksheet.fitToPage) {
+		const fitW = setup?.fitToWidth ?? 1;
+		let sW = 1;
+		let sH = 1;
+		if (fitW >= 1 && totalGridTwips > 0) sW = contentWidthTwips * fitW / totalGridTwips;
+		const fitH = setup?.fitToHeight;
+		if (fitH !== void 0 && fitH >= 1 && totalGridHeightTwips > 0) sH = contentHeightTwips * fitH / totalGridHeightTwips;
+		s = Math.min(sW, sH);
+	} else if (setup?.scale !== void 0 && setup.scale > 0) s = setup.scale / 100;
+	return Math.min(1, Math.max(MIN_PRINT_SCALE, s));
+}
+function scaleRunFont(props, scale) {
+	const hp = props.fontSizeHalfPoints ?? 22;
+	return {
+		...props,
+		fontSizeHalfPoints: Math.max(2, Math.round(hp * scale))
+	};
+}
+var MAX_SHEET_TEXT_CHARS = 1e6;
+function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
+	if (worksheet.maxRow < 0 || worksheet.maxColumn < 0) return [];
+	let usedRow = -1;
+	let usedCol = -1;
+	for (const c of worksheet.cells) if (c.rawValue !== "" || c.inlineText !== void 0) {
+		if (c.row > usedRow) usedRow = c.row;
+		if (c.column > usedCol) usedCol = c.column;
+	}
+	for (const m of worksheet.merges) {
+		if (m.endRow > usedRow) usedRow = m.endRow;
+		if (m.endColumn > usedCol) usedCol = m.endColumn;
+	}
+	if (usedRow < 0 || usedCol < 0) return [];
+	let rowStart = 0;
+	let colStart = 0;
+	let rowEnd = usedRow;
+	let colEnd = usedCol;
+	if (print.printArea) {
+		rowStart = Math.max(0, print.printArea.startRow);
+		colStart = Math.max(0, print.printArea.startColumn);
+		rowEnd = Math.min(usedRow, print.printArea.endRow);
+		colEnd = Math.min(usedCol, print.printArea.endColumn);
+	}
+	if (rowEnd < rowStart || colEnd < colStart) return [];
+	const MAX_GRID_COLS = 1024;
+	const rowCount = Math.min(rowEnd - rowStart + 1, 5e4);
+	const colCount = Math.min(colEnd - colStart + 1, MAX_GRID_COLS);
+	const rowWindowEnd = rowStart + rowCount - 1;
+	const colWindowEnd = colStart + colCount - 1;
+	const rowHeightMap = /* @__PURE__ */ new Map();
+	for (const h of worksheet.rowHeights) {
+		const local = h.row - rowStart;
+		if (local < 0 || local >= rowCount) continue;
+		const heightTwips = Math.round(h.heightPt * TWIPS_PER_POINT);
+		rowHeightMap.set(local, {
+			heightTwips,
+			heightRule: "atLeast"
+		});
+	}
+	const cellMatrix = Array.from({ length: rowCount }, () => new Array(colCount));
+	for (const cell of worksheet.cells) {
+		const lr = cell.row - rowStart;
+		const lc = cell.column - colStart;
+		if (lr >= 0 && lr < rowCount && lc >= 0 && lc < colCount) cellMatrix[lr][lc] = cell;
+	}
+	const mergeOrigins = /* @__PURE__ */ new Map();
+	const insideMerge = /* @__PURE__ */ new Set();
+	for (const m of worksheet.merges) {
+		if (m.endRow < rowStart || m.startRow > rowWindowEnd) continue;
+		if (m.endColumn < colStart || m.startColumn > colWindowEnd) continue;
+		mergeOrigins.set(key(m.startRow, m.startColumn), m);
+		const rEnd = Math.min(m.endRow, rowWindowEnd);
+		const cEnd = Math.min(m.endColumn, colWindowEnd);
+		for (let r = Math.max(m.startRow, rowStart); r <= rEnd; r++) for (let c = Math.max(m.startColumn, colStart); c <= cEnd; c++) if (!(r === m.startRow && c === m.startColumn)) insideMerge.add(key(r, c));
+	}
+	const columnWidths = new Array(colCount).fill(DEFAULT_COL_TWIPS);
+	for (const col of worksheet.columns) {
+		const twips = Math.round(col.widthChars * TWIPS_PER_EXCEL_CHAR);
+		for (let abs = col.min - 1; abs <= col.max - 1; abs++) {
+			const i = abs - colStart;
+			if (i >= 0 && i < colCount) columnWidths[i] = twips;
+		}
+	}
+	const totalGridTwips = columnWidths.reduce((sum, w) => sum + w, 0);
+	let totalGridHeightTwips = 0;
+	for (let r = 0; r < rowCount; r++) totalGridHeightTwips += rowHeightMap.get(r)?.heightTwips ?? DEFAULT_ROW_TWIPS;
+	const printScale = computePrintScale(worksheet, totalGridTwips, sheetContentWidthTwips(worksheet), totalGridHeightTwips, sheetContentHeightTwips(worksheet));
+	const scaled = printScale < .999;
+	const breakRows = new Set(worksheet.rowBreaks ?? []);
+	let textBudget = MAX_SHEET_TEXT_CHARS;
+	const rows = [];
+	for (let r = 0; r < rowCount; r++) {
+		const absR = r + rowStart;
+		const cells = [];
+		for (let c = 0; c < colCount; c++) {
+			const absC = c + colStart;
+			const merge = mergeOrigins.get(key(absR, absC));
+			if (insideMerge.has(key(absR, absC)) && !merge) {
+				const verticalParent = verticalMergeParent(worksheet.merges, absR, absC);
+				if (verticalParent && absC === verticalParent.startColumn) cells.push(makeVerticalContinuation(verticalParent, colWindowEnd));
+				continue;
+			}
+			const ws = cellMatrix[r]?.[c];
+			let text = ws ? resolveCellText(ws, sharedStrings, styles, date1904) : "";
+			if (text.length > textBudget) text = text.slice(0, Math.max(0, textBudget));
+			textBudget -= text.length;
+			const xf = ws && ws.styleIndex !== void 0 ? styles.cellXfs[ws.styleIndex] : void 0;
+			const baseRunProps = xf ? runPropsFromXf(xf, styles) : {};
+			const runProps = scaled ? scaleRunFont(baseRunProps, printScale) : baseRunProps;
+			const alignment = xf ? alignmentFromXf(xf) : void 0;
+			const shading = xf ? shadingFromXf(xf, styles) : void 0;
+			const borders = xf ? bordersFromXf(xf, styles) : void 0;
+			if (text.length > 0 && !merge && ws && (ws.type === "s" || ws.type === "str" || ws.type === "inlineStr") && (alignment === void 0 || alignment === "left")) {
+				let availTwips = columnWidths[c];
+				let cc = c + 1;
+				while (cc < colCount && !cellHasContent(cellMatrix[r]?.[cc])) {
+					availTwips += columnWidths[cc];
+					cc++;
+				}
+				if (cc < colCount) {
+					const charsFit = Math.max(1, Math.round(availTwips / TWIPS_PER_EXCEL_CHAR));
+					if (text.length > charsFit) text = text.slice(0, charsFit);
+				}
+			}
+			const visibleEndCol = merge ? Math.min(merge.endColumn, colWindowEnd) : 0;
+			const properties = {
+				...merge && visibleEndCol > merge.startColumn ? { gridSpan: visibleEndCol - merge.startColumn + 1 } : {},
+				...merge && Math.min(merge.endRow, rowWindowEnd) > merge.startRow ? { vMerge: "restart" } : {},
+				...shading ? { shading } : {},
+				...borders ? { borders } : {}
+			};
+			const paragraphProps = alignment ? { alignment } : {};
+			cells.push({
+				properties,
+				content: [{
+					kind: "paragraph",
+					paragraph: {
+						properties: paragraphProps,
+						runs: text.length > 0 ? [{
+							text,
+							properties: runProps
+						}] : []
+					}
+				}]
+			});
+		}
+		const baseRowProps = rowHeightMap.get(r);
+		const scaledRowProps = scaled && baseRowProps?.heightTwips !== void 0 ? {
+			...baseRowProps,
+			heightTwips: Math.max(1, Math.round(baseRowProps.heightTwips * printScale))
+		} : baseRowProps ?? {};
+		const isTitleRow = print.titleRows !== void 0 && absR >= print.titleRows.startRow && absR <= print.titleRows.endRow;
+		const rowProps = {
+			...scaledRowProps,
+			...isTitleRow ? { isHeader: true } : {},
+			...breakRows.has(absR) ? { pageBreakBefore: true } : {}
+		};
+		rows.push({
+			properties: rowProps,
+			cells
+		});
+	}
+	const thin = {
+		style: "single",
+		sizeEighthPt: 4
+	};
+	const centered = worksheet.printOptions?.horizontalCentered === true;
+	return [{
+		kind: "table",
+		table: {
+			properties: {
+				...print.gridLines ? { borders: {
+					top: thin,
+					bottom: thin,
+					left: thin,
+					right: thin,
+					insideH: thin,
+					insideV: thin
+				} } : {},
+				...centered ? { alignment: "center" } : {}
+			},
+			grid: columnWidths,
+			rows
+		}
+	}];
+}
+function verticalMergeParent(merges, row, column) {
+	for (const m of merges) if (column >= m.startColumn && column <= m.endColumn && row > m.startRow && row <= m.endRow && m.endRow > m.startRow) return m;
+}
+function makeVerticalContinuation(merge, colWindowEnd) {
+	const span = Math.min(merge.endColumn, colWindowEnd) - merge.startColumn + 1;
+	return {
+		properties: {
+			vMerge: "continue",
+			...span > 1 ? { gridSpan: span } : {}
+		},
+		content: [{
+			kind: "paragraph",
+			paragraph: {
+				properties: {},
+				runs: []
+			}
+		}]
+	};
+}
+function resolveCellText(cell, sharedStrings, styles, date1904) {
+	if (cell.type === "inlineStr") return cell.inlineText ?? "";
+	if (cell.type === "s") {
+		const idx = Number(cell.rawValue);
+		if (Number.isInteger(idx) && idx >= 0 && idx < sharedStrings.length) return sharedStrings[idx];
+		return "";
+	}
+	if (cell.type === "b") return cell.rawValue === "1" ? "TRUE" : "FALSE";
+	if (cell.type === "str" || cell.type === "e" || cell.type === "d") return cell.rawValue;
+	const numFmtId = (cell.styleIndex !== void 0 ? styles.cellXfs[cell.styleIndex] : void 0)?.numFmtId ?? 0;
+	return applyNumberFormat(cell.rawValue, numFmtId, styles.numFmts, date1904);
+}
+function runPropsFromXf(xf, styles) {
+	if (!xf.applyFont && xf.fontId === 0) return {};
+	const font = styles.fonts[xf.fontId];
+	if (!font) return {};
+	const props = {};
+	if (font.bold) props.bold = true;
+	if (font.italic) props.italic = true;
+	if (font.sizePt !== void 0) props.fontSizeHalfPoints = Math.round(font.sizePt * 2);
+	if (font.colorHex) props.colorHex = font.colorHex;
+	return props;
+}
+function alignmentFromXf(xf) {
+	const align = xf.alignment;
+	if (!align) return void 0;
+	return mapAlignment(align.horizontal);
+}
+function mapAlignment(h) {
+	if (!h) return void 0;
+	if (h === "left") return "left";
+	if (h === "right") return "right";
+	if (h === "center" || h === "centerContinuous") return "center";
+	if (h === "justify") return "both";
+	if (h === "distributed") return "distribute";
+}
+function shadingFromXf(xf, styles) {
+	if (xf.applyFill === false) return void 0;
+	if (xf.fillId === 0 || xf.fillId === 1) {
+		if (!xf.applyFill) return void 0;
+	}
+	const fill = styles.fills[xf.fillId];
+	if (!fill || fill.patternType !== "solid" || !fill.fgColorHex) return void 0;
+	return { colorHex: fill.fgColorHex };
+}
+function bordersFromXf(xf, styles) {
+	if (xf.applyBorder === false) return void 0;
+	if (xf.borderId === 0 && !xf.applyBorder) return void 0;
+	const border = styles.borders[xf.borderId];
+	if (!border) return void 0;
+	const out = {};
+	const top = mapBorderEdge(border.top);
+	const right = mapBorderEdge(border.right);
+	const bottom = mapBorderEdge(border.bottom);
+	const left = mapBorderEdge(border.left);
+	if (top) out.top = top;
+	if (right) out.right = right;
+	if (bottom) out.bottom = bottom;
+	if (left) out.left = left;
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function mapBorderEdge(edge) {
+	if (!edge || !edge.style || edge.style === "none") return void 0;
+	const { style, sizeEighthPt } = mapBorderStyle(edge.style);
+	return {
+		style,
+		sizeEighthPt,
+		...edge.colorHex ? { colorHex: edge.colorHex } : {}
+	};
+}
+function mapBorderStyle(style) {
+	switch (style) {
+		case "hair": return {
+			style: "single",
+			sizeEighthPt: 2
+		};
+		case "thin": return {
+			style: "single",
+			sizeEighthPt: 4
+		};
+		case "medium":
+		case "mediumDashed":
+		case "mediumDashDot":
+		case "mediumDashDotDot": return {
+			style: "single",
+			sizeEighthPt: 8
+		};
+		case "thick": return {
+			style: "thick",
+			sizeEighthPt: 12
+		};
+		case "dashed":
+		case "dashDot":
+		case "dashDotDot":
+		case "slantDashDot": return {
+			style: "dashed",
+			sizeEighthPt: 4
+		};
+		case "dotted": return {
+			style: "dotted",
+			sizeEighthPt: 4
+		};
+		case "double": return {
+			style: "double",
+			sizeEighthPt: 4
+		};
+		default: return {
+			style: "single",
+			sizeEighthPt: 4
+		};
+	}
+}
+function key(row, col) {
+	return `${row},${col}`;
+}
+function cellHasContent(cell) {
+	return !!cell && (cell.rawValue !== "" || cell.inlineText !== void 0);
+}
+//#endregion
+export { convertXlsxToPdf, convertXlsxToPdfSync };

package/dist/esm/crypto/asn1.d.ts

@@ -0,0 +1,23 @@
+export declare function concat(arrays: ReadonlyArray<Uint8Array>): Uint8Array;
+export declare function tlv(tag: number, content: Uint8Array): Uint8Array;
+export declare const seq: (...items: Array<Uint8Array>) => Uint8Array;
+export declare const set: (...items: Array<Uint8Array>) => Uint8Array;
+export declare const octetString: (bytes: Uint8Array) => Uint8Array;
+export declare const nullValue: () => Uint8Array;
+export declare const explicit: (tagNum: number, content: Uint8Array) => Uint8Array;
+export declare function oid(dotted: string): Uint8Array;
+export declare function integer(value: number | Uint8Array): Uint8Array;
+export declare function cmsTime(d: Date): Uint8Array;
+export declare function setOfBody(items: ReadonlyArray<Uint8Array>): Uint8Array;
+export interface Tlv {
+    readonly tag: number;
+    readonly contentStart: number;
+    readonly contentEnd: number;
+    readonly end: number;
+}
+export declare function children(buf: Uint8Array, parent: Tlv): Array<Tlv>;
+export declare function readTlv(buf: Uint8Array, offset: number): Tlv;
+export declare function certIssuerAndSerial(cert: Uint8Array): {
+    readonly issuer: Uint8Array;
+    readonly serial: Uint8Array;
+};

package/dist/esm/crypto/asn1.js

@@ -0,0 +1,123 @@
+//#region src/crypto/asn1.ts
+var textEncoder = new TextEncoder();
+function concat(arrays) {
+	let total = 0;
+	for (const a of arrays) total += a.length;
+	const out = new Uint8Array(total);
+	let off = 0;
+	for (const a of arrays) {
+		out.set(a, off);
+		off += a.length;
+	}
+	return out;
+}
+function encodeLength(len) {
+	if (len < 128) return new Uint8Array([len]);
+	const bytes = [];
+	let n = len;
+	while (n > 0) {
+		bytes.unshift(n & 255);
+		n = Math.floor(n / 256);
+	}
+	return new Uint8Array([128 | bytes.length, ...bytes]);
+}
+function tlv(tag, content) {
+	const len = encodeLength(content.length);
+	const out = new Uint8Array(1 + len.length + content.length);
+	out[0] = tag;
+	out.set(len, 1);
+	out.set(content, 1 + len.length);
+	return out;
+}
+var seq = (...items) => tlv(48, concat(items));
+var set = (...items) => tlv(49, concat(items));
+var octetString = (bytes) => tlv(4, bytes);
+var nullValue = () => tlv(5, new Uint8Array(0));
+var explicit = (tagNum, content) => tlv(160 | tagNum, content);
+function base128(v) {
+	const out = [v & 127];
+	let n = Math.floor(v / 128);
+	while (n > 0) {
+		out.unshift(n & 127 | 128);
+		n = Math.floor(n / 128);
+	}
+	return out;
+}
+function oid(dotted) {
+	const parts = dotted.split(".").map((p) => Number(p));
+	const body = [...base128(40 * parts[0] + parts[1])];
+	for (let i = 2; i < parts.length; i++) body.push(...base128(parts[i]));
+	return tlv(6, new Uint8Array(body));
+}
+function integer(value) {
+	let bytes;
+	if (typeof value === "number") {
+		bytes = [];
+		let n = value;
+		if (n === 0) bytes = [0];
+		while (n > 0) {
+			bytes.unshift(n & 255);
+			n = Math.floor(n / 256);
+		}
+	} else {
+		bytes = [...value];
+		while (bytes.length > 1 && bytes[0] === 0 && (bytes[1] & 128) === 0) bytes.shift();
+	}
+	if (bytes.length === 0) bytes = [0];
+	if (bytes[0] & 128) bytes.unshift(0);
+	return tlv(2, new Uint8Array(bytes));
+}
+var pad2 = (n) => n.toString().padStart(2, "0");
+function cmsTime(d) {
+	const y = d.getUTCFullYear();
+	const mmddhhmmss = pad2(d.getUTCMonth() + 1) + pad2(d.getUTCDate()) + pad2(d.getUTCHours()) + pad2(d.getUTCMinutes()) + pad2(d.getUTCSeconds());
+	if (y >= 1950 && y < 2050) return tlv(23, textEncoder.encode(pad2(y % 100) + mmddhhmmss + "Z"));
+	return tlv(24, textEncoder.encode(String(y) + mmddhhmmss + "Z"));
+}
+function compareDer(a, b) {
+	const n = Math.min(a.length, b.length);
+	for (let i = 0; i < n; i++) if (a[i] !== b[i]) return a[i] - b[i];
+	return a.length - b.length;
+}
+function setOfBody(items) {
+	return concat([...items].sort(compareDer));
+}
+function readTlv(buf, offset) {
+	const tag = buf[offset];
+	let i = offset + 1;
+	let len = buf[i];
+	i++;
+	if (len & 128) {
+		const n = len & 127;
+		len = 0;
+		for (let k = 0; k < n; k++) {
+			len = len * 256 + buf[i];
+			i++;
+		}
+	}
+	return {
+		tag,
+		contentStart: i,
+		contentEnd: i + len,
+		end: i + len
+	};
+}
+function certIssuerAndSerial(cert) {
+	let p = readTlv(cert, readTlv(cert, 0).contentStart).contentStart;
+	let t = readTlv(cert, p);
+	if (t.tag === 160) {
+		p = t.end;
+		t = readTlv(cert, p);
+	}
+	const serial = cert.slice(p, t.end);
+	p = t.end;
+	t = readTlv(cert, p);
+	p = t.end;
+	t = readTlv(cert, p);
+	return {
+		issuer: cert.slice(p, t.end),
+		serial
+	};
+}
+//#endregion
+export { certIssuerAndSerial, cmsTime, concat, explicit, integer, nullValue, octetString, oid, seq, set, setOfBody, tlv };

package/dist/esm/crypto/cms.d.ts

@@ -0,0 +1,9 @@
+export interface CmsParams {
+    readonly certificate: Uint8Array;
+    readonly extraCertificates?: ReadonlyArray<Uint8Array>;
+    readonly messageDigest: Uint8Array;
+    readonly signingTime: Date;
+    readonly signatureAlgorithm?: 'rsa' | 'ecdsa';
+    readonly sign: (signedAttrsDer: Uint8Array) => Promise<Uint8Array>;
+}
+export declare function buildPkcs7Detached(params: CmsParams): Promise<Uint8Array>;