reamkit 1.1.0 → 1.3.0

package/dist/esm/pdf/encryption.d.ts

@@ -0,0 +1,34 @@
+import { PdfValue } from './objects.js';
+export interface PdfPermissions {
+    /** Bit 3 — print the document (default true). */
+    readonly printing?: boolean;
+    /** Bit 4 — modify contents (default true). */
+    readonly modifying?: boolean;
+    /** Bit 5 — copy text and graphics (default true). */
+    readonly copying?: boolean;
+    /** Bit 6 — add/modify annotations (default true). */
+    readonly annotating?: boolean;
+    /** Bit 9 — fill in form fields (default true). */
+    readonly fillingForms?: boolean;
+    /** Bit 10 — extraction for accessibility (default true; forced by PDF/UA). */
+    readonly contentAccessibility?: boolean;
+    /** Bit 11 — assemble (insert/rotate/delete pages) (default true). */
+    readonly documentAssembly?: boolean;
+}
+export interface PdfEncryptOptions {
+    /** Required to OPEN the document. Empty string = opens without a prompt. */
+    readonly userPassword?: string;
+    /** Overrides the permission restrictions. Defaults to the user password. */
+    readonly ownerPassword?: string;
+    readonly permissions?: PdfPermissions;
+}
+export interface PreparedEncryption {
+    readonly fileKey: Uint8Array;
+    readonly encryptDict: PdfValue;
+}
+export declare function permissionBits(p: PdfPermissions | undefined): number;
+export declare function aesCbcNoPadDecrypt(key: Uint8Array, iv: Uint8Array, data: Uint8Array): Promise<Uint8Array>;
+export declare function hardHash(password: Uint8Array, salt: Uint8Array, userData: Uint8Array): Promise<Uint8Array>;
+export declare function preparePdfEncryption(options: PdfEncryptOptions): Promise<PreparedEncryption>;
+export declare function decryptBytes(fileKey: Uint8Array, data: Uint8Array): Promise<Uint8Array>;
+export declare function encryptObjectGraph(value: PdfValue, fileKey: Uint8Array): Promise<PdfValue>;

package/dist/esm/pdf/encryption.js

