pdf-parser.js 5.2.30 → 5.3.1

package/dist/write-images.js

@@ -0,0 +1,140 @@
+import { pdfArray, pdfBool, pdfDict, pdfName, pdfNum } from "./objects.js";
+import { deflate } from "./bytes/flate.js";
+import { encodeCcittFax } from "./image/ccitt-encode.js";
+import { decodePng } from "./image/png-decode.js";
+import { readJpegInfo as readJpegInfo$1 } from "./image/jpeg-info.js";
+import { base64ToBytes } from "byte-codec";
+//#region src/write-images.ts
+const BITS_PER_BYTE = 8;
+const BYTE_SHIFT = Math.log2(8);
+const BYTE_MASK = 255;
+const PACKED_BIT_MSB_MASK = 128;
+const BIT_INDEX_MASK = 7;
+const JPEG_COMPONENTS_CMYK = 4;
+function prepareJpegImage(bytes) {
+	const info = readJpegInfo$1(bytes);
+	const colorSpace = info.components === 1 ? "DeviceGray" : info.components === JPEG_COMPONENTS_CMYK ? "DeviceCMYK" : "DeviceRGB";
+	const entries = /* @__PURE__ */ new Map([
+		["Type", pdfName("XObject")],
+		["Subtype", pdfName("Image")],
+		["Width", pdfNum(info.width)],
+		["Height", pdfNum(info.height)],
+		["ColorSpace", pdfName(colorSpace)],
+		["BitsPerComponent", pdfNum(info.precision)],
+		["Filter", pdfName("DCTDecode")]
+	]);
+	if (info.components === JPEG_COMPONENTS_CMYK && (info.adobeTransform === 2 || info.adobeTransform === void 0)) entries.set("Decode", pdfArray([
+		1,
+		0,
+		1,
+		0,
+		1,
+		0,
+		1,
+		0
+	].map((n) => pdfNum(n))));
+	return {
+		dict: pdfDict(entries),
+		raw: bytes
+	};
+}
+function pngImageDict(width, height, colorSpace, compress) {
+	const entries = /* @__PURE__ */ new Map([
+		["Type", pdfName("XObject")],
+		["Subtype", pdfName("Image")],
+		["Width", pdfNum(width)],
+		["Height", pdfNum(height)],
+		["ColorSpace", pdfName(colorSpace)],
+		["BitsPerComponent", pdfNum(8)]
+	]);
+	if (compress) entries.set("Filter", pdfName("FlateDecode"));
+	return pdfDict(entries);
+}
+function packBilevel(raw) {
+	const rowBytes = raw.width + BIT_INDEX_MASK >> BYTE_SHIFT;
+	const packed = new Uint8Array(rowBytes * raw.height);
+	const view = new DataView(packed.buffer);
+	for (let index = 0; index < raw.data.length; index++) {
+		const sample = raw.data[index];
+		if (sample !== 0 && sample !== 255) return;
+		if (sample === 255) {
+			const x = index % raw.width;
+			const byteIndex = Math.floor(index / raw.width) * rowBytes + (x >> BYTE_SHIFT);
+			view.setUint8(byteIndex, view.getUint8(byteIndex) | PACKED_BIT_MSB_MASK >> (x & BIT_INDEX_MASK));
+		}
+	}
+	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,
+		alpha: raw.alpha === void 0 ? void 0 : {
+			dict: pngImageDict(raw.width, raw.height, "DeviceGray", compress),
+			raw: compress ? deflate(raw.alpha) : raw.alpha
+		}
+	};
+}
+function preparePassthroughImage(asset, original, compress) {
+	const png = preparePngImage(base64ToBytes(asset.base64), compress);
+	const entries = /* @__PURE__ */ new Map([
+		["Type", pdfName("XObject")],
+		["Subtype", pdfName("Image")],
+		["Width", pdfNum(asset.widthPx)],
+		["Height", pdfNum(asset.heightPx)],
+		["Filter", pdfName(original.filter === "jbig2" ? "JBIG2Decode" : "JPXDecode")]
+	]);
+	if (original.filter === "jbig2") {
+		entries.set("ColorSpace", pdfName("DeviceGray"));
+		entries.set("BitsPerComponent", pdfNum(1));
+	}
+	return {
+		dict: pdfDict(entries),
+		raw: base64ToBytes(original.base64),
+		alpha: png.alpha
+	};
+}
+function prepareImage(asset, compress) {
+	if (asset.original !== void 0) return preparePassthroughImage(asset, asset.original, compress);
+	const bytes = base64ToBytes(asset.base64);
+	return asset.format === "jpeg" ? prepareJpegImage(bytes) : preparePngImage(bytes, compress);
+}
+//#endregion
+export { BITS_PER_BYTE, BYTE_MASK, packBilevel, pngImageDict, prepareImage, prepareJpegImage, preparePassthroughImage, preparePngImage };

