pdf-parser.js 3.0.8 → 4.5.2

package/dist/write.js

@@ -1,13 +1,19 @@
-import { a as winAnsiGlyphName, n as widthOfCode, t as STANDARD_METRICS } from "./afm-widths-Dxucrg7D.js";
-import { base64ToBytes } from "./util/base64.js";
+import { n as widthOfCode, p as winAnsiGlyphName, t as STANDARD_METRICS } from "./afm-widths-De_QMWgC.js";
+import { NOTES_ANNOTATION_AUTHOR } from "./notes-annotation-author.js";
+import { pdfArray, pdfBool, pdfDict, pdfHexString, pdfLiteralString, pdfName, pdfNull, pdfNum, pdfRef, pdfStream } from "./objects.js";
 import { ByteWriter, concatBytes } from "./bytes/writer.js";
-import { pdfArray, pdfDict, pdfHexString, pdfName, pdfNum, pdfRef, pdfStream } from "./objects.js";
+import { writeObject } from "./serialize.js";
+import { ByteReader } from "./bytes/reader.js";
 import { deflate } from "./bytes/flate.js";
+import { base64ToBytes } from "./util/base64.js";
+import { parseValue } from "./parse.js";
 import { throwIfAborted } from "./util/abort.js";
+import { randomBytes } from "./crypto/random.js";
+import { createStandardEncryptor, encryptIndirectObject } from "./encrypt-write.js";
 import { readJpegInfo } from "./image/jpeg-info.js";
+import { encodeCcittFax } from "./image/ccitt-encode.js";
 import { decodePng } from "./image/png-decode.js";
 import { collectEmbeddedGlyphs } from "./embedded-font.js";
-import { writeObject } from "./serialize.js";
 import { writeContentStream } from "./content-write.js";
 import { buildEmbeddedFontObjects } from "./embedded-font-write.js";
 import { resolveFaceWithRegistry } from "./font-registry.js";
@@ -28,6 +34,7 @@ const FLAG_SERIF = 2;
 const FLAG_NONSYMBOLIC = 32;
 const FLAG_ITALIC = 64;
 const FLAG_FORCE_BOLD = 262144;
+const FILE_ID_BYTES = 16;
 function textToPdfString(text) {
 	const bytes = new Uint8Array(2 + text.length * 2);
 	bytes[0] = 254;
@@ -138,9 +145,57 @@ function pngImageDict(width, height, colorSpace, compress) {
 	if (compress) entries.set("Filter", pdfName("FlateDecode"));
 	return pdfDict(entries);
 }
+function packBilevel(raw) {
+	const rowBytes = raw.width + 7 >> 3;
+	const packed = new Uint8Array(rowBytes * raw.height);
+	for (let y = 0; y < raw.height; y++) for (let x = 0; x < raw.width; x++) {
+		const sample = raw.data[y * raw.width + x] ?? 0;
+		if (sample !== 0 && sample !== 255) return;
+		if (sample === 255) {
+			const index = y * rowBytes + (x >> 3);
+			packed[index] = (packed[index] ?? 0) | 128 >> (x & 7);
+		}
+	}
+	return packed;
+}
 function preparePngImage(bytes, compress) {
 	const raw = decodePng(bytes);
 	const colorSpace = raw.channels === 1 ? "DeviceGray" : "DeviceRGB";
+	if (compress && raw.channels === 1 && raw.alpha === void 0) {
+		const bilevel = packBilevel(raw);
+		if (bilevel !== void 0) {
+			const flate = deflate(raw.data);
+			const g4 = encodeCcittFax(bilevel, {
+				columns: raw.width,
+				rows: raw.height,
+				maxBytes: flate.length
+			});
+			if (g4 !== void 0) return {
+				dict: pdfDict(/* @__PURE__ */ new Map([
+					["Type", pdfName("XObject")],
+					["Subtype", pdfName("Image")],
+					["Width", pdfNum(raw.width)],
+					["Height", pdfNum(raw.height)],
+					["ColorSpace", pdfName("DeviceGray")],
+					["BitsPerComponent", pdfNum(1)],
+					["Filter", pdfName("CCITTFaxDecode")],
+					["DecodeParms", pdfDict(/* @__PURE__ */ new Map([
+						["K", pdfNum(-1)],
+						["Columns", pdfNum(raw.width)],
+						["Rows", pdfNum(raw.height)],
+						["BlackIs1", pdfBool(false)]
+					]))]
+				])),
+				raw: g4,
+				alpha: void 0
+			};
+			return {
+				dict: pngImageDict(raw.width, raw.height, colorSpace, true),
+				raw: flate,
+				alpha: void 0
+			};
+		}
+	}
 	return {
 		dict: pngImageDict(raw.width, raw.height, colorSpace, compress),
 		raw: compress ? deflate(raw.data) : raw.data,
@@ -176,11 +231,59 @@ function buildLinkAnnotDict(link) {
 		})
 	});
 }
