pdf-codec 1.3.0 → 1.4.0

package/dist/write.js

@@ -0,0 +1,419 @@
+import { a as winAnsiGlyphName, n as widthOfCode, t as STANDARD_METRICS } from "./afm-widths-Dxucrg7D.js";
+import { base64ToBytes } from "./util/base64.js";
+import { ByteWriter, concatBytes } from "./bytes/writer.js";
+import { deflate } from "./bytes/flate.js";
+import { pdfArray, pdfDict, pdfHexString, pdfName, pdfNum, pdfRef, pdfStream } from "./objects.js";
+import { throwIfAborted } from "./util/abort.js";
+import { resolveStandardFont } from "./fonts.js";
+import { readJpegInfo } from "./image/jpeg-info.js";
+import { decodePng } from "./image/png-decode.js";
+import { writeObject } from "./serialize.js";
+import { writeContentStream } from "./content-write.js";
+import { collectUsedGlyphs, writeFormulaContentStream } from "./math-content-write.js";
+import { loadMathFont } from "./math-font.js";
+import { buildMathFontObjects } from "./math-font-write.js";
+import { createStandardFontMeasurer } from "./measure.js";
+//#region src/write.ts
+const MATH_FONT_RESOURCE_NAME = "MF";
+const FIRST_CHAR = 32;
+const LAST_CHAR = 255;
+const NOMINAL_STEM_V_REGULAR = 80;
+const NOMINAL_STEM_V_BOLD = 120;
+const FLAG_FIXED_PITCH = 1;
+const FLAG_SERIF = 2;
+const FLAG_NONSYMBOLIC = 32;
+const FLAG_ITALIC = 64;
+const FLAG_FORCE_BOLD = 262144;
+function textToPdfString(text) {
+	const bytes = new Uint8Array(2 + text.length * 2);
+	bytes[0] = 254;
+	bytes[1] = 255;
+	for (let i = 0; i < text.length; i++) {
+		const code = text.charCodeAt(i);
+		bytes[2 + i * 2] = code >> 8 & 255;
+		bytes[2 + i * 2 + 1] = code & 255;
+	}
+	return pdfHexString(bytes);
+}
+function pad2(n) {
+	return n.toString().padStart(2, "0");
+}
+function formatPdfDate(iso) {
+	const date = new Date(iso);
+	return `D:${date.getUTCFullYear()}${pad2(date.getUTCMonth() + 1)}${pad2(date.getUTCDate())}${pad2(date.getUTCHours())}${pad2(date.getUTCMinutes())}${pad2(date.getUTCSeconds())}Z`;
+}
+function buildInfoDict(doc) {
+	const entries = /* @__PURE__ */ new Map();
+	entries.set("Producer", textToPdfString("documents.js"));
+	if (doc.metadata.title !== void 0) entries.set("Title", textToPdfString(doc.metadata.title));
+	if (doc.metadata.author !== void 0) entries.set("Author", textToPdfString(doc.metadata.author));
+	if (doc.metadata.subject !== void 0) entries.set("Subject", textToPdfString(doc.metadata.subject));
+	if (doc.metadata.keywords !== void 0) entries.set("Keywords", textToPdfString(doc.metadata.keywords.join(", ")));
+	if (doc.metadata.creator !== void 0) entries.set("Creator", textToPdfString(doc.metadata.creator));
+	if (doc.metadata.createdIso !== void 0) entries.set("CreationDate", textToPdfString(formatPdfDate(doc.metadata.createdIso)));
+	if (doc.metadata.modifiedIso !== void 0) entries.set("ModDate", textToPdfString(formatPdfDate(doc.metadata.modifiedIso)));
+	return pdfDict(entries);
+}
+function computeFontFlags(standardName, metrics) {
+	let flags = FLAG_NONSYMBOLIC;
+	if (standardName.startsWith("Courier")) flags |= FLAG_FIXED_PITCH;
+	if (standardName.startsWith("Times")) flags |= FLAG_SERIF;
+	if (metrics.italicAngle !== 0) flags |= FLAG_ITALIC;
+	if (standardName.includes("Bold")) flags |= FLAG_FORCE_BOLD;
+	return flags;
+}
+function widthForWidthsArray(standardName, code) {
+	if (STANDARD_METRICS[standardName].fixedWidth === void 0 && winAnsiGlyphName(code) === void 0) return 0;
+	return widthOfCode(standardName, code);
+}
+function buildFontObjects(standardName, descriptorRef) {
+	const metrics = STANDARD_METRICS[standardName];
+	const widths = [];
+	for (let code = FIRST_CHAR; code <= LAST_CHAR; code++) widths.push(pdfNum(widthForWidthsArray(standardName, code)));
+	return {
+		font: pdfDict({
+			Type: pdfName("Font"),
+			Subtype: pdfName("Type1"),
+			BaseFont: pdfName(standardName),
+			Encoding: pdfName("WinAnsiEncoding"),
+			FirstChar: pdfNum(FIRST_CHAR),
+			LastChar: pdfNum(LAST_CHAR),
+			Widths: pdfArray(widths),
+			FontDescriptor: descriptorRef
+		}),
+		descriptor: pdfDict({
+			Type: pdfName("FontDescriptor"),
+			FontName: pdfName(standardName),
+			Flags: pdfNum(computeFontFlags(standardName, metrics)),
+			FontBBox: pdfArray(metrics.fontBBox.map((n) => pdfNum(n))),
+			ItalicAngle: pdfNum(metrics.italicAngle),
+			Ascent: pdfNum(metrics.ascender),
+			Descent: pdfNum(metrics.descender),
+			CapHeight: pdfNum(metrics.capHeight),
+			XHeight: pdfNum(metrics.xHeight),
+			StemV: pdfNum(standardName.includes("Bold") ? NOMINAL_STEM_V_BOLD : NOMINAL_STEM_V_REGULAR)
+		})
+	};
+}
+function prepareJpegImage(bytes) {
+	const info = readJpegInfo(bytes);
+	const colorSpace = info.components === 1 ? "DeviceGray" : info.components === 4 ? "DeviceCMYK" : "DeviceRGB";
+	const entries = /* @__PURE__ */ new Map([
+		["Type", pdfName("XObject")],
+		["Subtype", pdfName("Image")],
+		["Width", pdfNum(info.width)],
+		["Height", pdfNum(info.height)],
+		["ColorSpace", pdfName(colorSpace)],
+		["BitsPerComponent", pdfNum(info.precision)],
+		["Filter", pdfName("DCTDecode")]
+	]);
+	if (info.components === 4 && (info.adobeTransform === 2 || info.adobeTransform === void 0)) entries.set("Decode", pdfArray([
+		1,
+		0,
+		1,
+		0,
+		1,
+		0,
+		1,
+		0
+	].map((n) => pdfNum(n))));
+	return {
+		dict: pdfDict(entries),
+		raw: bytes
+	};
+}
+function pngImageDict(width, height, colorSpace, compress) {
+	const entries = /* @__PURE__ */ new Map([
+		["Type", pdfName("XObject")],
+		["Subtype", pdfName("Image")],
+		["Width", pdfNum(width)],
+		["Height", pdfNum(height)],
+		["ColorSpace", pdfName(colorSpace)],
+		["BitsPerComponent", pdfNum(8)]
+	]);
+	if (compress) entries.set("Filter", pdfName("FlateDecode"));
+	return pdfDict(entries);
+}
+function preparePngImage(bytes, compress) {
+	const raw = decodePng(bytes);
+	const colorSpace = raw.channels === 1 ? "DeviceGray" : "DeviceRGB";
+	return {
+		dict: pngImageDict(raw.width, raw.height, colorSpace, compress),
+		raw: compress ? deflate(raw.data) : raw.data,
+		alpha: raw.alpha === void 0 ? void 0 : {
+			dict: pngImageDict(raw.width, raw.height, "DeviceGray", compress),
+			raw: compress ? deflate(raw.alpha) : raw.alpha
+		}
+	};
+}
+function prepareImage(asset, compress) {
+	const bytes = base64ToBytes(asset.base64);
+	return asset.format === "jpeg" ? prepareJpegImage(bytes) : preparePngImage(bytes, compress);
+}
+function buildLinkAnnotDict(link) {
+	return pdfDict({
+		Type: pdfName("Annot"),
+		Subtype: pdfName("Link"),
+		Rect: pdfArray([
+			link.xPt,
+			link.yPt,
+			link.xPt + link.widthPt,
+			link.yPt + link.heightPt
+		].map((n) => pdfNum(n))),
+		Border: pdfArray([
+			0,
+			0,
+			0
+		].map((n) => pdfNum(n))),
+		A: pdfDict({
+			Type: pdfName("Action"),
+			S: pdfName("URI"),
+			URI: pdfHexString(new TextEncoder().encode(link.uri))
+		})
+	});
+}
+function isLinkItem(item) {
+	return item.kind === "link";
+}
+const NOTES_ANNOTATION_HIDDEN_FLAG = 2;
+const NOTES_ANNOTATION_AUTHOR = "documents.js:notes";
+function buildNotesAnnotDict(notes) {
+	return pdfDict({
+		Type: pdfName("Annot"),
+		Subtype: pdfName("Text"),
+		Rect: pdfArray([
+			0,
+			0,
+			0,
+			0
+		].map((n) => pdfNum(n))),
+		Contents: textToPdfString(notes),
+		T: textToPdfString(NOTES_ANNOTATION_AUTHOR),
+		F: pdfNum(NOTES_ANNOTATION_HIDDEN_FLAG)
+	});
+}
+function xrefEntry(offset, generation, inUse) {
+	return `${offset.toString().padStart(10, "0")} ${generation.toString().padStart(5, "0")} ${inUse ? "n" : "f"} \n`;
+}
+function writePdf(doc, options = {}) {
+	const compress = options.compress ?? true;
+	const measurer = createStandardFontMeasurer();
+	let nextObjNum = 1;
+	const catalogNum = nextObjNum++;
+	const pagesNum = nextObjNum++;
+	const infoNum = nextObjNum++;
+	const fontNames = /* @__PURE__ */ new Set();
+	const imageIds = /* @__PURE__ */ new Set();
+	for (const page of doc.pages) for (const item of page.items) if (item.kind === "text") fontNames.add(resolveStandardFont(item.font.family, item.font.weight === "bold", item.font.style === "italic").standardName);
+	else if (item.kind === "image") imageIds.add(item.imageId);
+	const fontAllocs = /* @__PURE__ */ new Map();
+	for (const [index, name] of [...fontNames].sort().entries()) {
+		const fontNum = nextObjNum++;
+		const descNum = nextObjNum++;
+		fontAllocs.set(name, {
+			fontNum,
+			descNum,
+			resourceName: `F${index + 1}`
+		});
+	}
+	const imageAllocs = /* @__PURE__ */ new Map();
+	for (const [index, imageId] of [...imageIds].sort().entries()) {
+		const asset = doc.images[imageId];
+		if (asset === void 0) throw new Error(`LayoutDocument references image "${imageId}" but it is not present in images`);
+		const prepared = prepareImage(asset, compress);
+		const imageNum = nextObjNum++;
+		const smaskNum = prepared.alpha === void 0 ? void 0 : nextObjNum++;
+		imageAllocs.set(imageId, {
+			imageNum,
+			smaskNum,
+			resourceName: `Im${index + 1}`,
+			prepared
+		});
+	}
+	const formulas = options.formulas ?? [];
+	const mathFontAlloc = formulas.length === 0 ? void 0 : {
+		type0Num: nextObjNum++,
+		cidFontNum: nextObjNum++,
+		descriptorNum: nextObjNum++,
+		fontFileNum: nextObjNum++,
+		toUnicodeNum: nextObjNum++,
+		resourceName: MATH_FONT_RESOURCE_NAME
+	};
+	const pageAllocs = doc.pages.map(() => ({
+		pageNum: nextObjNum++,
+		contentsNum: nextObjNum++
+	}));
+	const objects = [];
+	objects.push({
+		num: catalogNum,
+		value: pdfDict({
+			Type: pdfName("Catalog"),
+			Pages: pdfRef(pagesNum, 0)
+		})
+	});
+	objects.push({
+		num: pagesNum,
+		value: pdfDict({
+			Type: pdfName("Pages"),
+			Kids: pdfArray(pageAllocs.map((p) => pdfRef(p.pageNum, 0))),
+			Count: pdfNum(doc.pages.length)
+		})
+	});
+	objects.push({
+		num: infoNum,
+		value: buildInfoDict(doc)
+	});
+	for (const [standardName, alloc] of fontAllocs) {
+		const { font, descriptor } = buildFontObjects(standardName, pdfRef(alloc.descNum, 0));
+		objects.push({
+			num: alloc.fontNum,
+			value: font
+		});
+		objects.push({
+			num: alloc.descNum,
+			value: descriptor
+		});
+	}
+	for (const alloc of imageAllocs.values()) {
+		if (alloc.smaskNum !== void 0 && alloc.prepared.alpha !== void 0) {
+			alloc.prepared.dict.entries.set("SMask", pdfRef(alloc.smaskNum, 0));
+			objects.push({
+				num: alloc.smaskNum,
+				value: pdfStream(alloc.prepared.alpha.dict, alloc.prepared.alpha.raw)
+			});
+		}
+		objects.push({
+			num: alloc.imageNum,
+			value: pdfStream(alloc.prepared.dict, alloc.prepared.raw)
+		});
+	}
+	const mathFont = mathFontAlloc === void 0 ? void 0 : loadMathFont().font;
+	const usedGlyphs = mathFontAlloc === void 0 || mathFont === void 0 ? void 0 : collectUsedGlyphs(formulas, mathFont);
+	if (mathFontAlloc !== void 0 && mathFont !== void 0 && usedGlyphs !== void 0) {
+		const built = buildMathFontObjects(mathFont, usedGlyphs, {
+			cidFontRef: pdfRef(mathFontAlloc.cidFontNum, 0),
+			descriptorRef: pdfRef(mathFontAlloc.descriptorNum, 0),
+			fontFileRef: pdfRef(mathFontAlloc.fontFileNum, 0),
+			toUnicodeRef: pdfRef(mathFontAlloc.toUnicodeNum, 0)
+		}, compress);
+		objects.push({
+			num: mathFontAlloc.type0Num,
+			value: built.type0
+		});
+		objects.push({
+			num: mathFontAlloc.cidFontNum,
+			value: built.cidFont
+		});
+		objects.push({
+			num: mathFontAlloc.descriptorNum,
+			value: built.descriptor
+		});
+		objects.push({
+			num: mathFontAlloc.fontFileNum,
+			value: built.fontFile
+		});
+		objects.push({
+			num: mathFontAlloc.toUnicodeNum,
+			value: built.toUnicode
+		});
+	}
+	const resourceEntries = /* @__PURE__ */ new Map();
+	if (fontAllocs.size > 0 || mathFontAlloc !== void 0) {
+		const fontEntries = new Map([...fontAllocs.values()].map((alloc) => [alloc.resourceName, pdfRef(alloc.fontNum, 0)]));
+		if (mathFontAlloc !== void 0) fontEntries.set(mathFontAlloc.resourceName, pdfRef(mathFontAlloc.type0Num, 0));
+		resourceEntries.set("Font", pdfDict(fontEntries));
+	}
+	if (imageAllocs.size > 0) resourceEntries.set("XObject", pdfDict(new Map([...imageAllocs.values()].map((alloc) => [alloc.resourceName, pdfRef(alloc.imageNum, 0)]))));
+	const resourcesDict = pdfDict(resourceEntries);
+	const formulasByPage = /* @__PURE__ */ new Map();
+	for (const formula of formulas) {
+		const forPage = formulasByPage.get(formula.pageIndex);
+		if (forPage === void 0) formulasByPage.set(formula.pageIndex, [formula]);
+		else forPage.push(formula);
+	}
+	const context = {
+		measurer,
+		resolveFont: (font) => {
+			const standardName = resolveStandardFont(font.family, font.weight === "bold", font.style === "italic").standardName;
+			const alloc = fontAllocs.get(standardName);
+			if (alloc === void 0) throw new Error(`font "${standardName}" was not pre-allocated -- this is a writePdf internal invariant violation`);
+			return {
+				resourceName: alloc.resourceName,
+				standardName
+			};
+		},
+		resolveImage: (imageId) => {
+			const alloc = imageAllocs.get(imageId);
+			if (alloc === void 0) throw new Error(`image "${imageId}" was not pre-allocated -- this is a writePdf internal invariant violation`);
+			return { resourceName: alloc.resourceName };
+		}
+	};
+	doc.pages.forEach((page, pageIndex) => {
+		throwIfAborted(options.signal);
+		const { pageNum, contentsNum } = pageAllocs[pageIndex];
+		const { bytes: contentBytes, substitutions } = writeContentStream(page.items, context);
+		for (const substitution of substitutions) options.onSubstitution?.(substitution, { pageIndex });
+		const pageFormulas = formulasByPage.get(pageIndex);
+		const formulaBytes = pageFormulas === void 0 || mathFontAlloc === void 0 || mathFont === void 0 ? void 0 : writeFormulaContentStream(pageFormulas, {
+			font: mathFont,
+			resourceName: mathFontAlloc.resourceName
+		});
+		const combinedContentBytes = formulaBytes === void 0 ? contentBytes : concatBytes([contentBytes, formulaBytes]);
+		const finalContentBytes = compress ? deflate(combinedContentBytes) : combinedContentBytes;
+		const contentsDict = pdfDict(compress ? { Filter: pdfName("FlateDecode") } : {});
+		objects.push({
+			num: contentsNum,
+			value: pdfStream(contentsDict, finalContentBytes)
+		});
+		const annots = page.items.filter(isLinkItem).map((link) => buildLinkAnnotDict(link));
+		if (page.notes !== void 0 && page.notes.length > 0) annots.push(buildNotesAnnotDict(page.notes));
+		const pageEntries = /* @__PURE__ */ new Map([
+			["Type", pdfName("Page")],
+			["Parent", pdfRef(pagesNum, 0)],
+			["MediaBox", pdfArray([
+				0,
+				0,
+				page.widthPt,
+				page.heightPt
+			].map((n) => pdfNum(n)))],
+			["Resources", resourcesDict],
+			["Contents", pdfRef(contentsNum, 0)]
+		]);
+		if (annots.length > 0) pageEntries.set("Annots", pdfArray(annots));
+		objects.push({
+			num: pageNum,
+			value: pdfDict(pageEntries)
+		});
+	});
+	const writer = new ByteWriter();
+	writer.writeAscii("%PDF-1.7\n");
+	const offsets = /* @__PURE__ */ new Map();
+	for (const { num, value } of objects) {
+		offsets.set(num, writer.length);
+		writer.writeAscii(`${num} 0 obj\n`);
+		writeObject(writer, value);
+		writer.writeAscii("\nendobj\n");
+	}
+	const maxObjNum = nextObjNum - 1;
+	const xrefOffset = writer.length;
+	writer.writeAscii("xref\n");
+	writer.writeAscii(`0 ${maxObjNum + 1}\n`);
+	writer.writeAscii(xrefEntry(0, 65535, false));
+	for (let num = 1; num <= maxObjNum; num++) {
+		const offset = offsets.get(num);
+		if (offset === void 0) throw new Error(`object ${num} was allocated but never written -- this is a writePdf internal invariant violation`);
+		writer.writeAscii(xrefEntry(offset, 0, true));
+	}
+	writer.writeAscii("trailer\n");
+	writeObject(writer, pdfDict({
+		Size: pdfNum(maxObjNum + 1),
+		Root: pdfRef(catalogNum, 0),
+		Info: pdfRef(infoNum, 0)
+	}));
+	writer.writeAscii("\nstartxref\n");
+	writer.writeAscii(`${xrefOffset}\n`);
+	writer.writeAscii("%%EOF");
+	return writer.toBytes();
+}
+//#endregion
+export { NOTES_ANNOTATION_AUTHOR, writePdf };