package/dist/write-outline.cjs

@@ -0,0 +1,46 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objects = require("./objects.cjs");
+const require_write_annotations = require("./write-annotations.cjs");
+//#region src/write-outline.ts
+function emitOutlineObjects(state) {
+	const { objects, outlineItemNums, outlineRootNum, doc, pageAllocs } = state;
+	if (outlineRootNum !== void 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(require_write_annotations.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)
+			})
+		});
+	}
+}
+//#endregion
+exports.emitOutlineObjects = emitOutlineObjects;

package/dist/write-outline.d.cts

@@ -0,0 +1,18 @@
+import { r as PdfObject } from "./objects-e2RS3-yT.cjs";
+import { LayoutDocument } from "./layout.cjs";
+//#region src/write-outline.d.ts
+interface OutlineEmitState {
+  readonly objects: {
+    num: number;
+    value: PdfObject;
+  }[];
+  readonly outlineItemNums: readonly number[];
+  readonly outlineRootNum: number | undefined;
+  readonly doc: LayoutDocument;
+  readonly pageAllocs: readonly {
+    pageNum: number;
+  }[];
+}
+declare function emitOutlineObjects(state: OutlineEmitState): void;
+//#endregion
+export { OutlineEmitState, emitOutlineObjects };

package/dist/write-outline.d.ts

@@ -0,0 +1,18 @@
+import { r as PdfObject } from "./objects-e2RS3-yT.js";
+import { LayoutDocument } from "./layout.js";
+//#region src/write-outline.d.ts
+interface OutlineEmitState {
+  readonly objects: {
+    num: number;
+    value: PdfObject;
+  }[];
+  readonly outlineItemNums: readonly number[];
+  readonly outlineRootNum: number | undefined;
+  readonly doc: LayoutDocument;
+  readonly pageAllocs: readonly {
+    pageNum: number;
+  }[];
+}
+declare function emitOutlineObjects(state: OutlineEmitState): void;
+//#endregion
+export { OutlineEmitState, emitOutlineObjects };

package/dist/write-outline.js

@@ -0,0 +1,45 @@
+import { pdfArray, pdfDict, pdfLiteralString, pdfName, pdfNum, pdfRef } from "./objects.js";
+import { resolveDestinationArray } from "./write-annotations.js";
+//#region src/write-outline.ts
+function emitOutlineObjects(state) {
+	const { objects, outlineItemNums, outlineRootNum, doc, pageAllocs } = state;
+	if (outlineRootNum !== void 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)
+			})
+		});
+	}
+}
+//#endregion
+export { emitOutlineObjects };

package/dist/write-page-emit.cjs