@@ -0,0 +1,143 @@
+import { PdfHexString, PdfStream, dict, name } from "./objects.js";
+//#region src/pdf/encryption.ts
+var encoder = new TextEncoder();
+var subtle = globalThis.crypto.subtle;
+function permissionBits(p) {
+	let bits = -4;
+	const off = (bit) => bits &= ~(1 << bit - 1);
+	if (p?.printing === false) {
+		off(3);
+		off(12);
+	}
+	if (p?.modifying === false) off(4);
+	if (p?.copying === false) off(5);
+	if (p?.annotating === false) off(6);
+	if (p?.fillingForms === false) off(9);
+	if (p?.contentAccessibility === false) off(10);
+	if (p?.documentAssembly === false) off(11);
+	return bits | 0;
+}
+function passwordBytes(password) {
+	return encoder.encode(password).slice(0, 127);
+}
+function concat(...parts) {
+	const out = new Uint8Array(parts.reduce((s, p) => s + p.length, 0));
+	let off = 0;
+	for (const p of parts) {
+		out.set(p, off);
+		off += p.length;
+	}
+	return out;
+}
+async function sha(algo, data) {
+	return new Uint8Array(await subtle.digest(algo, data));
+}
+async function aesCbcNoPad(key, iv, data) {
+	const k = await subtle.importKey("raw", key, "AES-CBC", false, ["encrypt"]);
+	return new Uint8Array(await subtle.encrypt({
+		name: "AES-CBC",
+		iv
+	}, k, data)).slice(0, data.length);
+}
+async function hardHash(password, salt, userData) {
+	let k = await sha("SHA-256", concat(password, salt, userData));
+	for (let round = 0;; round++) {
+		const block = concat(password, k, userData);
+		const k1 = new Uint8Array(block.length * 64);
+		for (let i = 0; i < 64; i++) k1.set(block, i * block.length);
+		const e = await aesCbcNoPad(k.slice(0, 16), k.slice(16, 32), k1);
+		let mod = 0;
+		for (let i = 0; i < 16; i++) mod = (mod + e[i]) % 3;
+		k = (await sha(mod === 0 ? "SHA-256" : mod === 1 ? "SHA-384" : "SHA-512", e)).slice(0, 64);
+		if (round >= 63 && e[e.length - 1] <= round - 31) break;
+	}
+	return k.slice(0, 32);
+}
+async function preparePdfEncryption(options) {
+	const user = passwordBytes(options.userPassword ?? "");
+	const owner = passwordBytes(options.ownerPassword ?? options.userPassword ?? "");
+	const fileKey = new Uint8Array(32);
+	globalThis.crypto.getRandomValues(fileKey);
+	const salts = new Uint8Array(36);
+	globalThis.crypto.getRandomValues(salts);
+	const uvs = salts.slice(0, 8);
+	const uks = salts.slice(8, 16);
+	const ovs = salts.slice(16, 24);
+	const oks = salts.slice(24, 32);
+	const U = concat(await hardHash(user, uvs, new Uint8Array(0)), uvs, uks);
+	const UE = await aesCbcNoPad(await hardHash(user, uks, new Uint8Array(0)), new Uint8Array(16), fileKey);
+	const O = concat(await hardHash(owner, ovs, U), ovs, oks);
+	const OE = await aesCbcNoPad(await hardHash(owner, oks, U), new Uint8Array(16), fileKey);
+	const p = permissionBits(options.permissions);
+	const permsPlain = new Uint8Array(16);
+	new DataView(permsPlain.buffer).setInt32(0, p, true);
+	permsPlain.set([
+		255,
+		255,
+		255,
+		255
+	], 4);
+	permsPlain.set([
+		84,
+		97,
+		100,
+		98
+	], 8);
+	permsPlain.set(salts.slice(32, 36), 12);
+	const perms = await aesCbcNoPad(fileKey, new Uint8Array(16), permsPlain);
+	return {
+		fileKey,
+		encryptDict: dict({
+			Filter: name("Standard"),
+			V: 5,
+			R: 6,
+			Length: 256,
+			CF: dict({ StdCF: dict({
+				CFM: name("AESV3"),
+				AuthEvent: name("DocOpen"),
+				Length: 32
+			}) }),
+			StmF: name("StdCF"),
+			StrF: name("StdCF"),
+			U: new PdfHexString(U),
+			UE: new PdfHexString(UE),
+			O: new PdfHexString(O),
+			OE: new PdfHexString(OE),
+			P: p,
+			Perms: new PdfHexString(perms),
+			EncryptMetadata: true
+		})
+	};
+}
+async function encryptBytes(fileKey, data) {
+	const iv = new Uint8Array(16);
+	globalThis.crypto.getRandomValues(iv);
+	const k = await subtle.importKey("raw", fileKey, "AES-CBC", false, ["encrypt"]);
+	return concat(iv, new Uint8Array(await subtle.encrypt({
+		name: "AES-CBC",
+		iv
+	}, k, data)));
+}
+async function encryptObjectGraph(value, fileKey) {
+	if (typeof value === "string") return new PdfHexString(await encryptBytes(fileKey, encoder.encode(value)));
+	if (value instanceof PdfHexString) return new PdfHexString(await encryptBytes(fileKey, value.bytes));
+	if (value instanceof PdfStream) {
+		const data = await encryptBytes(fileKey, value.data);
+		const d = new Map(value.dict);
+		d.set("Length", data.length);
+		return new PdfStream(d, data);
+	}
+	if (Array.isArray(value)) {
+		const out = [];
+		for (const v of value) out.push(await encryptObjectGraph(v, fileKey));
+		return out;
+	}
+	if (value instanceof Map) {
+		const out = /* @__PURE__ */ new Map();
+		for (const [k, v] of value) out.set(k, await encryptObjectGraph(v, fileKey));
+		return out;
+	}
+	return value;
+}
+//#endregion
+export { encryptObjectGraph, preparePdfEncryption };

