pdf-parser.js 3.0.8 → 4.5.2

package/dist/write.cjs

@@ -1,14 +1,20 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_afm_widths = require("./afm-widths-BoeTOK2r.cjs");
-const require_util_base64 = require("./util/base64.cjs");
-const require_bytes_writer = require("./bytes/writer.cjs");
+const require_afm_widths = require("./afm-widths-BTu0IDp2.cjs");
+const require_notes_annotation_author = require("./notes-annotation-author.cjs");
 const require_objects = require("./objects.cjs");
+const require_bytes_writer = require("./bytes/writer.cjs");
+const require_serialize = require("./serialize.cjs");
+const require_bytes_reader = require("./bytes/reader.cjs");
 const require_bytes_flate = require("./bytes/flate.cjs");
+const require_util_base64 = require("./util/base64.cjs");
+const require_parse = require("./parse.cjs");
 const require_util_abort = require("./util/abort.cjs");
+const require_crypto_random = require("./crypto/random.cjs");
+const require_encrypt_write = require("./encrypt-write.cjs");
 const require_image_jpeg_info = require("./image/jpeg-info.cjs");
+const require_image_ccitt_encode = require("./image/ccitt-encode.cjs");
 const require_image_png_decode = require("./image/png-decode.cjs");
 const require_embedded_font = require("./embedded-font.cjs");
-const require_serialize = require("./serialize.cjs");
 const require_content_write = require("./content-write.cjs");
 const require_embedded_font_write = require("./embedded-font-write.cjs");
 const require_font_registry = require("./font-registry.cjs");