@@ -0,0 +1,97 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objects = require("./objects.cjs");
+const require_bytes_writer = require("./bytes/writer.cjs");
+const require_bytes_flate = require("./bytes/flate.cjs");
+const require_util_abort = require("./util/abort.cjs");
+const require_write_annotations = require("./write-annotations.cjs");
+const require_math_content_write = require("./math-content-write.cjs");
+const require_content_write = require("./content-write.cjs");
+const require_font_registry = require("./font-registry.cjs");
+//#region src/write-page-emit.ts
+function emitPageObjects(s) {
+	const { doc, options, objects, compress, measurer, registry, fontAllocs, embeddedAllocs, imageAllocs, layerNumByName, formulas, mathFontAlloc, mathFont, pageAllocs, pagesNum, resourcesDict, widgetAnnotsByPage } = s;
+	const markedStructureByPage = /* @__PURE__ */ new Map();
+	const formulasByPage = /* @__PURE__ */ new Map();
+	for (const formula of formulas) {
+		const forPage = formulasByPage.get(formula.pageIndex);
+		if (forPage === void 0) formulasByPage.set(formula.pageIndex, [formula]);
+		else forPage.push(formula);
+	}
+	const context = {
+		measurer,
+		resolveFont: (font) => {
+			const resolved = require_font_registry.resolveFaceWithRegistry(registry, font);
+			if (resolved.kind === "embedded") {
+				const alloc = embeddedAllocs.get(resolved.face);
+				if (alloc === void 0) throw new Error(`embedded font "${resolved.face.postScriptName}" was not pre-allocated — this is a writePdf internal invariant violation`);
+				return {
+					kind: "embedded",
+					resourceName: alloc.resourceName,
+					face: resolved.face
+				};
+			}
+			const alloc = fontAllocs.get(resolved.standardName);
+			if (alloc === void 0) throw new Error(`font "${resolved.standardName}" was not pre-allocated — this is a writePdf internal invariant violation`);
+			return {
+				kind: "standard",
+				resourceName: alloc.resourceName,
+				standardName: resolved.standardName
+			};
+		},
+		resolveImage: (imageId) => {
+			const alloc = imageAllocs.get(imageId);
+			if (alloc === void 0) throw new Error(`image "${imageId}" was not pre-allocated — this is a writePdf internal invariant violation`);
+			return { resourceName: alloc.resourceName };
+		}
+	};
+	doc.pages.forEach((page, pageIndex) => {
+		require_util_abort.throwIfAborted(options.signal);
+		const { pageNum, contentsNum } = pageAllocs[pageIndex];
+		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);
+		const formulaBytes = pageFormulas === void 0 || mathFontAlloc === void 0 || mathFont === void 0 ? void 0 : require_math_content_write.writeFormulaContentStream(pageFormulas, {
+			font: mathFont.font,
+			resourceName: mathFontAlloc.resourceName
+		});
+		const combinedContentBytes = formulaBytes === void 0 ? contentBytes : require_bytes_writer.concatBytes([contentBytes, formulaBytes]);
+		const finalContentBytes = compress ? require_bytes_flate.deflate(combinedContentBytes) : combinedContentBytes;
+		const contentsDict = require_objects.pdfDict(compress ? { Filter: require_objects.pdfName("FlateDecode") } : {});
+		objects.push({
+			num: contentsNum,
+			value: require_objects.pdfStream(contentsDict, finalContentBytes)
+		});
+		const annots = [...page.items.filter(require_write_annotations.isLinkItem).map((link) => require_write_annotations.buildLinkAnnotDict(link)), ...page.items.filter(require_write_annotations.isInternalLinkItem).map((link) => require_write_annotations.buildInternalLinkAnnotDict(link, doc, pageAllocs))];
+		if (page.notes !== void 0 && page.notes.length > 0) annots.push(require_write_annotations.buildNotesAnnotDict(page.notes));
+		annots.push(...widgetAnnotsByPage.get(pageIndex) ?? []);
+		const pageEntries = /* @__PURE__ */ new Map([
+			["Type", require_objects.pdfName("Page")],
+			["Parent", require_objects.pdfRef(pagesNum, 0)],
+			["MediaBox", require_objects.pdfArray([
+				0,
+				0,
+				page.widthPt,
+				page.heightPt
+			].map((n) => require_objects.pdfNum(n)))],
+			["Resources", resourcesDict],
+			["Contents", require_objects.pdfRef(contentsNum, 0)]
+		]);
+		if (annots.length > 0) pageEntries.set("Annots", require_objects.pdfArray(annots));
+		if (markedStructureByPage.has(pageIndex)) pageEntries.set("StructParents", require_objects.pdfNum(pageIndex));
+		objects.push({
+			num: pageNum,
+			value: require_objects.pdfDict(pageEntries)
+		});
+	});
+	return markedStructureByPage;
+}
+//#endregion
+exports.emitPageObjects = emitPageObjects;

package/dist/write-page-emit.d.cts