package/dist/esm/pdf/index.d.ts

@@ -1,6 +1,7 @@
 export { renderPlainTextPdf } from './text-page-renderer.js';
 export type { TextRenderOptions, FontInput } from './text-page-renderer.js';
-export { renderStyledPdf } from './styled-page-renderer.js';
+export { renderStyledPdf, renderStyledPdfEncrypted } from './styled-page-renderer.js';
+export type { PdfEncryptOptions, PdfPermissions } from './encryption.js';
 export type { DocumentInfo, StyledRenderOptions, PdfALevel } from './styled-page-renderer.js';
 export { signPdf } from './signature.js';
 export type { SignaturePlaceholder, SignerCredentials, SignatureOptions } from './signature.js';

package/dist/esm/pdf/struct-tree.d.ts

@@ -1,6 +1,6 @@
 import { PdfRef } from './objects.js';
 import { PdfDocument } from './writer.js';
-export type StructType = 'Document' | 'Part' | 'Sect' | 'H1' | 'H2' | 'H3' | 'H4' | 'H5' | 'H6' | 'P' | 'L' | 'LI' | 'Lbl' | 'LBody' | 'Table' | 'TR' | 'TH' | 'TD' | 'Caption' | 'Figure' | 'Span';
+export type StructType = 'Document' | 'Part' | 'Sect' | 'H1' | 'H2' | 'H3' | 'H4' | 'H5' | 'H6' | 'P' | 'L' | 'LI' | 'Lbl' | 'LBody' | 'Table' | 'TR' | 'TH' | 'TD' | 'Caption' | 'Figure' | 'Link' | 'Note' | 'Span';
 interface Mcref {
     readonly pageIndex: number;
     readonly mcid: number;
@@ -10,6 +10,10 @@ export declare class StructNode {
     type: StructType;
     readonly children: Array<StructNode>;
     readonly mcrefs: Array<Mcref>;
+    readonly objrs: Array<{
+        readonly annotRef: PdfRef;
+        readonly pageIndex: number;
+    }>;
     parent: StructNode | null;
     ref: PdfRef | null;
     alt: string | null;
@@ -26,6 +30,8 @@ export declare class StructTreeBuilder {
     create(type: StructType, parent: StructNode | null): StructNode;
     node(id: number): StructNode;
     addMcref(nodeId: number, pageIndex: number, mcid: number): void;
+    private readonly annotParents;
+    addAnnotParent(key: number, nodeId: number): void;
     emit(doc: PdfDocument, pageRefs: ReadonlyArray<PdfRef>): PdfRef;
 }
 export {};

package/dist/esm/pdf/struct-tree.js

@@ -3,6 +3,7 @@ import { PDF_NULL, dict, name, unicodeString } from "./objects.js";
 var StructNode = class {
 	children = [];
 	mcrefs = [];
+	objrs = [];
 	parent = null;
 	ref = null;
 	alt = null;
@@ -39,6 +40,13 @@ var StructTreeBuilder = class {
 			mcid
 		});
 	}
+	annotParents = [];
+	addAnnotParent(key, nodeId) {
+		this.annotParents.push({
+			key,
+			nodeId
+		});
+	}
 	emit(doc, pageRefs) {
 		const order = [];
 		const walk = (n) => {
@@ -52,6 +60,7 @@ var StructTreeBuilder = class {
 				Type: name("StructElem"),
 				S: name(n.type)
 			});
+			if (n.type === "Note") d.set("ID", `note-${n.id}`);
 			n.ref = doc.add(d);
 			dicts.set(n.id, d);
 		}
@@ -60,7 +69,7 @@ var StructTreeBuilder = class {
 		for (const n of order) {
 			const d = dicts.get(n.id);
 			d.set("P", n.parent ? n.parent.ref : rootRef);
-			const firstPage = n.mcrefs.length > 0 ? n.mcrefs[0].pageIndex : void 0;
+			const firstPage = n.mcrefs.length > 0 ? n.mcrefs[0].pageIndex : n.objrs.length > 0 ? n.objrs[0].pageIndex : void 0;
 			if (firstPage !== void 0) d.set("Pg", pageRefs[firstPage]);
 			const kids = [];
 			for (const c of n.children) kids.push(c.ref);
@@ -69,6 +78,11 @@ var StructTreeBuilder = class {
 				Pg: pageRefs[m.pageIndex],
 				MCID: m.mcid
 			}));
+			for (const o of n.objrs) kids.push(dict({
+				Type: name("OBJR"),
+				Pg: pageRefs[o.pageIndex],
+				Obj: o.annotRef
+			}));
 			if (kids.length === 1) d.set("K", kids[0]);
 			else if (kids.length > 1) d.set("K", kids);
 			if (n.alt !== null) d.set("Alt", unicodeString(n.alt));
@@ -90,14 +104,16 @@ var StructTreeBuilder = class {
 			}
 			arr[m.mcid] = n.ref;
 		}
