reamkit 0.1.0-alpha.0

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

@@ -0,0 +1,32 @@
+export declare const PDF_NULL: unique symbol;
+export type PdfNull = typeof PDF_NULL;
+export declare class PdfName {
+    readonly value: string;
+    constructor(value: string);
+}
+export declare class PdfRef {
+    readonly id: number;
+    readonly generation: number;
+    constructor(id: number, generation?: number);
+}
+export declare class PdfStream {
+    readonly dict: PdfDict;
+    readonly data: Uint8Array;
+    constructor(dict: PdfDict, data: Uint8Array);
+}
+export declare class PdfHexString {
+    readonly bytes: Uint8Array;
+    constructor(bytes: Uint8Array);
+}
+export declare class PdfRawToken {
+    readonly token: string;
+    constructor(token: string);
+}
+export type PdfDict = Map<string, PdfValue>;
+export type PdfArray = Array<PdfValue>;
+export type PdfValue = PdfNull | boolean | number | string | PdfName | PdfHexString | PdfRawToken | PdfArray | PdfDict | PdfRef | PdfStream;
+export declare const name: (v: string) => PdfName;
+export declare const ref: (id: number, gen?: number) => PdfRef;
+export declare const dict: (entries: Record<string, PdfValue>) => PdfDict;
+export declare const stream: (entries: Record<string, PdfValue>, data: Uint8Array) => PdfStream;
+export declare const unicodeString: (s: string) => PdfHexString;

package/dist/esm/pdf/objects.js

@@ -0,0 +1,54 @@
+//#region src/pdf/objects.ts
+var PDF_NULL = Symbol("PDF_NULL");
+var PdfName = class {
+	constructor(value) {
+		this.value = value;
+	}
+};
+var PdfRef = class {
+	constructor(id, generation = 0) {
+		this.id = id;
+		this.generation = generation;
+	}
+};
+var PdfStream = class {
+	constructor(dict, data) {
+		this.dict = dict;
+		this.data = data;
+	}
+};
+var PdfHexString = class {
+	constructor(bytes) {
+		this.bytes = bytes;
+	}
+};
+var PdfRawToken = class {
+	constructor(token) {
+		this.token = token;
+	}
+};
+var name = (v) => new PdfName(v);
+var ref = (id, gen = 0) => new PdfRef(id, gen);
+var dict = (entries) => new Map(Object.entries(entries));
+var stream = (entries, data) => new PdfStream(dict(entries), data);
+var unicodeString = (s) => {
+	const codepoints = [];
+	for (const ch of s) codepoints.push(ch.codePointAt(0));
+	const units = [];
+	for (const cp of codepoints) if (cp < 65536) units.push(cp);
+	else {
+		const adj = cp - 65536;
+		units.push(55296 + (adj >> 10));
+		units.push(56320 + (adj & 1023));
+	}
+	const out = new Uint8Array(2 + units.length * 2);
+	out[0] = 254;
+	out[1] = 255;
+	for (let i = 0; i < units.length; i++) {
+		out[2 + i * 2] = units[i] >> 8 & 255;
+		out[2 + i * 2 + 1] = units[i] & 255;
+	}
+	return new PdfHexString(out);
+};
+//#endregion
+export { PDF_NULL, PdfHexString, PdfName, PdfRawToken, PdfRef, PdfStream, dict, name, ref, stream, unicodeString };

package/dist/esm/pdf/preset-geometry.d.ts

@@ -0,0 +1,6 @@
+import { CustomGeometry } from '../document-model/index.js';
+import { PathSegment, VectorPath } from './vector-graphics.js';
+export declare function rectSegments(w: number, h: number): ReadonlyArray<PathSegment>;
+export declare function rectPath(w: number, h: number): VectorPath;
+export declare function presetPaths(preset: string, w: number, h: number, adjust: ReadonlyMap<string, number>): Array<VectorPath> | null;
+export declare function customPaths(geom: CustomGeometry, wPt: number, hPt: number): Array<VectorPath>;

package/dist/esm/pdf/preset-geometry.js