@@ -0,0 +1,63 @@
+import { r as PdfObject } from "./objects-e2RS3-yT.cjs";
+import { LayoutDocument } from "./layout.cjs";
+import { r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-CqePfvrl.cjs";
+import { WinAnsiSubstitution } from "./winansi.cjs";
+import { FontRegistry } from "./font-registry.cjs";
+import { LoadedMathFont } from "./math-font.cjs";
+import { createFontMeasurer } from "./measure.cjs";
+import { PositionedFormula } from "document-schema.js";
+//#region src/write-page-emit.d.ts
+interface PdfObjectSink {
+  num: number;
+  value: PdfObject;
+}
+interface WritePdfPageOptions {
+  readonly signal?: AbortSignal;
+  readonly onSubstitution?: (substitution: WinAnsiSubstitution, context: {
+    readonly pageIndex: number;
+  }) => void;
+  readonly onMissingGlyph?: (missing: EmbeddedFaceSubstitution, context: {
+    readonly pageIndex: number;
+  }) => void;
+}
+interface PageEmitState {
+  readonly doc: LayoutDocument;
+  readonly options: WritePdfPageOptions;
+  readonly objects: PdfObjectSink[];
+  readonly compress: boolean;
+  readonly measurer: ReturnType<typeof createFontMeasurer>;
+  readonly registry: FontRegistry | undefined;
+  readonly fontAllocs: ReadonlyMap<string, {
+    resourceName: string;
+    fontNum: number;
+    descNum: number;
+    objNum?: number;
+    objNums?: readonly number[];
+  }>;
+  readonly embeddedAllocs: ReadonlyMap<EmbeddedFace, {
+    resourceName: string;
+  }>;
+  readonly imageAllocs: ReadonlyMap<string, {
+    resourceName: string;
+    [extra: string]: unknown;
+  }>;
+  readonly layerNumByName: ReadonlyMap<string, number>;
+  readonly formulas: readonly PositionedFormula[];
+  readonly mathFontAlloc: {
+    resourceName: string;
+  } | undefined;
+  readonly mathFont: LoadedMathFont | undefined;
+  readonly pageAllocs: readonly {
+    pageNum: number;
+    contentsNum: number;
+  }[];
+  readonly pagesNum: number;
+  readonly resourcesDict: PdfObject;
+  readonly widgetAnnotsByPage: ReadonlyMap<number, PdfObject[]>;
+}
+declare function emitPageObjects(s: PageEmitState): Map<number, {
+  mcid: number;
+  structureId: string;
+}[]>;
+//#endregion
+export { PageEmitState, PdfObjectSink, WritePdfPageOptions, emitPageObjects };

package/dist/write-page-emit.d.ts

@@ -0,0 +1,63 @@
+import { r as PdfObject } from "./objects-e2RS3-yT.js";
+import { LayoutDocument } from "./layout.js";
+import { r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-CQZbTTDM.js";
+import { WinAnsiSubstitution } from "./winansi.js";
+import { FontRegistry } from "./font-registry.js";
+import { LoadedMathFont } from "./math-font.js";
+import { createFontMeasurer } from "./measure.js";
+import { PositionedFormula } from "document-schema.js";
+//#region src/write-page-emit.d.ts
+interface PdfObjectSink {
+  num: number;
+  value: PdfObject;
+}
+interface WritePdfPageOptions {
+  readonly signal?: AbortSignal;
+  readonly onSubstitution?: (substitution: WinAnsiSubstitution, context: {
+    readonly pageIndex: number;
+  }) => void;
+  readonly onMissingGlyph?: (missing: EmbeddedFaceSubstitution, context: {
+    readonly pageIndex: number;
+  }) => void;
+}
+interface PageEmitState {
+  readonly doc: LayoutDocument;
+  readonly options: WritePdfPageOptions;
+  readonly objects: PdfObjectSink[];
+  readonly compress: boolean;
+  readonly measurer: ReturnType<typeof createFontMeasurer>;
+  readonly registry: FontRegistry | undefined;
+  readonly fontAllocs: ReadonlyMap<string, {
+    resourceName: string;
+    fontNum: number;
+    descNum: number;
+    objNum?: number;
+    objNums?: readonly number[];
+  }>;
+  readonly embeddedAllocs: ReadonlyMap<EmbeddedFace, {
+    resourceName: string;
+  }>;
+  readonly imageAllocs: ReadonlyMap<string, {
+    resourceName: string;
+    [extra: string]: unknown;
+  }>;
+  readonly layerNumByName: ReadonlyMap<string, number>;
+  readonly formulas: readonly PositionedFormula[];
+  readonly mathFontAlloc: {
+    resourceName: string;
+  } | undefined;
+  readonly mathFont: LoadedMathFont | undefined;
+  readonly pageAllocs: readonly {
+    pageNum: number;
+    contentsNum: number;
+  }[];
+  readonly pagesNum: number;
+  readonly resourcesDict: PdfObject;
+  readonly widgetAnnotsByPage: ReadonlyMap<number, PdfObject[]>;
+}
+declare function emitPageObjects(s: PageEmitState): Map<number, {
+  mcid: number;
+  structureId: string;
+}[]>;
+//#endregion
+export { PageEmitState, PdfObjectSink, WritePdfPageOptions, emitPageObjects };

package/dist/write-page-emit.js

@@ -0,0 +1,96 @@
+import { pdfArray, pdfDict, pdfName, pdfNum, pdfRef, pdfStream } from "./objects.js";
+import { concatBytes } from "./bytes/writer.js";
+import { deflate } from "./bytes/flate.js";
+import { throwIfAborted } from "./util/abort.js";
+import { buildInternalLinkAnnotDict, buildLinkAnnotDict, buildNotesAnnotDict, isInternalLinkItem, isLinkItem } from "./write-annotations.js";
+import { writeFormulaContentStream } from "./math-content-write.js";
+import { writeContentStream } from "./content-write.js";
+import { resolveFaceWithRegistry } from "./font-registry.js";
+//#region src/write-page-emit.ts
+function emitPageObjects(s) {
+	const { doc, options, objects, compress, measurer, registry, fontAllocs, embeddedAllocs, imageAllocs, layerNumByName, formulas, mathFontAlloc, mathFont, pageAllocs, pagesNum, resourcesDict, widgetAnnotsByPage } = s;
+	const markedStructureByPage = /* @__PURE__ */ new Map();
+	const formulasByPage = /* @__PURE__ */ new Map();
+	for (const formula of formulas) {
+		const forPage = formulasByPage.get(formula.pageIndex);
+		if (forPage === void 0) formulasByPage.set(formula.pageIndex, [formula]);
+		else forPage.push(formula);
+	}
+	const context = {
+		measurer,
+		resolveFont: (font) => {
+			const resolved = resolveFaceWithRegistry(registry, font);
+			if (resolved.kind === "embedded") {
+				const alloc = embeddedAllocs.get(resolved.face);
+				if (alloc === void 0) throw new Error(`embedded font "${resolved.face.postScriptName}" was not pre-allocated — this is a writePdf internal invariant violation`);
+				return {
+					kind: "embedded",
+					resourceName: alloc.resourceName,
+					face: resolved.face
+				};
+			}
+			const alloc = fontAllocs.get(resolved.standardName);
+			if (alloc === void 0) throw new Error(`font "${resolved.standardName}" was not pre-allocated — this is a writePdf internal invariant violation`);
+			return {
+				kind: "standard",
+				resourceName: alloc.resourceName,
+				standardName: resolved.standardName
+			};
+		},
+		resolveImage: (imageId) => {
+			const alloc = imageAllocs.get(imageId);
+			if (alloc === void 0) throw new Error(`image "${imageId}" was not pre-allocated — this is a writePdf internal invariant violation`);
+			return { resourceName: alloc.resourceName };
+		}
+	};
+	doc.pages.forEach((page, pageIndex) => {
+		throwIfAborted(options.signal);
+		const { pageNum, contentsNum } = pageAllocs[pageIndex];
+		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);
+		const formulaBytes = pageFormulas === void 0 || mathFontAlloc === void 0 || mathFont === void 0 ? void 0 : writeFormulaContentStream(pageFormulas, {
+			font: mathFont.font,
+			resourceName: mathFontAlloc.resourceName
+		});
+		const combinedContentBytes = formulaBytes === void 0 ? contentBytes : concatBytes([contentBytes, formulaBytes]);
+		const finalContentBytes = compress ? deflate(combinedContentBytes) : combinedContentBytes;
+		const contentsDict = pdfDict(compress ? { Filter: pdfName("FlateDecode") } : {});
+		objects.push({
+			num: contentsNum,
+			value: pdfStream(contentsDict, finalContentBytes)
+		});
+		const annots = [...page.items.filter(isLinkItem).map((link) => buildLinkAnnotDict(link)), ...page.items.filter(isInternalLinkItem).map((link) => buildInternalLinkAnnotDict(link, doc, pageAllocs))];
+		if (page.notes !== void 0 && page.notes.length > 0) annots.push(buildNotesAnnotDict(page.notes));
+		annots.push(...widgetAnnotsByPage.get(pageIndex) ?? []);
+		const pageEntries = /* @__PURE__ */ new Map([
+			["Type", pdfName("Page")],
+			["Parent", pdfRef(pagesNum, 0)],
+			["MediaBox", pdfArray([
+				0,
+				0,
+				page.widthPt,
+				page.heightPt
+			].map((n) => pdfNum(n)))],
+			["Resources", resourcesDict],
+			["Contents", pdfRef(contentsNum, 0)]
+		]);
+		if (annots.length > 0) pageEntries.set("Annots", pdfArray(annots));
+		if (markedStructureByPage.has(pageIndex)) pageEntries.set("StructParents", pdfNum(pageIndex));
+		objects.push({
+			num: pageNum,
+			value: pdfDict(pageEntries)
+		});
+	});
+	return markedStructureByPage;
+}
+//#endregion
+export { emitPageObjects };

package/dist/write-pages.cjs

@@ -0,0 +1,37 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objects = require("./objects.cjs");
+//#region src/write-pages.ts
+function emitStructParentTree(state) {
+	const { objects, structElementNumById, markedStructureByPage, structureRoots, structRootNum, structParentTreeNum } = state;
+	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 }, (_, mcid) => {
+				const mark = marks.find((candidate) => candidate.mcid === mcid);
+				const elementNum = mark === void 0 ? void 0 : structElementNumById.get(mark.structureId);
+				return elementNum === void 0 ? require_objects.pdfNull() : 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(structureRoots.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))
+		});
+	}
+}
+//#endregion
+exports.emitStructParentTree = emitStructParentTree;