+function destinationViewArray(target) {
+	const n = (value) => value === void 0 ? pdfNull() : pdfNum(value);
+	if (target.kind === "xyz") return [
+		pdfName("XYZ"),
+		n(target.leftPt),
+		n(target.topPt),
+		n(target.zoom)
+	];
+	if (target.kind === "fitH") return [pdfName("FitH"), n(target.topPt)];
+	if (target.kind === "fitV") return [pdfName("FitV"), n(target.leftPt)];
+	if (target.kind === "fitR") return [
+		pdfName("FitR"),
+		n(target.leftPt),
+		n(target.bottomPt),
+		n(target.rightPt),
+		n(target.topPt)
+	];
+	if (target.kind === "fitBH") return [pdfName("FitBH"), n(target.topPt)];
+	if (target.kind === "fitBV") return [pdfName("FitBV"), n(target.leftPt)];
+	return [pdfName(target.kind === "fitB" ? "FitB" : "Fit")];
+}
+function resolveDestinationArray(doc, pageAllocs, name, what) {
+	const destination = doc.destinations?.find((d) => d.name === name);
+	if (destination === void 0) throw new Error(`${what} names destination "${name}", which the document's destinations table does not carry -- this is a caller-invariant violation`);
+	const targetPage = pageAllocs[destination.pageIndex];
+	if (targetPage === void 0) throw new Error(`destination "${destination.name}" names page index ${destination.pageIndex}, which is beyond the document's own pages -- this is a caller-invariant violation`);
+	return [pdfRef(targetPage.pageNum, 0), ...destinationViewArray(destination.target)];
+}
+function buildInternalLinkAnnotDict(link, doc, pageAllocs) {
+	return pdfDict({
+		Type: pdfName("Annot"),
+		Subtype: pdfName("Link"),
+		Rect: pdfArray([
+			link.xPt,
+			link.yPt,
+			link.xPt + link.widthPt,
+			link.yPt + link.heightPt
+		].map((v) => pdfNum(v))),
+		Border: pdfArray([
+			0,
+			0,
+			0
+		].map((v) => pdfNum(v))),
+		Dest: pdfArray(resolveDestinationArray(doc, pageAllocs, link.destination, "internal link"))
+	});
+}
 function isLinkItem(item) {
 	return item.kind === "link";
 }
+function isInternalLinkItem(item) {
+	return item.kind === "internalLink";
+}
 const NOTES_ANNOTATION_HIDDEN_FLAG = 2;