@@ -0,0 +1,199 @@
+import { PathBuilder } from "./vector-graphics.js";
+import { arcToBeziers, ellipseSegments, roundRectSegments } from "./arc-to-bezier.js";
+//#region src/pdf/preset-geometry.ts
+function rectSegments(w, h) {
+	return new PathBuilder().moveTo(0, 0).lineTo(w, 0).lineTo(w, h).lineTo(0, h).close().build().segments;
+}
+function rectPath(w, h) {
+	return { segments: rectSegments(w, h) };
+}
+function polygon(points) {
+	const b = new PathBuilder();
+	points.forEach(([x, y], i) => i === 0 ? b.moveTo(x, y) : b.lineTo(x, y));
+	return b.close().build();
+}
+var clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+var frac = (adjust, key, def) => (adjust.get(key) ?? def) / 1e5;
+function presetPaths(preset, w, h, adjust) {
+	switch (preset) {
+		case "rect": return [rectPath(w, h)];
+		case "roundRect": return [{ segments: roundRectSegments(w, h, frac(adjust, "adj", 16667) * Math.min(w, h)) }];
+		case "ellipse": return [{ segments: ellipseSegments(w, h) }];
+		case "triangle": {
+			const apexX = clamp(frac(adjust, "adj", 5e4), 0, 1) * w;
+			return [polygon([
+				[0, 0],
+				[w, 0],
+				[apexX, h]
+			])];
+		}
+		case "rtTriangle": return [polygon([
+			[0, 0],
+			[w, 0],
+			[0, h]
+		])];
+		case "diamond": return [polygon([
+			[w / 2, 0],
+			[w, h / 2],
+			[w / 2, h],
+			[0, h / 2]
+		])];
+		case "parallelogram": {
+			const s = clamp(frac(adjust, "adj", 25e3) * w, 0, w);
+			return [polygon([
+				[0, 0],
+				[w - s, 0],
+				[w, h],
+				[s, h]
+			])];
+		}
+		case "trapezoid": {
+			const t = clamp(frac(adjust, "adj", 25e3) * w, 0, w / 2);
+			return [polygon([
+				[0, 0],
+				[w, 0],
+				[w - t, h],
+				[t, h]
+			])];
+		}
+		case "pentagon": return [regularPolygon(w, h, 5)];
+		case "hexagon": {
+			const inset = clamp(frac(adjust, "adj", 25e3) * w, 0, w / 2);
+			return [polygon([
+				[inset, 0],
+				[w - inset, 0],
+				[w, h / 2],
+				[w - inset, h],
+				[inset, h],
+				[0, h / 2]
+			])];
+		}
+		case "line":
+		case "straightConnector1": return [new PathBuilder().moveTo(0, h).lineTo(w, 0).build()];
+		case "rightArrow": return [blockArrow(w, h, adjust, "right")];
+		case "leftArrow": return [blockArrow(w, h, adjust, "left")];
+		case "upArrow": return [blockArrow(w, h, adjust, "up")];
+		case "downArrow": return [blockArrow(w, h, adjust, "down")];
+		default: return null;
+	}
+}
+function customPaths(geom, wPt, hPt) {
+	const sx = geom.pathWidth > 0 ? wPt / geom.pathWidth : 1;
+	const sy = geom.pathHeight > 0 ? hPt / geom.pathHeight : 1;
+	const tx = (x) => x * sx;
+	const ty = (y) => hPt - y * sy;
+	const b = new PathBuilder();
+	let curX = 0;
+	let curY = 0;
+	for (const cmd of geom.commands) switch (cmd.cmd) {
+		case "move":
+			b.moveTo(tx(cmd.x), ty(cmd.y));
+			curX = cmd.x;
+			curY = cmd.y;
+			break;
+		case "line":
+			b.lineTo(tx(cmd.x), ty(cmd.y));
+			curX = cmd.x;
+			curY = cmd.y;
+			break;
+		case "cubic":
+			b.cubicTo(tx(cmd.x1), ty(cmd.y1), tx(cmd.x2), ty(cmd.y2), tx(cmd.x), ty(cmd.y));
+			curX = cmd.x;
+			curY = cmd.y;
+			break;
+		case "quad": {
+			const c1x = curX + 2 / 3 * (cmd.x1 - curX);
+			const c1y = curY + 2 / 3 * (cmd.y1 - curY);
+			const c2x = cmd.x + 2 / 3 * (cmd.x1 - cmd.x);
+			const c2y = cmd.y + 2 / 3 * (cmd.y1 - cmd.y);
+			b.cubicTo(tx(c1x), ty(c1y), tx(c2x), ty(c2y), tx(cmd.x), ty(cmd.y));
+			curX = cmd.x;
+			curY = cmd.y;
+			break;
+		}
+		case "arc": {
+			const st = cmd.stAng / 6e4 * (Math.PI / 180);
+			const sw = cmd.swAng / 6e4 * (Math.PI / 180);
+			const cxP = curX - cmd.wR * Math.cos(st);
+			const cyP = curY - cmd.hR * Math.sin(st);
+			b.append(arcToBeziers(tx(cxP), ty(cyP), cmd.wR * sx, cmd.hR * sy, -st, -sw));
+			curX = cxP + cmd.wR * Math.cos(st + sw);
+			curY = cyP + cmd.hR * Math.sin(st + sw);
+			break;
+		}
+		case "close":
+			b.close();
+			break;
+	}
+	return [b.build()];
+}
+function regularPolygon(w, h, n) {
+	const cx = w / 2;
+	const cy = h / 2;
+	const rx = w / 2;
+	const ry = h / 2;
+	const pts = [];
+	for (let i = 0; i < n; i++) {
+		const a = Math.PI / 2 + i * 2 * Math.PI / n;
+		pts.push([cx + rx * Math.cos(a), cy + ry * Math.sin(a)]);
+	}
+	return polygon(pts);
+}
+function blockArrow(w, h, adjust, dir) {
+	const thick = clamp(frac(adjust, "adj1", 5e4), 0, 1);
+	const head = clamp(frac(adjust, "adj2", 5e4), 0, 1);
+	if (dir === "right" || dir === "left") {
+		const sb = h * (1 - thick) / 2;
+		const st = h * (1 + thick) / 2;
+		const hl = head * w;
+		if (dir === "right") {
+			const bx = w - hl;
+			return polygon([
+				[0, sb],
+				[bx, sb],
+				[bx, 0],
+				[w, h / 2],
+				[bx, h],
+				[bx, st],
+				[0, st]
+			]);
+		}
+		const bx = hl;
+		return polygon([
+			[w, sb],
+			[bx, sb],
+			[bx, 0],
+			[0, h / 2],
+			[bx, h],
+			[bx, st],
+			[w, st]
+		]);
+	}
+	const sl = w * (1 - thick) / 2;
+	const sr = w * (1 + thick) / 2;
+	const hh = head * h;
+	if (dir === "up") {
+		const by = h - hh;
+		return polygon([
+			[sl, 0],
+			[sr, 0],
+			[sr, by],
+			[w, by],
+			[w / 2, h],
+			[0, by],
+			[sl, by]
+		]);
+	}
+	const ty = hh;
+	return polygon([
+		[sl, h],
+		[sr, h],
+		[sr, ty],
+		[w, ty],
+		[w / 2, 0],
+		[0, ty],
+		[sl, ty]
+	]);
+}
+//#endregion
+export { customPaths, presetPaths, rectPath };

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