@@ -29,6 +35,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;
@@ -139,9 +146,57 @@ function pngImageDict(width, height, colorSpace, compress) {
 	if (compress) entries.set("Filter", require_objects.pdfName("FlateDecode"));
 	return require_objects.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 = require_image_png_decode.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 = require_bytes_flate.deflate(raw.data);
+			const g4 = require_image_ccitt_encode.encodeCcittFax(bilevel, {
+				columns: raw.width,
+				rows: raw.height,
+				maxBytes: flate.length
+			});
+			if (g4 !== void 0) return {
+				dict: require_objects.pdfDict(/* @__PURE__ */ new Map([
+					["Type", require_objects.pdfName("XObject")],
+					["Subtype", require_objects.pdfName("Image")],
+					["Width", require_objects.pdfNum(raw.width)],
+					["Height", require_objects.pdfNum(raw.height)],
+					["ColorSpace", require_objects.pdfName("DeviceGray")],
+					["BitsPerComponent", require_objects.pdfNum(1)],
+					["Filter", require_objects.pdfName("CCITTFaxDecode")],
+					["DecodeParms", require_objects.pdfDict(/* @__PURE__ */ new Map([
+						["K", require_objects.pdfNum(-1)],
+						["Columns", require_objects.pdfNum(raw.width)],
+						["Rows", require_objects.pdfNum(raw.height)],
+						["BlackIs1", require_objects.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 ? require_bytes_flate.deflate(raw.data) : raw.data,
@@ -177,11 +232,59 @@ function buildLinkAnnotDict(link) {
 		})
 	});
 }
+function destinationViewArray(target) {
+	const n = (value) => value === void 0 ? require_objects.pdfNull() : require_objects.pdfNum(value);
+	if (target.kind === "xyz") return [
+		require_objects.pdfName("XYZ"),
+		n(target.leftPt),
+		n(target.topPt),
+		n(target.zoom)
+	];
+	if (target.kind === "fitH") return [require_objects.pdfName("FitH"), n(target.topPt)];
+	if (target.kind === "fitV") return [require_objects.pdfName("FitV"), n(target.leftPt)];
+	if (target.kind === "fitR") return [
+		require_objects.pdfName("FitR"),
+		n(target.leftPt),
+		n(target.bottomPt),
+		n(target.rightPt),
+		n(target.topPt)
+	];
+	if (target.kind === "fitBH") return [require_objects.pdfName("FitBH"), n(target.topPt)];
+	if (target.kind === "fitBV") return [require_objects.pdfName("FitBV"), n(target.leftPt)];
+	return [require_objects.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 [require_objects.pdfRef(targetPage.pageNum, 0), ...destinationViewArray(destination.target)];
+}
+function buildInternalLinkAnnotDict(link, doc, pageAllocs) {
+	return require_objects.pdfDict({
+		Type: require_objects.pdfName("Annot"),
+		Subtype: require_objects.pdfName("Link"),
+		Rect: require_objects.pdfArray([
+			link.xPt,
+			link.yPt,
+			link.xPt + link.widthPt,
+			link.yPt + link.heightPt
+		].map((v) => require_objects.pdfNum(v))),
+		Border: require_objects.pdfArray([
+			0,
+			0,
+			0
+		].map((v) => require_objects.pdfNum(v))),
+		Dest: require_objects.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 require_objects.pdfDict({
 		Type: require_objects.pdfName("Annot"),
@@ -193,13 +296,31 @@ function buildNotesAnnotDict(notes) {
 			0
 		].map((n) => require_objects.pdfNum(n))),
 		Contents: textToPdfString(notes),
-		T: textToPdfString(NOTES_ANNOTATION_AUTHOR),
+		T: textToPdfString(require_notes_annotation_author.NOTES_ANNOTATION_AUTHOR),
 		F: require_objects.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 parseResidueRow(residue) {
+	const reader = new require_bytes_reader.ByteReader(new TextEncoder().encode(residue.xml));
+	return require_parse.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;
@@ -272,13 +393,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", require_objects.pdfName("Catalog")], ["Pages", require_objects.pdfRef(pagesNum, 0)]];
+	if (attachmentsNamesNum !== void 0) catalogEntries.push(["Names", require_objects.pdfRef(attachmentsNamesNum, 0)]);
+	if (outlineRootNum !== void 0) catalogEntries.push(["Outlines", require_objects.pdfRef(outlineRootNum, 0)]);
+	if (layerNumByName.size > 0) {
+		const ocgRefs = [...layerNumByName.values()].map((num) => require_objects.pdfRef(num, 0));
+		const visible = [];
+		const hidden = [];
+		for (const layer of doc.layers ?? []) {
+			const num = layerNumByName.get(layer.name);
+			(layer.visible ? visible : hidden).push(require_objects.pdfRef(num, 0));
+		}
+		const defaultConfigEntries = [];
+		if (visible.length > 0) defaultConfigEntries.push(["ON", require_objects.pdfArray(visible)]);
+		if (hidden.length > 0) defaultConfigEntries.push(["OFF", require_objects.pdfArray(hidden)]);
+		catalogEntries.push(["OCProperties", require_objects.pdfDict({
+			OCGs: require_objects.pdfArray(ocgRefs),
+			D: require_objects.pdfDict(Object.fromEntries(defaultConfigEntries))
+		})]);
+	}
+	if (doc.form !== void 0 && doc.form.length > 0) catalogEntries.push(["AcroForm", require_objects.pdfDict({ Fields: require_objects.pdfArray(doc.form.map((field) => require_objects.pdfRef(formNumOf(field), 0))) })]);
+	if (structRootNum !== void 0) catalogEntries.push(["StructTreeRoot", require_objects.pdfRef(structRootNum, 0)]);
+	if (residueXmpNum !== void 0) catalogEntries.push(["Metadata", require_objects.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: require_objects.pdfDict({
-			Type: require_objects.pdfName("Catalog"),
-			Pages: require_objects.pdfRef(pagesNum, 0)
-		})
+		value: require_objects.pdfDict(Object.fromEntries(catalogEntries))
 	});
 	objects.push({
 		num: pagesNum,
@@ -292,6 +499,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", require_objects.pdfName("EmbeddedFile")]];
+		if (attachment.mimeType !== void 0) fileEntries.push(["Subtype", require_objects.pdfName(attachment.mimeType)]);
+		objects.push({
+			num: alloc.fileNum,
+			value: require_objects.pdfStream(require_objects.pdfDict(Object.fromEntries(fileEntries)), require_util_base64.base64ToBytes(attachment.base64))
+		});
+		const specEntries = [
+			["Type", require_objects.pdfName("Filespec")],
+			["F", require_objects.pdfLiteralString(new TextEncoder().encode(attachment.name))],
+			["EF", require_objects.pdfDict({ F: require_objects.pdfRef(alloc.fileNum, 0) })]
+		];
+		if (attachment.description !== void 0) specEntries.push(["Desc", require_objects.pdfLiteralString(new TextEncoder().encode(attachment.description))]);
+		objects.push({
+			num: alloc.specNum,
+			value: require_objects.pdfDict(Object.fromEntries(specEntries))
+		});
+	}
+	if (attachmentsNamesNum !== void 0) {
+		const names = [];
+		for (const [index, attachment] of (doc.attachments ?? []).entries()) {
+			names.push(require_objects.pdfLiteralString(new TextEncoder().encode(attachment.name)));
+			names.push(require_objects.pdfRef(attachmentAllocs[index].specNum, 0));
+		}
+		objects.push({
+			num: attachmentsNamesNum,
+			value: require_objects.pdfDict({ EmbeddedFiles: require_objects.pdfDict({ Names: require_objects.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", require_objects.pdfLiteralString(new TextEncoder().encode(item.title))], ["Parent", require_objects.pdfRef(parentNum, 0)]];
+				if (item.destination !== void 0) entries.push(["Dest", require_objects.pdfArray(resolveDestinationArray(doc, pageAllocs, item.destination, `outline item "${item.title}"`))]);
+				if (prevNum !== void 0) entries.push(["Prev", require_objects.pdfRef(prevNum, 0)]);
+				if (siblingNums.length < items.length) entries.push(["Next", require_objects.pdfRef(outlineItemNums[itemCursor], 0)]);
+				if (childNums.length > 0) {
+					entries.push(["First", require_objects.pdfRef(childNums[0], 0)]);
+					entries.push(["Last", require_objects.pdfRef(childNums[childNums.length - 1], 0)]);
+					entries.push(["Count", require_objects.pdfNum(childNums.length)]);
+				}
+				objects.push({
+					num: ownNum,
+					value: require_objects.pdfDict(Object.fromEntries(entries))
+				});
+				prevNum = ownNum;
+			}
+			return siblingNums;
+		};
+		const topLevelNums = emitItems(doc.outline ?? [], outlineRootNum);
+		objects.push({
+			num: outlineRootNum,
+			value: require_objects.pdfDict({
+				Type: require_objects.pdfName("Outlines"),
+				First: require_objects.pdfRef(topLevelNums[0], 0),
+				Last: require_objects.pdfRef(topLevelNums[topLevelNums.length - 1], 0)
+			})
+		});
+	}
+	for (const layer of doc.layers ?? []) {
+		const num = layerNumByName.get(layer.name);
+		objects.push({
+			num,
+			value: require_objects.pdfDict({
+				Type: require_objects.pdfName("OCG"),
+				Name: require_objects.pdfLiteralString(new TextEncoder().encode(layer.name))
+			})
+		});
+	}
+	const widgetRectArray = (widget) => require_objects.pdfArray([
+		widget.xPt,
+		widget.yPt,
+		widget.xPt + widget.widthPt,
+		widget.yPt + widget.heightPt
+	].map((n) => require_objects.pdfNum(n)));
+	const widgetDict = (widget) => require_objects.pdfDict({
+		Subtype: require_objects.pdfName("Widget"),
+		Rect: widgetRectArray(widget),
+		P: require_objects.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", require_objects.pdfLiteralString(new TextEncoder().encode(ownName))]);
+			if (field.alias !== void 0) entries.push(["TU", require_objects.pdfLiteralString(new TextEncoder().encode(field.alias))]);
+			if (field.fieldType === "group") entries.push(["Kids", require_objects.pdfArray(field.children.map((child) => require_objects.pdfRef(formNumOf(child), 0)))]);
+			else {
+				entries.push(["FT", require_objects.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", require_objects.pdfNum(flags)]);
+				if (field.fieldType === "text" || field.fieldType === "listbox" || field.fieldType === "combobox") {
+					if (field.value !== void 0) entries.push(["V", require_objects.pdfLiteralString(new TextEncoder().encode(field.value))]);
+				} else if (field.fieldType === "checkbox" || field.fieldType === "radio") entries.push(["V", require_objects.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", require_objects.pdfArray(field.options.map((option) => require_objects.pdfLiteralString(new TextEncoder().encode(option))))]);
+				const firstWidget = field.widgets[0];
+				if (field.widgets.length === 1 && firstWidget !== void 0) {
+					entries.push(["Subtype", require_objects.pdfName("Widget")]);
+					entries.push(["Rect", widgetRectArray(firstWidget)]);
+					entries.push(["P", require_objects.pdfRef(pageAllocs[firstWidget.pageIndex].pageNum, 0)]);
+				} else if (field.widgets.length > 1 && firstWidget !== void 0) {
+					const extraNums = formExtraWidgetNums.get(field) ?? [];
+					entries.push(["Kids", require_objects.pdfArray([widgetDict(firstWidget), ...extraNums.map((num) => require_objects.pdfRef(num, 0))])]);
+				}
+			}
+			objects.push({
+				num: formNumOf(field),
+				value: require_objects.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", require_objects.pdfName("StructElem")],
+				["S", require_objects.pdfName(element.type)],
+				["P", require_objects.pdfRef(parentNum, 0)]
+			];
+			if (element.title !== void 0) entries.push(["T", require_objects.pdfLiteralString(new TextEncoder().encode(element.title))]);
+			if (element.language !== void 0) entries.push(["Lang", require_objects.pdfLiteralString(new TextEncoder().encode(element.language))]);
+			if (element.alt !== void 0) entries.push(["Alt", require_objects.pdfLiteralString(new TextEncoder().encode(element.alt))]);
+			if (element.actualText !== void 0) entries.push(["ActualText", require_objects.pdfLiteralString(new TextEncoder().encode(element.actualText))]);
+			if (element.children.length > 0) entries.push(["K", require_objects.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 require_objects.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: require_objects.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: require_objects.pdfStream(require_objects.pdfDict({
+			Type: require_objects.pdfName("Metadata"),
+			Subtype: require_objects.pdfName("XML")
+		}), new TextEncoder().encode(doc.source.xmp.xml))
+	});
 	for (const [standardName, alloc] of fontAllocs) {
 		const { font, descriptor } = buildFontObjects(standardName, require_objects.pdfRef(alloc.descNum, 0));
 		objects.push({
@@ -347,9 +733,10 @@ function writePdf(doc, options = {}) {
 		});
 	}
 	for (const [face, alloc] of embeddedAllocs) {
-		const subset = require_sfnt_subset.subsetSfnt(face.font, [...alloc.codePoints].sort((a, b) => a - b));
+		const usedGlyphs = require_embedded_font.collectEmbeddedGlyphs(alloc.texts, face);
+		const subset = require_sfnt_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 = require_embedded_font_write.buildEmbeddedFontObjects(face, subset, require_embedded_font.collectEmbeddedGlyphs(alloc.texts, face), {
+		const built = require_embedded_font_write.buildEmbeddedFontObjects(face, subset, usedGlyphs, {
 			cidFontRef: require_objects.pdfRef(alloc.cidFontNum, 0),
 			descriptorRef: require_objects.pdfRef(alloc.descriptorNum, 0),
 			fontFileRef: require_objects.pdfRef(alloc.fontFileNum, 0),
@@ -385,6 +772,7 @@ function writePdf(doc, options = {}) {
 	}
 	if (imageAllocs.size > 0) resourceEntries.set("XObject", require_objects.pdfDict(new Map([...imageAllocs.values()].map((alloc) => [alloc.resourceName, require_objects.pdfRef(alloc.imageNum, 0)]))));
 	const resourcesDict = require_objects.pdfDict(resourceEntries);
+	const markedStructureByPage = /* @__PURE__ */ new Map();
 	const formulasByPage = /* @__PURE__ */ new Map();
 	for (const formula of formulas) {
 		const forPage = formulasByPage.get(formula.pageIndex);
@@ -421,7 +809,14 @@ function writePdf(doc, options = {}) {
 	doc.pages.forEach((page, pageIndex) => {
 		require_util_abort.throwIfAborted(options.signal);
 		const { pageNum, contentsNum } = pageAllocs[pageIndex];
-		const { bytes: contentBytes, substitutions, missingGlyphs } = require_content_write.writeContentStream(page.items, context);
+		let pageMcid = 0;
+		const pageContext = {
+			...context,
+			nextMcid: () => pageMcid++,
+			layerObjectNumberOf: (name) => layerNumByName.get(name)
+		};
+		const { bytes: contentBytes, substitutions, missingGlyphs, markedStructure } = require_content_write.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);
@@ -436,7 +831,7 @@ function writePdf(doc, options = {}) {
 			num: contentsNum,
 			value: require_objects.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", require_objects.pdfName("Page")],
@@ -451,15 +846,59 @@ function writePdf(doc, options = {}) {
 			["Contents", require_objects.pdfRef(contentsNum, 0)]
 		]);
 		if (annots.length > 0) pageEntries.set("Annots", require_objects.pdfArray(annots));
+		if ((markedStructureByPage.get(pageIndex) ?? []).length > 0) pageEntries.set("StructParents", require_objects.pdfNum(pageIndex));
 		objects.push({
 			num: pageNum,
 			value: require_objects.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 }, () => require_objects.pdfNull());
+			for (const mark of marks) {
+				const elementNum = structElementNumById.get(mark.structureId);
+				if (elementNum !== void 0) byMcid[mark.mcid] = require_objects.pdfRef(elementNum, 0);
+			}
+			nums.push(require_objects.pdfNum(pageIndex), require_objects.pdfArray(byMcid));
+		}
+		objects.push({
+			num: structParentTreeNum,
+			value: require_objects.pdfDict({ Nums: require_objects.pdfArray(nums) })
+		});
+		const rootEntries = [
+			["Type", require_objects.pdfName("StructTreeRoot")],
+			["K", require_objects.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 require_objects.pdfRef(num, 0);
+			}))],
+			["ParentTree", require_objects.pdfRef(structParentTreeNum, 0)]
+		];
+		objects.push({
+			num: structRootNum,
+			value: require_objects.pdfDict(Object.fromEntries(rootEntries))
+		});
+	}
+	let fileId;
+	let encryptedObjects = objects;
+	if (options.encryption !== void 0 && encryptDictNum !== void 0) {
+		fileId = require_crypto_random.randomBytes(FILE_ID_BYTES);
+		const encryptor = require_encrypt_write.createStandardEncryptor(options.encryption, fileId);
+		encryptedObjects = objects.map(({ num, value }) => ({
+			num,
+			value: require_encrypt_write.encryptIndirectObject(value, num, 0, encryptor)
+		}));
+		encryptedObjects.push({
+			num: encryptDictNum,
+			value: encryptor.encryptDict
+		});
+	}
 	const writer = new require_bytes_writer.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`);
 		require_serialize.writeObject(writer, value);
@@ -475,17 +914,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", require_objects.pdfNum(maxObjNum + 1)],
+		["Root", require_objects.pdfRef(catalogNum, 0)],
+		["Info", require_objects.pdfRef(infoNum, 0)]
+	]);
+	if (fileId !== void 0 && encryptDictNum !== void 0) {
+		trailerEntries.set("ID", require_objects.pdfArray([require_objects.pdfHexString(fileId), require_objects.pdfHexString(fileId)]));
+		trailerEntries.set("Encrypt", require_objects.pdfRef(encryptDictNum, 0));
+	} else if (trailerIdRestore !== void 0) trailerEntries.set("ID", trailerIdRestore);
 	writer.writeAscii("trailer\n");
-	require_serialize.writeObject(writer, require_objects.pdfDict({
-		Size: require_objects.pdfNum(maxObjNum + 1),
-		Root: require_objects.pdfRef(catalogNum, 0),
-		Info: require_objects.pdfRef(infoNum, 0)
-	}));
+	require_serialize.writeObject(writer, require_objects.pdfDict(trailerEntries));
 	writer.writeAscii("\nstartxref\n");
 	writer.writeAscii(`${xrefOffset}\n`);
 	writer.writeAscii("%%EOF");
 	return writer.toBytes();
 }
 //#endregion
-exports.NOTES_ANNOTATION_AUTHOR = NOTES_ANNOTATION_AUTHOR;
 exports.writePdf = writePdf;

package/dist/write.d.cts

@@ -1,6 +1,7 @@
 import { LayoutDocument } from "./layout.cjs";
-import { r as EmbeddedFaceSubstitution } from "./embedded-font-BU6Jgcof.cjs";
+import { r as EmbeddedFaceSubstitution } from "./embedded-font-oc65VGlr.cjs";
 import { WinAnsiSubstitution } from "./winansi.cjs";
+import { PdfEncryptionOptions } from "./encrypt-write.cjs";
 import { FontRegistry } from "./font-registry.cjs";
 import { PositionedFormula } from "document-schema.js";
 //#region src/write.d.ts
@@ -15,8 +16,8 @@ interface WritePdfOptions {
   }) => void;
   readonly fonts?: FontRegistry;
   readonly formulas?: readonly PositionedFormula[];
+  readonly encryption?: PdfEncryptionOptions;
 }
-declare const NOTES_ANNOTATION_AUTHOR = "documents.js:notes";
 declare function writePdf(doc: LayoutDocument, options?: WritePdfOptions): Uint8Array<ArrayBuffer>;
 //#endregion
-export { NOTES_ANNOTATION_AUTHOR, WritePdfOptions, writePdf };
+export { WritePdfOptions, writePdf };

package/dist/write.d.ts

@@ -1,6 +1,7 @@
 import { LayoutDocument } from "./layout.js";
-import { r as EmbeddedFaceSubstitution } from "./embedded-font-fREdbxnr.js";
+import { r as EmbeddedFaceSubstitution } from "./embedded-font-B4p9a3O3.js";
 import { WinAnsiSubstitution } from "./winansi.js";
+import { PdfEncryptionOptions } from "./encrypt-write.js";
 import { FontRegistry } from "./font-registry.js";
 import { PositionedFormula } from "document-schema.js";
 //#region src/write.d.ts
@@ -15,8 +16,8 @@ interface WritePdfOptions {
   }) => void;
   readonly fonts?: FontRegistry;
   readonly formulas?: readonly PositionedFormula[];
+  readonly encryption?: PdfEncryptionOptions;
 }
-declare const NOTES_ANNOTATION_AUTHOR = "documents.js:notes";
 declare function writePdf(doc: LayoutDocument, options?: WritePdfOptions): Uint8Array<ArrayBuffer>;
 //#endregion
-export { NOTES_ANNOTATION_AUTHOR, WritePdfOptions, writePdf };
+export { WritePdfOptions, writePdf };