-const NOTES_ANNOTATION_AUTHOR = "documents.js:notes";
 function buildNotesAnnotDict(notes) {
 	return pdfDict({
 		Type: pdfName("Annot"),
@@ -199,6 +302,24 @@ function buildNotesAnnotDict(notes) {
 function xrefEntry(offset, generation, inUse) {
 	return `${offset.toString().padStart(10, "0")} ${generation.toString().padStart(5, "0")} ${inUse ? "n" : "f"} \n`;
 }
+function parseResidueRow(residue) {
+	const reader = new ByteReader(new TextEncoder().encode(residue.xml));
+	return parseValue(reader, () => {});
+}
+function objectContainsReference(obj) {
+	if (obj.kind === "ref") return true;
+	if (obj.kind === "array") return obj.items.some(objectContainsReference);
+	if (obj.kind === "dict") return [...obj.entries.values()].some(objectContainsReference);
+	if (obj.kind === "stream") return [...obj.dict.entries.values()].some(objectContainsReference);
+	return false;
+}
+function restoreResidueRow(source, key) {
+	const row = source?.[key];
+	if (row === void 0) return;
+	const parsed = parseResidueRow(row);
+	if (parsed === void 0 || objectContainsReference(parsed)) return;
+	return parsed;
+}
 function writePdf(doc, options = {}) {
 	const compress = options.compress ?? true;
 	const registry = options.fonts;
@@ -271,13 +392,99 @@ function writePdf(doc, options = {}) {
 		pageNum: nextObjNum++,
 		contentsNum: nextObjNum++
 	}));
+	const encryptDictNum = options.encryption === void 0 ? void 0 : nextObjNum++;
+	const attachmentAllocs = (doc.attachments ?? []).map(() => ({
+		fileNum: nextObjNum++,
+		specNum: nextObjNum++
+	}));
+	const attachmentsNamesNum = attachmentAllocs.length > 0 ? nextObjNum++ : void 0;
+	const outlineRootNum = (doc.outline ?? []).length > 0 ? nextObjNum++ : void 0;
+	const outlineItemNums = [];
+	if (outlineRootNum !== void 0) {
+		const countItems = (items) => {
+			let n = 0;
+			for (const item of items) n += 1 + countItems(item.children);
+			return n;
+		};
+		for (let i = 0; i < countItems(doc.outline ?? []); i += 1) outlineItemNums.push(nextObjNum++);
+	}
+	const layerNumByName = /* @__PURE__ */ new Map();
+	for (const layer of doc.layers ?? []) layerNumByName.set(layer.name, nextObjNum++);
+	const formObjectNums = [];
+	const countFieldObjects = (fields) => {
+		let n = 0;
+		for (const field of fields) n += 1 + (field.fieldType !== "group" && field.widgets.length > 1 ? field.widgets.length - 1 : 0) + countFieldObjects(field.children);
+		return n;
+	};
+	for (let i = 0; i < countFieldObjects(doc.form ?? []); i += 1) formObjectNums.push(nextObjNum++);
+	const formNumByField = /* @__PURE__ */ new Map();
+	const formExtraWidgetNums = /* @__PURE__ */ new Map();
+	let formNumCursor = 0;
+	const claimFormNums = (fields) => {
+		for (const field of fields) {
+			formNumByField.set(field, formObjectNums[formNumCursor++]);
+			if (field.fieldType !== "group" && field.widgets.length > 1) formExtraWidgetNums.set(field, field.widgets.slice(1).map(() => formObjectNums[formNumCursor++]));
+			claimFormNums(field.children);
+		}
+	};
+	claimFormNums(doc.form ?? []);
+	const formNumOf = (field) => {
+		const num = formNumByField.get(field);
+		if (num === void 0) throw new Error("AcroForm field object number was not claimed -- this is a writePdf internal invariant violation");
+		return num;
+	};
+	const structElementNumById = /* @__PURE__ */ new Map();
+	const countElements = (elements) => {
+		let n = 0;
+		for (const element of elements) {
+			structElementNumById.set(element.id, nextObjNum++);
+			n += 1 + countElements(element.children);
+		}
+		return n;
+	};
+	const structElementCount = countElements(doc.structure ?? []);
+	const structRootNum = structElementCount > 0 ? nextObjNum++ : void 0;
+	const structParentTreeNum = structElementCount > 0 ? nextObjNum++ : void 0;
+	const residueXmpNum = doc.source?.xmp !== void 0 ? nextObjNum++ : void 0;
 	const objects = [];
+	const catalogEntries = [["Type", pdfName("Catalog")], ["Pages", pdfRef(pagesNum, 0)]];
+	if (attachmentsNamesNum !== void 0) catalogEntries.push(["Names", pdfRef(attachmentsNamesNum, 0)]);
+	if (outlineRootNum !== void 0) catalogEntries.push(["Outlines", pdfRef(outlineRootNum, 0)]);
+	if (layerNumByName.size > 0) {
+		const ocgRefs = [...layerNumByName.values()].map((num) => pdfRef(num, 0));
+		const visible = [];
+		const hidden = [];
+		for (const layer of doc.layers ?? []) {
+			const num = layerNumByName.get(layer.name);
+			(layer.visible ? visible : hidden).push(pdfRef(num, 0));
+		}
+		const defaultConfigEntries = [];
+		if (visible.length > 0) defaultConfigEntries.push(["ON", pdfArray(visible)]);
+		if (hidden.length > 0) defaultConfigEntries.push(["OFF", pdfArray(hidden)]);
+		catalogEntries.push(["OCProperties", pdfDict({
+			OCGs: pdfArray(ocgRefs),
+			D: pdfDict(Object.fromEntries(defaultConfigEntries))
+		})]);
+	}
+	if (doc.form !== void 0 && doc.form.length > 0) catalogEntries.push(["AcroForm", pdfDict({ Fields: pdfArray(doc.form.map((field) => pdfRef(formNumOf(field), 0))) })]);
+	if (structRootNum !== void 0) catalogEntries.push(["StructTreeRoot", pdfRef(structRootNum, 0)]);
+	if (residueXmpNum !== void 0) catalogEntries.push(["Metadata", pdfRef(residueXmpNum, 0)]);
+	const trailerIdRestore = restoreResidueRow(doc.source, "trailer-id");
+	for (const [rowKey, catalogKey] of [
+		["viewer-preferences", "ViewerPreferences"],
+		["page-mode", "PageMode"],
+		["page-layout", "PageLayout"],
+		["output-intents", "OutputIntents"],
+		["piece-info", "PieceInfo"],
+		["legal", "Legal"],
+		["collection", "Collection"]
+	]) {
+		const restored = restoreResidueRow(doc.source, rowKey);
+		if (restored !== void 0) catalogEntries.push([catalogKey, restored]);
+	}
 	objects.push({
 		num: catalogNum,
-		value: pdfDict({
-			Type: pdfName("Catalog"),
-			Pages: pdfRef(pagesNum, 0)
-		})
+		value: pdfDict(Object.fromEntries(catalogEntries))
 	});
 	objects.push({
 		num: pagesNum,
@@ -291,6 +498,185 @@ function writePdf(doc, options = {}) {
 		num: infoNum,
 		value: buildInfoDict(doc)
 	});
+	for (const [index, attachment] of (doc.attachments ?? []).entries()) {
+		const alloc = attachmentAllocs[index];
+		const fileEntries = [["Type", pdfName("EmbeddedFile")]];
+		if (attachment.mimeType !== void 0) fileEntries.push(["Subtype", pdfName(attachment.mimeType)]);
+		objects.push({
+			num: alloc.fileNum,
+			value: pdfStream(pdfDict(Object.fromEntries(fileEntries)), base64ToBytes(attachment.base64))
+		});
+		const specEntries = [
+			["Type", pdfName("Filespec")],
+			["F", pdfLiteralString(new TextEncoder().encode(attachment.name))],
+			["EF", pdfDict({ F: pdfRef(alloc.fileNum, 0) })]
+		];
+		if (attachment.description !== void 0) specEntries.push(["Desc", pdfLiteralString(new TextEncoder().encode(attachment.description))]);
+		objects.push({
+			num: alloc.specNum,
+			value: pdfDict(Object.fromEntries(specEntries))
+		});
+	}
+	if (attachmentsNamesNum !== void 0) {
+		const names = [];
+		for (const [index, attachment] of (doc.attachments ?? []).entries()) {
+			names.push(pdfLiteralString(new TextEncoder().encode(attachment.name)));
+			names.push(pdfRef(attachmentAllocs[index].specNum, 0));
+		}
+		objects.push({
+			num: attachmentsNamesNum,
+			value: pdfDict({ EmbeddedFiles: pdfDict({ Names: pdfArray(names) }) })
+		});
+	}
+	if (outlineRootNum !== void 0 && (doc.outline ?? []).length > 0) {
+		let itemCursor = 0;
+		const emitItems = (items, parentNum) => {
+			const siblingNums = [];
+			let prevNum;
+			for (const item of items) {
+				const ownNum = outlineItemNums[itemCursor];
+				itemCursor += 1;
+				siblingNums.push(ownNum);
+				const childNums = emitItems(item.children, ownNum);
+				const entries = [["Title", pdfLiteralString(new TextEncoder().encode(item.title))], ["Parent", pdfRef(parentNum, 0)]];
+				if (item.destination !== void 0) entries.push(["Dest", pdfArray(resolveDestinationArray(doc, pageAllocs, item.destination, `outline item "${item.title}"`))]);
+				if (prevNum !== void 0) entries.push(["Prev", pdfRef(prevNum, 0)]);
+				if (siblingNums.length < items.length) entries.push(["Next", pdfRef(outlineItemNums[itemCursor], 0)]);
+				if (childNums.length > 0) {
+					entries.push(["First", pdfRef(childNums[0], 0)]);
+					entries.push(["Last", pdfRef(childNums[childNums.length - 1], 0)]);
+					entries.push(["Count", pdfNum(childNums.length)]);
+				}
+				objects.push({
+					num: ownNum,
+					value: pdfDict(Object.fromEntries(entries))
+				});
+				prevNum = ownNum;
+			}
+			return siblingNums;
+		};
+		const topLevelNums = emitItems(doc.outline ?? [], outlineRootNum);
+		objects.push({
+			num: outlineRootNum,
+			value: pdfDict({
+				Type: pdfName("Outlines"),
+				First: pdfRef(topLevelNums[0], 0),
+				Last: pdfRef(topLevelNums[topLevelNums.length - 1], 0)
+			})
+		});
+	}
+	for (const layer of doc.layers ?? []) {
+		const num = layerNumByName.get(layer.name);
+		objects.push({
+			num,
+			value: pdfDict({
+				Type: pdfName("OCG"),
+				Name: pdfLiteralString(new TextEncoder().encode(layer.name))
+			})
+		});
+	}
+	const widgetRectArray = (widget) => pdfArray([
+		widget.xPt,
+		widget.yPt,
+		widget.xPt + widget.widthPt,
+		widget.yPt + widget.heightPt
+	].map((n) => pdfNum(n)));
+	const widgetDict = (widget) => pdfDict({
+		Subtype: pdfName("Widget"),
+		Rect: widgetRectArray(widget),
+		P: pdfRef(pageAllocs[widget.pageIndex].pageNum, 0)
+	});
+	const FIELD_TYPE_PDF_NAME = {
+		text: "Tx",
+		checkbox: "Btn",
+		radio: "Btn",
+		button: "Btn",
+		listbox: "Ch",
+		combobox: "Ch",
+		signature: "Sig"
+	};
+	const emitFormFieldObjects = (fields, parentName) => {
+		for (const field of fields) {
+			const ownName = parentName.length > 0 && field.name.startsWith(`${parentName}.`) ? field.name.slice(parentName.length + 1) : field.name;
+			const entries = [];
+			if (ownName.length > 0) entries.push(["T", pdfLiteralString(new TextEncoder().encode(ownName))]);
+			if (field.alias !== void 0) entries.push(["TU", pdfLiteralString(new TextEncoder().encode(field.alias))]);
+			if (field.fieldType === "group") entries.push(["Kids", pdfArray(field.children.map((child) => pdfRef(formNumOf(child), 0)))]);
+			else {
+				entries.push(["FT", pdfName(FIELD_TYPE_PDF_NAME[field.fieldType])]);
+				const FLAG_READ_ONLY = 1;
+				const FLAG_PUSHBUTTON = 4;
+				const FLAG_RADIO = 32768;
+				const FLAG_COMBO = 131072;
+				let flags = 0;
+				if (field.readOnly === true) flags |= FLAG_READ_ONLY;
+				if (field.fieldType === "button") flags |= FLAG_PUSHBUTTON;
+				if (field.fieldType === "radio") flags |= FLAG_RADIO;
+				if (field.fieldType === "combobox") flags |= FLAG_COMBO;
+				if (flags !== 0) entries.push(["Ff", pdfNum(flags)]);
+				if (field.fieldType === "text" || field.fieldType === "listbox" || field.fieldType === "combobox") {
+					if (field.value !== void 0) entries.push(["V", pdfLiteralString(new TextEncoder().encode(field.value))]);
+				} else if (field.fieldType === "checkbox" || field.fieldType === "radio") entries.push(["V", pdfName(field.checked === false || field.value === void 0 ? field.value ?? (field.checked === true ? "Yes" : "Off") : field.value)]);
+				if (field.options !== void 0) entries.push(["Opt", pdfArray(field.options.map((option) => pdfLiteralString(new TextEncoder().encode(option))))]);
+				const firstWidget = field.widgets[0];
+				if (field.widgets.length === 1 && firstWidget !== void 0) {
+					entries.push(["Subtype", pdfName("Widget")]);
+					entries.push(["Rect", widgetRectArray(firstWidget)]);
+					entries.push(["P", pdfRef(pageAllocs[firstWidget.pageIndex].pageNum, 0)]);
+				} else if (field.widgets.length > 1 && firstWidget !== void 0) {
+					const extraNums = formExtraWidgetNums.get(field) ?? [];
+					entries.push(["Kids", pdfArray([widgetDict(firstWidget), ...extraNums.map((num) => pdfRef(num, 0))])]);
+				}
+			}
+			objects.push({
+				num: formNumOf(field),
+				value: pdfDict(Object.fromEntries(entries))
+			});
+			const extraNums = formExtraWidgetNums.get(field) ?? [];
+			for (const [index, num] of extraNums.entries()) {
+				const widget = field.widgets[index + 1];
+				objects.push({
+					num,
+					value: widgetDict(widget)
+				});
+			}
+			emitFormFieldObjects(field.children, field.name);
+		}
+	};
+	emitFormFieldObjects(doc.form ?? [], "");
+	if (structRootNum !== void 0 && structParentTreeNum !== void 0) {
+		const emitStructureElement = (element, parentNum) => {
+			const entries = [
+				["Type", pdfName("StructElem")],
+				["S", pdfName(element.type)],
+				["P", pdfRef(parentNum, 0)]
+			];
+			if (element.title !== void 0) entries.push(["T", pdfLiteralString(new TextEncoder().encode(element.title))]);
+			if (element.language !== void 0) entries.push(["Lang", pdfLiteralString(new TextEncoder().encode(element.language))]);
+			if (element.alt !== void 0) entries.push(["Alt", pdfLiteralString(new TextEncoder().encode(element.alt))]);
+			if (element.actualText !== void 0) entries.push(["ActualText", pdfLiteralString(new TextEncoder().encode(element.actualText))]);
+			if (element.children.length > 0) entries.push(["K", pdfArray(element.children.map((child) => {
+				const num = structElementNumById.get(child.id);
+				if (num === void 0) throw new Error(`structure element "${child.id}" was not allocated -- this is a writePdf internal invariant violation`);
+				return pdfRef(num, 0);
+			}))]);
+			const ownNum = structElementNumById.get(element.id);
+			if (ownNum === void 0) throw new Error(`structure element "${element.id}" was not allocated -- this is a writePdf internal invariant violation`);
+			objects.push({
+				num: ownNum,
+				value: pdfDict(Object.fromEntries(entries))
+			});
+			for (const child of element.children) emitStructureElement(child, ownNum);
+		};
+		for (const element of doc.structure ?? []) emitStructureElement(element, structRootNum);
+	}
+	if (residueXmpNum !== void 0 && doc.source?.xmp !== void 0) objects.push({
+		num: residueXmpNum,
+		value: pdfStream(pdfDict({
+			Type: pdfName("Metadata"),
+			Subtype: pdfName("XML")
+		}), new TextEncoder().encode(doc.source.xmp.xml))
+	});
 	for (const [standardName, alloc] of fontAllocs) {
 		const { font, descriptor } = buildFontObjects(standardName, pdfRef(alloc.descNum, 0));
 		objects.push({
@@ -346,9 +732,10 @@ function writePdf(doc, options = {}) {
 		});
 	}
 	for (const [face, alloc] of embeddedAllocs) {
-		const subset = subsetSfnt(face.font, [...alloc.codePoints].sort((a, b) => a - b));
+		const usedGlyphs = collectEmbeddedGlyphs(alloc.texts, face);
+		const subset = subsetSfnt(face.font, [...alloc.codePoints].sort((a, b) => a - b), [...usedGlyphs.keys()].sort((a, b) => a - b));
 		if (subset === void 0) throw new Error(`font "${face.postScriptName}" resolved to an embeddable face, but its glyph outlines could not be subsetted -- only TrueType-outline ('glyf') fonts can be embedded, so supply a TrueType face for this family or drop it from the registry`);
-		const built = buildEmbeddedFontObjects(face, subset, collectEmbeddedGlyphs(alloc.texts, face), {
+		const built = buildEmbeddedFontObjects(face, subset, usedGlyphs, {
 			cidFontRef: pdfRef(alloc.cidFontNum, 0),
 			descriptorRef: pdfRef(alloc.descriptorNum, 0),
 			fontFileRef: pdfRef(alloc.fontFileNum, 0),
@@ -384,6 +771,7 @@ function writePdf(doc, options = {}) {
 	}
 	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 markedStructureByPage = /* @__PURE__ */ new Map();
 	const formulasByPage = /* @__PURE__ */ new Map();
 	for (const formula of formulas) {
 		const forPage = formulasByPage.get(formula.pageIndex);
@@ -420,7 +808,14 @@ function writePdf(doc, options = {}) {
 	doc.pages.forEach((page, pageIndex) => {
 		throwIfAborted(options.signal);
 		const { pageNum, contentsNum } = pageAllocs[pageIndex];
-		const { bytes: contentBytes, substitutions, missingGlyphs } = writeContentStream(page.items, context);
+		let pageMcid = 0;
+		const pageContext = {
+			...context,
+			nextMcid: () => pageMcid++,
+			layerObjectNumberOf: (name) => layerNumByName.get(name)
+		};
+		const { bytes: contentBytes, substitutions, missingGlyphs, markedStructure } = writeContentStream(page.items, pageContext);
+		if (markedStructure.length > 0) markedStructureByPage.set(pageIndex, [...markedStructure]);
 		for (const substitution of substitutions) options.onSubstitution?.(substitution, { pageIndex });
 		for (const missing of missingGlyphs) options.onMissingGlyph?.(missing, { pageIndex });
 		const pageFormulas = formulasByPage.get(pageIndex);
@@ -435,7 +830,7 @@ function writePdf(doc, options = {}) {
 			num: contentsNum,
 			value: pdfStream(contentsDict, finalContentBytes)
 		});
-		const annots = page.items.filter(isLinkItem).map((link) => buildLinkAnnotDict(link));
+		const annots = [...page.items.filter(isLinkItem).map((link) => buildLinkAnnotDict(link)), ...page.items.filter(isInternalLinkItem).map((link) => buildInternalLinkAnnotDict(link, doc, pageAllocs))];
 		if (page.notes !== void 0 && page.notes.length > 0) annots.push(buildNotesAnnotDict(page.notes));
 		const pageEntries = /* @__PURE__ */ new Map([
 			["Type", pdfName("Page")],
@@ -450,15 +845,59 @@ function writePdf(doc, options = {}) {
 			["Contents", pdfRef(contentsNum, 0)]
 		]);
 		if (annots.length > 0) pageEntries.set("Annots", pdfArray(annots));
+		if ((markedStructureByPage.get(pageIndex) ?? []).length > 0) pageEntries.set("StructParents", pdfNum(pageIndex));
 		objects.push({
 			num: pageNum,
 			value: pdfDict(pageEntries)
 		});
 	});
+	if (structRootNum !== void 0 && structParentTreeNum !== void 0) {
+		const nums = [];
+		for (const [pageIndex, marks] of markedStructureByPage) {
+			const maxMcid = Math.max(...marks.map((mark) => mark.mcid));
+			const byMcid = Array.from({ length: maxMcid + 1 }, () => pdfNull());
+			for (const mark of marks) {
+				const elementNum = structElementNumById.get(mark.structureId);
+				if (elementNum !== void 0) byMcid[mark.mcid] = pdfRef(elementNum, 0);
+			}
+			nums.push(pdfNum(pageIndex), pdfArray(byMcid));
+		}
+		objects.push({
+			num: structParentTreeNum,
+			value: pdfDict({ Nums: pdfArray(nums) })
+		});
+		const rootEntries = [
+			["Type", pdfName("StructTreeRoot")],
+			["K", pdfArray((doc.structure ?? []).map((element) => {
+				const num = structElementNumById.get(element.id);
+				if (num === void 0) throw new Error(`structure element "${element.id}" was not allocated -- this is a writePdf internal invariant violation`);
+				return pdfRef(num, 0);
+			}))],
+			["ParentTree", pdfRef(structParentTreeNum, 0)]
+		];
+		objects.push({
+			num: structRootNum,
+			value: pdfDict(Object.fromEntries(rootEntries))
+		});
+	}
+	let fileId;
+	let encryptedObjects = objects;
+	if (options.encryption !== void 0 && encryptDictNum !== void 0) {
+		fileId = randomBytes(FILE_ID_BYTES);
+		const encryptor = createStandardEncryptor(options.encryption, fileId);
+		encryptedObjects = objects.map(({ num, value }) => ({
+			num,
+			value: encryptIndirectObject(value, num, 0, encryptor)
+		}));
+		encryptedObjects.push({
+			num: encryptDictNum,
+			value: encryptor.encryptDict
+		});
+	}
 	const writer = new ByteWriter();
 	writer.writeAscii("%PDF-1.7\n");
 	const offsets = /* @__PURE__ */ new Map();
-	for (const { num, value } of objects) {
+	for (const { num, value } of encryptedObjects) {
 		offsets.set(num, writer.length);
 		writer.writeAscii(`${num} 0 obj\n`);
 		writeObject(writer, value);
@@ -474,16 +913,21 @@ function writePdf(doc, options = {}) {
 		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));
 	}
+	const trailerEntries = /* @__PURE__ */ new Map([
+		["Size", pdfNum(maxObjNum + 1)],
+		["Root", pdfRef(catalogNum, 0)],
+		["Info", pdfRef(infoNum, 0)]
+	]);
+	if (fileId !== void 0 && encryptDictNum !== void 0) {
+		trailerEntries.set("ID", pdfArray([pdfHexString(fileId), pdfHexString(fileId)]));
+		trailerEntries.set("Encrypt", pdfRef(encryptDictNum, 0));
+	} else if (trailerIdRestore !== void 0) trailerEntries.set("ID", trailerIdRestore);
 	writer.writeAscii("trailer\n");
-	writeObject(writer, pdfDict({
-		Size: pdfNum(maxObjNum + 1),
-		Root: pdfRef(catalogNum, 0),
-		Info: pdfRef(infoNum, 0)
-	}));
+	writeObject(writer, pdfDict(trailerEntries));
 	writer.writeAscii("\nstartxref\n");
 	writer.writeAscii(`${xrefOffset}\n`);
 	writer.writeAscii("%%EOF");
 	return writer.toBytes();
 }
 //#endregion
-export { NOTES_ANNOTATION_AUTHOR, writePdf };
+export { writePdf };

package/dist/xmp.cjs

@@ -0,0 +1,46 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/xmp.ts
+function readXmpMetadata(packet) {
+	return {
+		...field(xmpValue(packet, "dc:title"), "title"),
+		...field(xmpValue(packet, "dc:creator"), "author"),
+		...field(xmpValue(packet, "dc:description"), "subject"),
+		...field(xmpValue(packet, "xmp:CreatorTool"), "creator"),
+		...field(xmpValue(packet, "pdf:Producer"), "producer"),
+		...field(xmpValue(packet, "xmp:CreateDate"), "createdIso"),
+		...field(xmpValue(packet, "xmp:ModifyDate"), "modifiedIso"),
+		...keywordsOf(packet)
+	};
+}
+function xmpValue(packet, element) {
+	const match = new RegExp(`<${element}(?:\\s[^>]*)?>([\\s\\S]*?)</${element}>`).exec(packet);
+	if (match === null) return;
+	const inner = match[1] ?? "";
+	const items = listItems(inner);
+	if (items.length > 0) return items;
+	const text = inner.trim();
+	return text.length > 0 ? text : void 0;
+}
+function listItems(inner) {
+	const items = [];
+	const pattern = /<rdf:li(?:\s[^>]*)?>([\s\S]*?)<\/rdf:li>/g;
+	let match;
+	while ((match = pattern.exec(inner)) !== null) {
+		const text = (match[1] ?? "").trim();
+		if (text.length > 0) items.push(text);
+	}
+	return items;
+}
+function field(value, key) {
+	if (typeof value === "string") return { [key]: value };
+	if (Array.isArray(value) && value.length > 0) return { [key]: value.join(", ") };
+	return {};
+}
+function keywordsOf(packet) {
+	const match = (/* @__PURE__ */ new RegExp("<dc:subject(?:\\s[^>]*)?>([\\s\\S]*?)</dc:subject>")).exec(packet);
+	if (match === null) return {};
+	const items = listItems(match[1] ?? "");
+	return items.length > 0 ? { keywords: items } : {};
+}
+//#endregion
+exports.readXmpMetadata = readXmpMetadata;

package/dist/xmp.d.cts

@@ -0,0 +1,14 @@
+//#region src/xmp.d.ts
+interface XmpMetadata {
+  readonly title?: string;
+  readonly author?: string;
+  readonly subject?: string;
+  readonly keywords?: string[];
+  readonly creator?: string;
+  readonly producer?: string;
+  readonly createdIso?: string;
+  readonly modifiedIso?: string;
+}
+declare function readXmpMetadata(packet: string): XmpMetadata;
+//#endregion
+export { XmpMetadata, readXmpMetadata };

package/dist/xmp.d.ts

@@ -0,0 +1,14 @@
+//#region src/xmp.d.ts
+interface XmpMetadata {
+  readonly title?: string;
+  readonly author?: string;
+  readonly subject?: string;
+  readonly keywords?: string[];
+  readonly creator?: string;
+  readonly producer?: string;
+  readonly createdIso?: string;
+  readonly modifiedIso?: string;
+}
+declare function readXmpMetadata(packet: string): XmpMetadata;
+//#endregion
+export { XmpMetadata, readXmpMetadata };