@@ -0,0 +1,3 @@
+import { PdfValue } from './objects.js';
+export declare function serializeValue(v: PdfValue): string;
+export declare function serializeIndirectObject(id: number, generation: number, value: PdfValue): Uint8Array;

package/dist/esm/pdf/serialize.js

@@ -0,0 +1,54 @@
+import { PDF_NULL, PdfHexString, PdfName, PdfRawToken, PdfRef, PdfStream } from "./objects.js";
+//#region src/pdf/serialize.ts
+var encoder = new TextEncoder();
+var NAME_ESCAPE = /[^!-~]|[#%()/<>[\]{}]/g;
+var escapeName = (s) => s.replace(NAME_ESCAPE, (c) => `#${c.charCodeAt(0).toString(16).padStart(2, "0").toUpperCase()}`);
+var escapeLiteralString = (s) => s.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+var formatNumber = (n) => {
+	if (Number.isInteger(n)) return String(n);
+	return n.toFixed(6).replace(/0+$/, "").replace(/\.$/, "");
+};
+function serializeValue(v) {
+	if (v === PDF_NULL) return "null";
+	if (typeof v === "boolean") return v ? "true" : "false";
+	if (typeof v === "number") {
+		if (!Number.isFinite(v)) throw new Error(`Non-finite number in PDF: ${v}`);
+		return formatNumber(v);
+	}
+	if (typeof v === "string") return `(${escapeLiteralString(v)})`;
+	if (v instanceof PdfHexString) {
+		let hex = "";
+		for (const b of v.bytes) hex += b.toString(16).padStart(2, "0").toUpperCase();
+		return `<${hex}>`;
+	}
+	if (v instanceof PdfRawToken) return v.token;
+	if (v instanceof PdfName) return `/${escapeName(v.value)}`;
+	if (Array.isArray(v)) return `[${v.map(serializeValue).join(" ")}]`;
+	if (v instanceof PdfRef) return `${v.id} ${v.generation} R`;
+	if (v instanceof Map) return serializeDict(v);
+	if (v instanceof PdfStream) throw new Error("PdfStream must be emitted as an indirect object, not inlined");
+	throw new Error(`Unknown PDF value: ${String(v)}`);
+}
+function serializeDict(d) {
+	const entries = [];
+	for (const [k, v] of d) entries.push(`/${escapeName(k)} ${serializeValue(v)}`);
+	return `<<${entries.join(" ")}>>`;
+}
+function serializeIndirectObject(id, generation, value) {
+	if (value instanceof PdfStream) return serializeStreamObject(id, generation, value);
+	const body = `${id} ${generation} obj\n${serializeValue(value)}\nendobj\n`;
+	return encoder.encode(body);
+}
+function serializeStreamObject(id, generation, s) {
+	const length = s.data.byteLength;
+	if (!s.dict.has("Length")) s.dict.set("Length", length);
+	const header = encoder.encode(`${id} ${generation} obj\n${serializeDict(s.dict)}\nstream\n`);
+	const footer = encoder.encode("\nendstream\nendobj\n");
+	const out = new Uint8Array(header.length + s.data.length + footer.length);
+	out.set(header, 0);
+	out.set(s.data, header.length);
+	out.set(footer, header.length + s.data.length);
+	return out;
+}
+//#endregion
+export { serializeIndirectObject };

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

@@ -0,0 +1,25 @@
+import { PdfDict, PdfRef } from './objects.js';
+import { PdfDocument } from './writer.js';
+export interface SignaturePlaceholder {
+    readonly reason?: string;
+    readonly location?: string;
+    readonly name?: string;
+    readonly contactInfo?: string;
+    readonly signingTime?: Date;
+    readonly fieldName?: string;
+    readonly reserveBytes?: number;
+}
+export interface SignerCredentials {
+    readonly certificate: Uint8Array;
+    readonly privateKey: CryptoKey;
+    readonly algorithm?: 'rsa' | 'ecdsa';
+    readonly extraCertificates?: ReadonlyArray<Uint8Array>;
+    readonly signingTime?: Date;
+}
+export interface SignatureOptions extends SignaturePlaceholder, SignerCredentials {
+}
+export declare function addSignaturePlaceholder(doc: PdfDocument, ph: SignaturePlaceholder, pageRef: PdfRef): {
+    readonly fieldRef: PdfRef;
+    readonly acroForm: PdfDict;
+};
+export declare function signPdf(pdf: Uint8Array, cred: SignerCredentials): Promise<Uint8Array>;

package/dist/esm/pdf/signature.js

@@ -0,0 +1,126 @@
+import { PdfHexString, PdfRawToken, dict, name, ref } from "./objects.js";
+import { integer, seq } from "../crypto/asn1.js";
+import { buildPkcs7Detached } from "../crypto/cms.js";
+import "../crypto/index.js";
+//#region src/pdf/signature.ts
+var BYTE_RANGE_PLACEHOLDER = "[0 0000000000 0000000000 0000000000]";
+var DEFAULT_RESERVE_BYTES = 8192;
+function pad2(n) {
+	return n.toString().padStart(2, "0");
+}
+function pdfDate(d) {
+	return `D:${d.getUTCFullYear()}${pad2(d.getUTCMonth() + 1)}${pad2(d.getUTCDate())}${pad2(d.getUTCHours())}${pad2(d.getUTCMinutes())}${pad2(d.getUTCSeconds())}+00'00'`;
+}
+function addSignaturePlaceholder(doc, ph, pageRef) {
+	const reserve = ph.reserveBytes ?? DEFAULT_RESERVE_BYTES;
+	const sigEntries = {
+		Type: name("Sig"),
+		Filter: name("Adobe.PPKLite"),
+		SubFilter: name("adbe.pkcs7.detached"),
+		ByteRange: new PdfRawToken(BYTE_RANGE_PLACEHOLDER),
+		Contents: new PdfHexString(new Uint8Array(reserve))
+	};
+	if (ph.signingTime) sigEntries["M"] = pdfDate(ph.signingTime);
+	if (ph.reason) sigEntries["Reason"] = ph.reason;
+	if (ph.location) sigEntries["Location"] = ph.location;
+	if (ph.name) sigEntries["Name"] = ph.name;
+	if (ph.contactInfo) sigEntries["ContactInfo"] = ph.contactInfo;
+	const sigRef = doc.add(dict(sigEntries));
+	const fieldRef = doc.add(dict({
+		FT: name("Sig"),
+		Type: name("Annot"),
+		Subtype: name("Widget"),
+		T: ph.fieldName ?? "Signature1",
+		V: ref(sigRef.id),
+		P: ref(pageRef.id),
+		Rect: [
+			0,
+			0,
+			0,
+			0
+		],
+		F: 132
+	}));
+	return {
+		fieldRef,
+		acroForm: dict({
+			Fields: [ref(fieldRef.id)],
+			SigFlags: 3
+		})
+	};
+}
+function indexOfAscii(buf, needle, from = 0) {
+	const n = needle.length;
+	outer: for (let i = from; i <= buf.length - n; i++) {
+		for (let j = 0; j < n; j++) if (buf[i + j] !== needle.charCodeAt(j)) continue outer;
+		return i;
+	}
+	return -1;
+}
+function writeAscii(buf, at, s) {
+	for (let i = 0; i < s.length; i++) buf[at + i] = s.charCodeAt(i);
+}
+function getSubtle() {
+	const c = globalThis.crypto;
+	if (!c?.subtle) throw new Error("Signing requires WebCrypto (globalThis.crypto.subtle)");
+	return c.subtle;
+}
+function asData(u) {
+	return u.buffer instanceof ArrayBuffer ? u : new Uint8Array(u);
+}
+function ecdsaRawToDer(raw) {
+	const half = raw.length >> 1;
+	return seq(integer(raw.slice(0, half)), integer(raw.slice(half)));
+}
+var HEX = "0123456789ABCDEF";
+function toHex(bytes) {
+	let s = "";
+	for (const b of bytes) s += HEX[b >> 4] + HEX[b & 15];
+	return s;
+}
+async function signPdf(pdf, cred) {
+	const out = pdf.slice();
+	const brKey = indexOfAscii(out, "/ByteRange");
+	if (brKey < 0) throw new Error("signPdf: no /ByteRange placeholder found");
+	const brOpen = indexOfAscii(out, "[", brKey);
+	const brClose = indexOfAscii(out, "]", brOpen);
+	const ctOpen = indexOfAscii(out, "<", indexOfAscii(out, "/Contents", brClose));
+	const ctClose = indexOfAscii(out, ">", ctOpen);
+	if (brOpen < 0 || brClose < 0 || ctOpen < 0 || ctClose < 0) throw new Error("signPdf: malformed signature placeholder");
+	const a = 0;
+	const b = ctOpen + 1;
+	const c = ctClose;
+	const d = out.length - ctClose;
+	const brStr = `[${a} ${b} ${c} ${d}]`;
+	const brWidth = brClose - brOpen + 1;
+	if (brStr.length > brWidth) throw new Error("signPdf: /ByteRange placeholder too small");
+	writeAscii(out, brOpen, brStr.slice(0, -1) + " ".repeat(brWidth - brStr.length) + "]");
+	const segment = new Uint8Array(b + d);
+	segment.set(out.subarray(a, a + b), 0);
+	segment.set(out.subarray(c, c + d), b);
+	const subtle = getSubtle();
+	const digest = new Uint8Array(await subtle.digest("SHA-256", asData(segment)));
+	const signingTime = cred.signingTime ?? /* @__PURE__ */ new Date();
+	const isEcdsa = cred.algorithm === "ecdsa";
+	const cms = await buildPkcs7Detached({
+		certificate: cred.certificate,
+		...cred.extraCertificates ? { extraCertificates: cred.extraCertificates } : {},
+		messageDigest: digest,
+		signingTime,
+		signatureAlgorithm: isEcdsa ? "ecdsa" : "rsa",
+		sign: async (attrs) => {
+			if (isEcdsa) return ecdsaRawToDer(new Uint8Array(await subtle.sign({
+				name: "ECDSA",
+				hash: "SHA-256"
+			}, cred.privateKey, asData(attrs))));
+			return new Uint8Array(await subtle.sign("RSASSA-PKCS1-v1_5", cred.privateKey, asData(attrs)));
+		}
+	});
+	const holeLen = ctClose - ctOpen - 1;
+	const hex = toHex(cms);
+	if (hex.length > holeLen) throw new Error(`signPdf: signature (${hex.length} hex) exceeds reserved /Contents (${holeLen}); raise reserveBytes`);
+	writeAscii(out, ctOpen + 1, hex + "0".repeat(holeLen - hex.length));
+	return out;
+}
+//#endregion
+export { addSignaturePlaceholder, signPdf };

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

@@ -0,0 +1,31 @@
+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';
+interface Mcref {
+    readonly pageIndex: number;
+    readonly mcid: number;
+}
+export declare class StructNode {
+    readonly id: number;
+    type: StructType;
+    readonly children: Array<StructNode>;
+    readonly mcrefs: Array<Mcref>;
+    parent: StructNode | null;
+    ref: PdfRef | null;
+    alt: string | null;
+    lang: string | null;
+    scope: 'Row' | 'Column' | null;
+    colSpan: number | null;
+    rowSpan: number | null;
+    constructor(id: number, type: StructType);
+}
+export declare class StructTreeBuilder {
+    private readonly nodes;
+    readonly root: StructNode;
+    constructor();
+    create(type: StructType, parent: StructNode | null): StructNode;
+    node(id: number): StructNode;
+    addMcref(nodeId: number, pageIndex: number, mcid: number): void;
+    emit(doc: PdfDocument, pageRefs: ReadonlyArray<PdfRef>): PdfRef;
+}
+export {};

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

@@ -0,0 +1,109 @@
+import { PDF_NULL, dict, name, unicodeString } from "./objects.js";
+//#region src/pdf/struct-tree.ts
+var StructNode = class {
+	children = [];
+	mcrefs = [];
+	parent = null;
+	ref = null;
+	alt = null;
+	lang = null;
+	scope = null;
+	colSpan = null;
+	rowSpan = null;
+	constructor(id, type) {
+		this.id = id;
+		this.type = type;
+	}
+};
+var StructTreeBuilder = class {
+	nodes = [];
+	root;
+	constructor() {
+		this.root = this.create("Document", null);
+	}
+	create(type, parent) {
+		const node = new StructNode(this.nodes.length, type);
+		node.parent = parent;
+		if (parent) parent.children.push(node);
+		this.nodes.push(node);
+		return node;
+	}
+	node(id) {
+		const n = this.nodes[id];
+		if (!n) throw new Error(`Unknown struct node id ${id}`);
+		return n;
+	}
+	addMcref(nodeId, pageIndex, mcid) {
+		this.node(nodeId).mcrefs.push({
+			pageIndex,
+			mcid
+		});
+	}
+	emit(doc, pageRefs) {
+		const order = [];
+		const walk = (n) => {
+			order.push(n);
+			for (const c of n.children) walk(c);
+		};
+		walk(this.root);
+		const dicts = /* @__PURE__ */ new Map();
+		for (const n of order) {
+			const d = dict({
+				Type: name("StructElem"),
+				S: name(n.type)
+			});
+			n.ref = doc.add(d);
+			dicts.set(n.id, d);
+		}
+		const rootDict = dict({ Type: name("StructTreeRoot") });
+		const rootRef = doc.add(rootDict);
+		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;
+			if (firstPage !== void 0) d.set("Pg", pageRefs[firstPage]);
+			const kids = [];
+			for (const c of n.children) kids.push(c.ref);
+			for (const m of n.mcrefs) kids.push(dict({
+				Type: name("MCR"),
+				Pg: pageRefs[m.pageIndex],
+				MCID: m.mcid
+			}));
+			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));
+			if (n.lang !== null) d.set("Lang", n.lang);
+			if (n.scope !== null || n.colSpan !== null || n.rowSpan !== null) {
+				const attrs = { O: name("Table") };
+				if (n.scope !== null) attrs["Scope"] = name(n.scope);
+				if (n.colSpan !== null) attrs["ColSpan"] = n.colSpan;
+				if (n.rowSpan !== null) attrs["RowSpan"] = n.rowSpan;
+				d.set("A", dict(attrs));
+			}
+		}
+		const perPage = /* @__PURE__ */ new Map();
+		for (const n of order) for (const m of n.mcrefs) {
+			let arr = perPage.get(m.pageIndex);
+			if (!arr) {
+				arr = [];
+				perPage.set(m.pageIndex, arr);
+			}
+			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 dense = [];
+			for (let i = 0; i < arr.length; i++) dense.push(arr[i] ?? PDF_NULL);
+			nums.push(k, dense);
+		}
+		const parentTreeRef = doc.add(dict({ Nums: nums }));
+		rootDict.set("K", this.root.ref);
+		rootDict.set("ParentTree", parentTreeRef);
+		rootDict.set("ParentTreeNextKey", sortedKeys.length > 0 ? sortedKeys[sortedKeys.length - 1] + 1 : 0);
+		return rootRef;
+	}
+};
+//#endregion
+export { StructTreeBuilder };

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