package/dist/write-pages.d.cts

@@ -0,0 +1,21 @@
+import { r as PdfObject } from "./objects-e2RS3-yT.cjs";
+//#region src/write-pages.d.ts
+interface StructParentTreeState {
+  readonly objects: {
+    num: number;
+    value: PdfObject;
+  }[];
+  readonly structElementNumById: ReadonlyMap<string, number>;
+  readonly markedStructureByPage: ReadonlyMap<number, readonly {
+    mcid: number;
+    structureId: string;
+  }[]>;
+  readonly structureRoots: readonly {
+    id: string;
+  }[];
+  readonly structRootNum: number | undefined;
+  readonly structParentTreeNum: number | undefined;
+}
+declare function emitStructParentTree(state: StructParentTreeState): void;
+//#endregion
+export { StructParentTreeState, emitStructParentTree };

package/dist/write-pages.d.ts

@@ -0,0 +1,21 @@
+import { r as PdfObject } from "./objects-e2RS3-yT.js";
+//#region src/write-pages.d.ts
+interface StructParentTreeState {
+  readonly objects: {
+    num: number;
+    value: PdfObject;
+  }[];
+  readonly structElementNumById: ReadonlyMap<string, number>;
+  readonly markedStructureByPage: ReadonlyMap<number, readonly {
+    mcid: number;
+    structureId: string;
+  }[]>;
+  readonly structureRoots: readonly {
+    id: string;
+  }[];
+  readonly structRootNum: number | undefined;
+  readonly structParentTreeNum: number | undefined;
+}
+declare function emitStructParentTree(state: StructParentTreeState): void;
+//#endregion
+export { StructParentTreeState, emitStructParentTree };