-		const sortedKeys = [...perPage.keys()].sort((a, b) => a - b);
-		const nums = [];
-		for (const k of sortedKeys) {
-			const arr = perPage.get(k);
+		const entries = /* @__PURE__ */ new Map();
+		for (const [k, arr] of perPage) {
 			const dense = [];
 			for (let i = 0; i < arr.length; i++) dense.push(arr[i] ?? PDF_NULL);
-			nums.push(k, dense);
+			entries.set(k, dense);
 		}
+		for (const a of this.annotParents) entries.set(a.key, this.node(a.nodeId).ref);
+		const sortedKeys = [...entries.keys()].sort((a, b) => a - b);
+		const nums = [];
+		for (const k of sortedKeys) nums.push(k, entries.get(k));
 		const parentTreeRef = doc.add(dict({ Nums: nums }));
 		rootDict.set("K", this.root.ref);
 		rootDict.set("ParentTree", parentTreeRef);

package/dist/esm/pdf/styled-page-emitter.d.ts

@@ -1,7 +1,9 @@
 import { LaidOutPdfDocument, StyledRenderOptions } from '../layout/styled-layout.js';
 import { PdfDocument } from './writer.js';
-type EmitOptions = Pick<StyledRenderOptions, 'attachments' | 'info' | 'language' | 'signaturePlaceholder'>;
+import { PdfEncryptOptions } from './encryption.js';
+type EmitOptions = Pick<StyledRenderOptions, 'attachments' | 'info' | 'language' | 'pdfUA' | 'signaturePlaceholder'>;
 export declare function emitStyledPdf(laid: LaidOutPdfDocument, options: EmitOptions, doc: PdfDocument): Uint8Array;
+export declare function emitStyledPdfEncrypted(laid: LaidOutPdfDocument, options: EmitOptions, doc: PdfDocument, encrypt: PdfEncryptOptions): Promise<Uint8Array>;
 export interface PageTagging {
     next: number;
     assigned: boolean;

package/dist/esm/pdf/styled-page-emitter.js

@@ -1,10 +1,12 @@
 import { dict, name, ref, stream, unicodeString } from "./objects.js";
 import { embedTtfFont } from "./cid-font.js";
+import { preparePdfEncryption } from "./encryption.js";
 import { reorderVisual } from "../core/bidi/algorithm.js";
 import { reverseByCodePoint } from "../core/bidi/index.js";
 import "../layout/styled-layout.js";
 import { paintPlan } from "../layout/page-doc.js";
 import { emitVectorShape } from "./vector-graphics.js";
+import { sanitizeHref } from "../core/links.js";
 import { embedAssociatedFile } from "./embedded-file.js";
 import { buildSrgbIccProfile } from "./icc-profile.js";
 import { addImage } from "./image-xobject.js";
@@ -13,8 +15,27 @@ import { buildXmpPacket } from "./xmp.js";
 //#region src/pdf/styled-page-emitter.ts
 var encoder = new TextEncoder();
 function emitStyledPdf(laid, options, doc) {
+	const a = assembleStyledPdf(laid, options, doc);
+	return doc.build(a.catalogRef, a.infoRef, a.buildOptions);
+}
+async function emitStyledPdfEncrypted(laid, options, doc, encrypt) {
+	const a = assembleStyledPdf(laid, options, doc);
+	const prepared = await preparePdfEncryption(encrypt);
+	await doc.encryptAll(prepared.fileKey);
+	const encryptRef = doc.add(prepared.encryptDict);
+	return doc.build(a.catalogRef, a.infoRef, {
+		...a.buildOptions,
+		id: true,
+		encrypt: encryptRef
+	});
+}
+function assembleStyledPdf(laid, options, doc) {
 	const { pages: renderedPages } = laid;
 	const { structBuilder, sectionCtxs, pdfaProfile, tagged } = laid.pdf;
+	const docInfo = options.pdfUA && !options.info?.title ? {
+		...options.info,
+		title: "Untitled document"
+	} : options.info;
 	const embeddedFonts = embedFontResources(doc, laid, pdfaProfile);
 	const embeddedImages = embedImageResources(doc, laid);
 	const pagesDict = dict({
@@ -24,6 +45,8 @@ function emitStyledPdf(laid, options, doc) {
 	});
 	const pagesRef = doc.add(pagesDict);
 	let firstPageDict;
+	let firstPageAnnots;
+	let annotParentCount = 0;
 	const fontResourceDict = buildFontResourceDict(laid.fontResources, embeddedFonts);
 	const xobjectResourceDict = buildXObjectResourceDict(laid.imageResources, embeddedImages);
 	const resourcesDict = dict({
@@ -43,6 +66,7 @@ function emitStyledPdf(laid, options, doc) {
 		});
 	}
 	const pageRefs = [];
+	const referencedAnchors = /* @__PURE__ */ new Set();
 	renderedPages.forEach((page, pageIndex) => {
 		let pageTagging;
 		if (structBuilder) {
@@ -54,7 +78,7 @@ function emitStyledPdf(laid, options, doc) {
 				tagFor: (structId) => builder.node(structId).type
 			};
 		}
-		const contentBytes = emitPageContent(page, pageTagging);
+		const { content: contentBytes, links } = emitPageContent(page, pageTagging);
 		const contentsRef = doc.add(stream({}, contentBytes));
 		const pageEntries = {
 			Type: name("Page"),
@@ -68,6 +92,53 @@ function emitStyledPdf(laid, options, doc) {
 			Resources: resourcesDict,
 			Contents: ref(contentsRef.id)
 		};
+		if (links.length > 0) {
+			const annots = [];
+			for (const l of links) {
+				if (structBuilder && l.structId === void 0) continue;
+				const entries = {
+					Type: name("Annot"),
+					Subtype: name("Link"),
+					Rect: [
+						l.rect[0],
+						l.rect[1],
+						l.rect[2],
+						l.rect[3]
+					],
+					Border: [
+						0,
+						0,
+						0
+					],
+					F: 4,
+					A: l.href !== void 0 ? dict({
+						S: name("URI"),
+						URI: l.href
+					}) : dict({
+						S: name("GoTo"),
+						D: l.anchor ?? ""
+					}),
+					Contents: l.text !== "" ? l.text : l.href ?? l.anchor ?? ""
+				};
+				if (l.anchor !== void 0) referencedAnchors.add(l.anchor);
+				if (structBuilder && l.structId !== void 0) entries["StructParent"] = renderedPages.length + annotParentCount;
+				const annotRef = doc.add(dict(entries));
+				if (structBuilder && l.structId !== void 0) {
+					const linkNode = structBuilder.create("Link", structBuilder.node(l.structId));
+					linkNode.objrs.push({
+						annotRef,
+						pageIndex
+					});
+					structBuilder.addAnnotParent(renderedPages.length + annotParentCount, linkNode.id);
+					annotParentCount++;
+				}
+				annots.push(ref(annotRef.id));
+			}
+			if (annots.length > 0) {
+				pageEntries["Annots"] = annots;
+				if (pageIndex === 0) firstPageAnnots = annots;
+			}
+		}
 		if (transparencyGroup) pageEntries["Group"] = transparencyGroup;
 		if (pageTagging?.assigned) {
 			pageEntries["StructParents"] = pageIndex;
@@ -98,29 +169,28 @@ function emitStyledPdf(laid, options, doc) {
 	}
 	pagesDict.set("Count", pageRefs.length);
 	pagesDict.set("Kids", pageRefs);
+	const namesTreeEntries = {};
 	const catalogEntries = {
 		Type: name("Catalog"),
 		Pages: ref(pagesRef.id)
 	};
-	if (pdfaProfile) {
-		catalogEntries["OutputIntents"] = [ref(doc.add(dict({
-			Type: name("OutputIntent"),
-			S: name("GTS_PDFA1"),
-			OutputConditionIdentifier: "sRGB",
-			Info: "sRGB IEC61966-2.1",
-			DestOutputProfile: ref(pdfaIccRef.id)
-		})).id)];
-		catalogEntries["Metadata"] = ref(doc.add(stream({
-			Type: name("Metadata"),
-			Subtype: name("XML")
-		}, buildXmpPacket(xmpFromInfo(options.info, pdfaProfile)))).id);
-	}
+	if (pdfaProfile) catalogEntries["OutputIntents"] = [ref(doc.add(dict({
+		Type: name("OutputIntent"),
+		S: name("GTS_PDFA1"),
+		OutputConditionIdentifier: "sRGB",
+		Info: "sRGB IEC61966-2.1",
+		DestOutputProfile: ref(pdfaIccRef.id)
+	})).id)];
+	if (pdfaProfile || options.pdfUA) catalogEntries["Metadata"] = ref(doc.add(stream({
+		Type: name("Metadata"),
+		Subtype: name("XML")
+	}, buildXmpPacket(xmpFromInfo(docInfo, pdfaProfile, options.pdfUA === true)))).id);
 	if (tagged && structBuilder) {
 		const structRootRef = structBuilder.emit(doc, pageRefs);
 		catalogEntries["MarkInfo"] = dict({ Marked: true });
 		catalogEntries["StructTreeRoot"] = ref(structRootRef.id);
 		catalogEntries["Lang"] = options.language ?? "en-US";
-		if (options.info?.title) catalogEntries["ViewerPreferences"] = dict({ DisplayDocTitle: true });
+		if (docInfo?.title) catalogEntries["ViewerPreferences"] = dict({ DisplayDocTitle: true });
 	}
 	if (options.attachments?.length && (!pdfaProfile || pdfaProfile.part === 3)) {
 		const embedded = options.attachments.map((file) => ({
@@ -131,25 +201,48 @@ function emitStyledPdf(laid, options, doc) {
 		const sorted = [...embedded].sort((a, b) => a.file.name < b.file.name ? -1 : a.file.name > b.file.name ? 1 : 0);
 		const names = [];
 		for (const e of sorted) names.push(e.file.name, ref(e.ref.id));
-		catalogEntries["Names"] = dict({ EmbeddedFiles: ref(doc.add(dict({ Names: names })).id) });
+		namesTreeEntries["EmbeddedFiles"] = ref(doc.add(dict({ Names: names })).id);
 	}
+	const bookmarkDests = laid.pdf.bookmarks;
+	const destNames = [...referencedAnchors].filter((n) => bookmarkDests.has(n)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	if (destNames.length > 0) {
+		const names = [];
+		for (const destName of destNames) {
+			const pos = bookmarkDests.get(destName);
+			const pageRef = pageRefs[pos.pageIdx];
+			if (!pageRef) continue;
+			names.push(destName, [
+				ref(pageRef.id),
+				name("FitH"),
+				pos.yTopPt
+			]);
+		}
+		namesTreeEntries["Dests"] = ref(doc.add(dict({ Names: names })).id);
+	}
+	if (Object.keys(namesTreeEntries).length > 0) catalogEntries["Names"] = dict(namesTreeEntries);
 	if (options.signaturePlaceholder && firstPageDict) {
 		const { fieldRef, acroForm } = addSignaturePlaceholder(doc, options.signaturePlaceholder, pageRefs[0]);
-		firstPageDict.set("Annots", [ref(fieldRef.id)]);
+		if (firstPageAnnots) firstPageAnnots.push(ref(fieldRef.id));
+		else firstPageDict.set("Annots", [ref(fieldRef.id)]);
 		catalogEntries["AcroForm"] = acroForm;
 	}
-	const catalogRef = doc.add(dict(catalogEntries));
-	const infoRef = buildInfoDict(doc, options.info);
-	return doc.build(catalogRef, infoRef, { ...pdfaProfile ? {
-		version: pdfaProfile.version,
-		id: true
-	} : {} });
+	return {
+		catalogRef: doc.add(dict(catalogEntries)),
+		infoRef: buildInfoDict(doc, docInfo),
+		buildOptions: { ...pdfaProfile ? {
+			version: pdfaProfile.version,
+			id: true
+		} : {} }
+	};
 }
 var DEFAULT_PRODUCER = "Ream";
-function xmpFromInfo(info, p) {
+function xmpFromInfo(info, p, pdfUA = false) {
 	return {
-		pdfaPart: p ? String(p.part) : "1",
-		pdfaConformance: p ? p.level.toUpperCase() : "B",
+		...p ? {
+			pdfaPart: String(p.part),
+			pdfaConformance: p.level.toUpperCase()
+		} : {},
+		...pdfUA ? { pdfuaPart: "1" } : {},
 		producer: info?.producer ?? DEFAULT_PRODUCER,
 		...info?.title ? { title: info.title } : {},
 		...info?.author ? { author: info.author } : {},
@@ -195,14 +288,14 @@ function defaultPageCtx() {
 		contentWidth: 451,
 		pageContentHeight: 698,
 		headerSet: {
-			default: [],
-			first: [],
-			even: []
+			default: { commands: [] },
+			first: { commands: [] },
+			even: { commands: [] }
 		},
 		footerSet: {
-			default: [],
-			first: [],
-			even: []
+			default: { commands: [] },
+			first: { commands: [] },
+			even: { commands: [] }
 		},
 		titlePg: false,
 		evenAndOddHeaders: false
@@ -270,7 +363,11 @@ function emitTaggedRuns(out, cmds, tagging, body) {
 }
 function emitPageContent(page, tagging) {
 	const commands = page.commands;
-	if (commands.length === 0) return new Uint8Array(0);
+	const links = [];
+	if (commands.length === 0) return {
+		content: new Uint8Array(0),
+		links
+	};
 	const H = page.height;
 	const out = [];
 	const plan = paintPlan(commands);
@@ -453,6 +550,47 @@ function emitPageContent(page, tagging) {
 			const line = cmd.line;
 			const originX = cmd.originX;
 			const baselineY = H - cmd.baselineY;
+			const lineFs = line.maxFontSizePt || 12;
+			const linkAscent = Math.max(lineFs, line.mathAscentPt ?? 0);
+			const linkDescent = Math.max(lineFs * .2, line.mathDescentPt ?? 0);
+			let linkHref;
+			let linkAnchor;
+			let linkText = "";
+			let linkX0 = 0;
+			let linkX1 = 0;
+			const flushLink = () => {
+				if (linkHref === void 0 && linkAnchor === void 0) return;
+				const safe = linkHref !== void 0 ? sanitizeHref(linkHref) : void 0;
+				const target = safe !== void 0 ? { href: safe } : linkAnchor !== void 0 ? { anchor: linkAnchor } : void 0;
+				if (target) links.push({
+					...target,
+					text: linkText.trim(),
+					rect: [
+						linkX0,
+						baselineY - linkDescent,
+						linkX1,
+						baselineY + linkAscent
+					],
+					...cmd.structId !== void 0 ? { structId: cmd.structId } : {}
+				});
+				linkHref = void 0;
+				linkAnchor = void 0;
+				linkText = "";
+			};
+			const trackLink = (href, anchor, text, x0, x1) => {
+				if (href !== linkHref || anchor !== linkAnchor) {
+					flushLink();
+					if (href !== void 0 || anchor !== void 0) {
+						linkHref = href;
+						linkAnchor = anchor;
+						linkX0 = x0;
+					}
+				}
+				if (href !== void 0 || anchor !== void 0) {
+					linkX1 = x1;
+					linkText += text;
+				}
+			};
 			const extraPerSpace = computeJustifyExtra(line);
 			const hasImageToken = line.tokens.some((t) => t.kind === "image");
 			const hasMathToken = line.tokens.some((t) => t.kind === "math");
@@ -467,11 +605,13 @@ function emitPageContent(page, tagging) {
 				for (const ti of order) {
 					const tok = line.tokens[ti];
 					if (tok.kind === "image") {
+						flushLink();
 						emitImageToken(tok, x, baselineY);
 						x += tok.widthPt;
 						continue;
 					}
 					if (tok.kind === "math") {
+						flushLink();
 						emitMathToken(tok, x, baselineY);
 						x += tok.widthPt;
 						continue;
@@ -483,21 +623,28 @@ function emitPageContent(page, tagging) {
 					switchFontIfNeeded(tok);
 					out.push(`1 0 0 1 ${formatNumber(x)} ${formatNumber(baselineY)} Tm`);
 					out.push(`<${encodeToken(tok)}> Tj`);
+					const tokenX0 = x;
 					x += tok.widthPt;
 					if (tok.isSpace) x += extraPerSpace;
+					trackLink(tok.href, tok.anchor, tok.text, tokenX0, x);
 				}
+				flushLink();
 			} else {
 				if (!inBT) {
 					out.push("BT");
 					inBT = true;
 				}
 				out.push(`1 0 0 1 ${formatNumber(originX)} ${formatNumber(baselineY)} Tm`);
+				let x = originX;
 				for (const tok of line.tokens) {
 					if (tok.kind !== "text") continue;
 					switchFontIfNeeded(tok);
 					const hex = tok.font.measure.encodeTextAsCidHex(tok.text);
 					out.push(`<${hex}> Tj`);
+					trackLink(tok.href, tok.anchor, tok.text, x, x + tok.widthPt);
+					x += tok.widthPt;
 				}
+				flushLink();
 			}
 		};
 		if (tagging) for (const cmd of lines) {
@@ -527,7 +674,10 @@ function emitPageContent(page, tagging) {
 			if (inBT) out.push("ET");
 		}
 	}
-	return encoder.encode(out.join("\n"));
+	return {
+		content: encoder.encode(out.join("\n")),
+		links
+	};
 }
 function lineVisualOrder(line) {
 	return reorderVisual(line.tokens.map((t) => t.bidiLevel));
@@ -554,4 +704,4 @@ function formatNumber(n) {
 	return n.toFixed(3).replace(/0+$/, "").replace(/\.$/, "");
 }
 //#endregion
-export { emitStyledPdf };
+export { emitStyledPdf, emitStyledPdfEncrypted };

package/dist/esm/pdf/styled-page-renderer.d.ts

@@ -1,5 +1,6 @@
 import { BodyElement } from '../core/document-model/index.js';
 import { StyledRenderOptions } from '../layout/styled-layout.js';
 export declare function renderStyledPdf(body: ReadonlyArray<BodyElement>, options: StyledRenderOptions): Uint8Array;
+export declare function renderStyledPdfEncrypted(body: ReadonlyArray<BodyElement>, options: StyledRenderOptions): Promise<Uint8Array>;
 export * from '../layout/page-doc.js';
 export * from '../layout/styled-layout.js';