@@ -0,0 +1,43 @@
+import { BodyElement, Chart, Numbering, Section, SectionProperties, StyleSheet } from '../document-model/index.js';
+import { FontRegistry } from '../font/index.js';
+import { FamilyKey } from '../fonts/index.js';
+import { Hyphenator } from '../hyphenation/index.js';
+import { AttachedFile } from './embedded-file.js';
+import { SignaturePlaceholder } from './signature.js';
+export type PdfALevel = 'PDF/A-1b' | 'PDF/A-1a' | 'PDF/A-2b' | 'PDF/A-2u' | 'PDF/A-2a' | 'PDF/A-3b' | 'PDF/A-3u' | 'PDF/A-3a';
+export interface StyledRenderOptions {
+    readonly registry: FontRegistry;
+    readonly registriesByFamily?: ReadonlyMap<FamilyKey, FontRegistry>;
+    readonly embeddedFonts?: ReadonlyMap<string, FontRegistry>;
+    readonly styles: StyleSheet;
+    readonly numbering?: Numbering;
+    readonly section?: SectionProperties;
+    readonly sections?: ReadonlyArray<Section>;
+    readonly headersFooters?: ReadonlyMap<string, ReadonlyArray<BodyElement>>;
+    readonly images?: ReadonlyMap<string, Uint8Array>;
+    readonly charts?: ReadonlyMap<string, Chart>;
+    readonly pageWidth?: number;
+    readonly pageHeight?: number;
+    readonly marginLeft?: number;
+    readonly marginRight?: number;
+    readonly marginTop?: number;
+    readonly marginBottom?: number;
+    readonly hyphenator?: Hyphenator;
+    readonly info?: DocumentInfo;
+    readonly pdfA?: PdfALevel;
+    readonly tagged?: boolean;
+    readonly language?: string;
+    readonly attachments?: ReadonlyArray<AttachedFile>;
+    readonly signaturePlaceholder?: SignaturePlaceholder;
+}
+export interface DocumentInfo {
+    readonly title?: string;
+    readonly author?: string;
+    readonly subject?: string;
+    readonly keywords?: string;
+    readonly creator?: string;
+    readonly producer?: string;
+    readonly creationDate?: Date;
+    readonly modificationDate?: Date;
+}
+export declare function renderStyledPdf(body: ReadonlyArray<BodyElement>, options: StyledRenderOptions): Uint8Array;