pdf-codec 3.1.3 → 3.2.0

package/dist/layout.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ColorSchema, ContentStrokeStyleSchema, LayoutFontSchema, LayoutMetadataSchema } from "document-schema.js";
+import { ColorSchema, ContentStrokeStyleSchema, LayoutFontSchema, LayoutMetadataSchema, SourceResidueSchema } from "document-schema.js";
 //#region src/layout.ts
 const LAYOUT_FORMAT_VERSION = 1;
 const LayoutTextSchema = z.object({
@@ -13,6 +13,9 @@ const LayoutTextSchema = z.object({
 	widthPt: z.number().nonnegative().optional(),
 	rotationDeg: z.number().optional(),
 	underline: z.boolean().optional(),
+	layer: z.string().optional(),
+	actualText: z.string().optional(),
+	alt: z.string().optional(),
 	sourcePath: z.string().optional()
 });
 const LayoutImageSchema = z.object({
@@ -23,6 +26,7 @@ const LayoutImageSchema = z.object({
 	widthPt: z.number().positive(),
 	heightPt: z.number().positive(),
 	rotationDeg: z.number().optional(),
+	layer: z.string().optional(),
 	sourcePath: z.string().optional()
 });
 const LayoutRectSchema = z.object({
@@ -36,6 +40,7 @@ const LayoutRectSchema = z.object({
 		color: ColorSchema,
 		widthPt: z.number().positive()
 	}).optional(),
+	layer: z.string().optional(),
 	sourcePath: z.string().optional()
 });
 const LayoutLineSchema = z.object({
@@ -47,6 +52,7 @@ const LayoutLineSchema = z.object({
 	color: ColorSchema,
 	widthPt: z.number().positive(),
 	style: ContentStrokeStyleSchema.optional(),
+	layer: z.string().optional(),
 	sourcePath: z.string().optional()
 });
 const LayoutEllipseSchema = z.object({
@@ -60,6 +66,7 @@ const LayoutEllipseSchema = z.object({
 		color: ColorSchema,
 		widthPt: z.number().positive()
 	}).optional(),
+	layer: z.string().optional(),
 	sourcePath: z.string().optional()
 });
 const LayoutPathSegmentSchema = z.discriminatedUnion("kind", [z.object({
@@ -91,6 +98,7 @@ const LayoutPathSchema = z.object({
 		widthPt: z.number().positive()
 	}).optional(),
 	style: ContentStrokeStyleSchema.optional(),
+	layer: z.string().optional(),
 	sourcePath: z.string().optional()
 });
 const LayoutLinkSchema = z.object({
@@ -100,8 +108,18 @@ const LayoutLinkSchema = z.object({
 	yPt: z.number(),
 	widthPt: z.number().nonnegative(),
 	heightPt: z.number().nonnegative(),
+	title: z.string().optional(),
 	sourcePath: z.string().optional()
 });
+const LayoutInternalLinkSchema = z.object({
+	kind: z.literal("internalLink"),
+	destination: z.string(),
+	xPt: z.number(),
+	yPt: z.number(),
+	widthPt: z.number().nonnegative(),
+	heightPt: z.number().nonnegative(),
+	title: z.string().optional()
+});
 const LayoutItemSchema = z.discriminatedUnion("kind", [
 	LayoutTextSchema,
 	LayoutImageSchema,
@@ -109,12 +127,44 @@ const LayoutItemSchema = z.discriminatedUnion("kind", [
 	LayoutLineSchema,
 	LayoutEllipseSchema,
 	LayoutPathSchema,
-	LayoutLinkSchema
+	LayoutLinkSchema,
+	LayoutInternalLinkSchema
 ]);
+const LayoutAnnotationQuadSchema = z.tuple([
+	z.object({
+		xPt: z.number(),
+		yPt: z.number()
+	}),
+	z.object({
+		xPt: z.number(),
+		yPt: z.number()
+	}),
+	z.object({
+		xPt: z.number(),
+		yPt: z.number()
+	}),
+	z.object({
+		xPt: z.number(),
+		yPt: z.number()
+	})
+]);
+const LayoutAnnotationSchema = z.object({
+	subtype: z.string(),
+	xPt: z.number(),
+	yPt: z.number(),
+	widthPt: z.number().nonnegative(),
+	heightPt: z.number().nonnegative(),
+	contents: z.string().optional(),
+	author: z.string().optional(),
+	modifiedIso: z.string().optional(),
+	quads: z.array(LayoutAnnotationQuadSchema).optional(),
+	source: SourceResidueSchema.optional()
+});
 const LayoutPageSchema = z.object({
 	widthPt: z.number().positive(),
 	heightPt: z.number().positive(),
 	items: z.array(LayoutItemSchema),
+	annotations: z.array(LayoutAnnotationSchema).optional(),
 	notes: z.string().optional()
 });
 const LayoutImageAssetSchema = z.object({
@@ -123,11 +173,81 @@ const LayoutImageAssetSchema = z.object({
 	widthPx: z.number().int().positive(),
 	heightPx: z.number().int().positive()
 });
+const LayoutDestinationTargetSchema = z.object({
+	kind: z.enum([
+		"xyz",
+		"fit",
+		"fitH",
+		"fitV",
+		"fitR",
+		"fitB",
+		"fitBH",
+		"fitBV"
+	]),
+	leftPt: z.number().optional(),
+	topPt: z.number().optional(),
+	bottomPt: z.number().optional(),
+	rightPt: z.number().optional(),
+	zoom: z.number().optional()
+});
+const LayoutDestinationSchema = z.object({
+	name: z.string(),
+	pageIndex: z.number().int().nonnegative(),
+	target: LayoutDestinationTargetSchema
+});
+const LayoutOutlineItemSchema = z.lazy(() => z.object({
+	title: z.string(),
+	destination: z.string().optional(),
+	children: z.array(LayoutOutlineItemSchema)
+}));
+const LayoutAttachmentSchema = z.object({
+	name: z.string(),
+	description: z.string().optional(),
+	mimeType: z.string().optional(),
+	base64: z.string()
+});
+const LayoutFormWidgetSchema = z.object({
+	pageIndex: z.number().int().nonnegative(),
+	xPt: z.number(),
+	yPt: z.number(),
+	widthPt: z.number().nonnegative(),
+	heightPt: z.number().nonnegative()
+});
+const LayoutFormFieldSchema = z.lazy(() => z.object({
+	name: z.string(),
+	fieldType: z.enum([
+		"text",
+		"checkbox",
+		"radio",
+		"button",
+		"listbox",
+		"combobox",
+		"signature",
+		"group"
+	]),
+	value: z.string().optional(),
+	checked: z.boolean().optional(),
+	options: z.array(z.string()).optional(),
+	alias: z.string().optional(),
+	readOnly: z.boolean().optional(),
+	widgets: z.array(LayoutFormWidgetSchema),
+	children: z.array(LayoutFormFieldSchema)
+}));
+const LayoutLayerSchema = z.object({
+	name: z.string(),
+	visible: z.boolean()
+});
 const LayoutDocumentSchema = z.object({
 	formatVersion: z.literal(1),
 	metadata: LayoutMetadataSchema,
 	pages: z.array(LayoutPageSchema),
-	images: z.record(z.string(), LayoutImageAssetSchema)
+	images: z.record(z.string(), LayoutImageAssetSchema),
+	destinations: z.array(LayoutDestinationSchema).optional(),
+	outline: z.array(LayoutOutlineItemSchema).optional(),
+	attachments: z.array(LayoutAttachmentSchema).optional(),
+	layers: z.array(LayoutLayerSchema).optional(),
+	form: z.array(LayoutFormFieldSchema).optional(),
+	source: z.record(z.string(), SourceResidueSchema).optional()
 });
 //#endregion
-export { LAYOUT_FORMAT_VERSION, LayoutDocumentSchema, LayoutEllipseSchema, LayoutImageAssetSchema, LayoutImageSchema, LayoutItemSchema, LayoutLineSchema, LayoutLinkSchema, LayoutPageSchema, LayoutPathSchema, LayoutPathSegmentSchema, LayoutRectSchema, LayoutSubpathSchema, LayoutTextSchema };
+export { LAYOUT_FORMAT_VERSION, LayoutAnnotationQuadSchema, LayoutAnnotationSchema, LayoutAttachmentSchema, LayoutDestinationSchema, LayoutDestinationTargetSchema, LayoutDocumentSchema, LayoutEllipseSchema, LayoutFormFieldSchema, LayoutFormWidgetSchema, LayoutImageAssetSchema, LayoutImageSchema, LayoutInternalLinkSchema, LayoutItemSchema, LayoutLayerSchema, LayoutLineSchema, LayoutLinkSchema, LayoutOutlineItemSchema, LayoutPageSchema, LayoutPathSchema, LayoutPathSegmentSchema, LayoutRectSchema, LayoutSubpathSchema, LayoutTextSchema };

package/dist/math-content-write.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_bytes_writer = require("./bytes/writer.cjs");
 const require_objects = require("./objects.cjs");
+const require_bytes_writer = require("./bytes/writer.cjs");
 const require_serialize = require("./serialize.cjs");
 //#region src/math-content-write.ts
 function toPdfX(positioned, itemXPt) {

package/dist/math-content-write.js

@@ -1,5 +1,5 @@
-import { ByteWriter } from "./bytes/writer.js";
 import { pdfDict, pdfHexString, pdfName } from "./objects.js";
+import { ByteWriter } from "./bytes/writer.js";
 import { formatNumber, writeObject } from "./serialize.js";
 //#region src/math-content-write.ts
 function toPdfX(positioned, itemXPt) {

package/dist/math-font.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_util_base64 = require("./util/base64.cjs");
 const require_sfnt = require("./sfnt.cjs");
 const require_cff_bounds = require("./cff-bounds.cjs");
 const require_cmap_table = require("./cmap-table.cjs");
-const require_util_base64 = require("./util/base64.cjs");
 const require_hmtx_table = require("./hmtx-table.cjs");
 const require_assets_stix_two_math_font = require("./assets/stix-two-math-font.cjs");
 const require_math_stretch = require("./math-stretch.cjs");

package/dist/math-font.js

@@ -1,7 +1,7 @@
+import { base64ToBytes } from "./util/base64.js";
 import { i16, parseSfnt, sfntTableBytes, u16 } from "./sfnt.js";
 import { parseCffGlyphBounds } from "./cff-bounds.js";
 import { buildCmapLookup } from "./cmap-table.js";
-import { base64ToBytes } from "./util/base64.js";
 import { parseHmtx } from "./hmtx-table.js";
 import { STIX_TWO_MATH_FONT_BASE64 } from "./assets/stix-two-math-font.js";
 import { assembleStretchyGlyph, scaleMathStretchConstruction } from "./math-stretch.js";

package/dist/names.cjs

@@ -0,0 +1,41 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objects = require("./objects.cjs");
+const require_pdf_text = require("./pdf-text.cjs");
+//#region src/names.ts
+function walkNameTree(root, resolver, sink) {
+	const entries = [];
+	collectNameTreeEntries(root, resolver, sink, entries, /* @__PURE__ */ new Set());
+	return entries;
+}
+function collectNameTreeEntries(node, resolver, sink, entries, visited) {
+	const dict = require_objects.asDict(resolver.resolve(node));
+	if (dict === void 0) {
+		if (node !== void 0) sink({
+			code: "pdf/name-tree-node-invalid",
+			severity: "warning",
+			message: "a name tree node did not resolve to a dictionary; skipping it"
+		});
+		return;
+	}
+	if (visited.has(dict)) {
+		sink({
+			code: "pdf/name-tree-cycle",
+			severity: "warning",
+			message: "the name tree contains a cycle; stopping descent at the repeated node"
+		});
+		return;
+	}
+	visited.add(dict);
+	const names = require_objects.asArray(require_objects.dictGet(dict, "Names"));
+	if (names !== void 0) for (let i = 0; i + 1 < names.length; i += 2) {
+		const key = names[i];
+		if (key?.kind === "string") entries.push({
+			name: require_pdf_text.decodePdfString(key.bytes),
+			value: names[i + 1]
+		});
+	}
+	const kids = require_objects.asArray(require_objects.dictGet(dict, "Kids"));
+	if (kids !== void 0) for (const kid of kids) collectNameTreeEntries(kid, resolver, sink, entries, visited);
+}
+//#endregion
+exports.walkNameTree = walkNameTree;

package/dist/names.d.cts

@@ -0,0 +1,11 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+import { PdfObject } from "./objects.cjs";
+import { PdfObjectResolver } from "./interpret.cjs";
+//#region src/names.d.ts
+interface NameTreeEntry {
+  readonly name: string;
+  readonly value: PdfObject;
+}
+declare function walkNameTree(root: PdfObject | undefined, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): NameTreeEntry[];
+//#endregion
+export { NameTreeEntry, walkNameTree };

package/dist/names.d.ts

@@ -0,0 +1,11 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { PdfObject } from "./objects.js";
+import { PdfObjectResolver } from "./interpret.js";
+//#region src/names.d.ts
+interface NameTreeEntry {
+  readonly name: string;
+  readonly value: PdfObject;
+}
+declare function walkNameTree(root: PdfObject | undefined, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): NameTreeEntry[];
+//#endregion
+export { NameTreeEntry, walkNameTree };

package/dist/names.js

@@ -0,0 +1,40 @@
+import { asArray, asDict, dictGet } from "./objects.js";
+import { decodePdfString } from "./pdf-text.js";
+//#region src/names.ts
+function walkNameTree(root, resolver, sink) {
+	const entries = [];
+	collectNameTreeEntries(root, resolver, sink, entries, /* @__PURE__ */ new Set());
+	return entries;
+}
+function collectNameTreeEntries(node, resolver, sink, entries, visited) {
+	const dict = asDict(resolver.resolve(node));
+	if (dict === void 0) {
+		if (node !== void 0) sink({
+			code: "pdf/name-tree-node-invalid",
+			severity: "warning",
+			message: "a name tree node did not resolve to a dictionary; skipping it"
+		});
+		return;
+	}
+	if (visited.has(dict)) {
+		sink({
+			code: "pdf/name-tree-cycle",
+			severity: "warning",
+			message: "the name tree contains a cycle; stopping descent at the repeated node"
+		});
+		return;
+	}
+	visited.add(dict);
+	const names = asArray(dictGet(dict, "Names"));
+	if (names !== void 0) for (let i = 0; i + 1 < names.length; i += 2) {
+		const key = names[i];
+		if (key?.kind === "string") entries.push({
+			name: decodePdfString(key.bytes),
+			value: names[i + 1]
+		});
+	}
+	const kids = asArray(dictGet(dict, "Kids"));
+	if (kids !== void 0) for (const kid of kids) collectNameTreeEntries(kid, resolver, sink, entries, visited);
+}
+//#endregion
+export { walkNameTree };

package/dist/navigation.cjs

@@ -0,0 +1,210 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objects = require("./objects.cjs");
+const require_pdf_text = require("./pdf-text.cjs");
+const require_names = require("./names.cjs");
+//#region src/navigation.ts
+function coordinateAt(arr, index) {
+	return require_objects.asNumber(arr[index]);
+}
+function parseDestination(value, resolver, pageIndex, sink) {
+	const arr = require_objects.asArray(resolver.resolve(value));
+	if (arr === void 0 || arr.length < 2) {
+		sink({
+			code: "pdf/destination-invalid",
+			severity: "warning",
+			message: "a destination is not a display destination array; skipping it"
+		});
+		return;
+	}
+	const pageEl = arr[0];
+	const resolvedPageIndex = pageEl?.kind === "number" ? Number.isInteger(pageEl.value) && pageEl.value >= 0 ? pageEl.value : void 0 : pageIndex(pageEl);
+	if (resolvedPageIndex === void 0) {
+		sink({
+			code: "pdf/destination-invalid",
+			severity: "warning",
+			message: "a destination names a page that is not in the document's page tree; skipping it"
+		});
+		return;
+	}
+	const type = require_objects.asName(arr[1]);
+	if (type === "XYZ") return {
+		pageIndex: resolvedPageIndex,
+		target: {
+			kind: "xyz",
+			...optionalCoords(arr, [
+				["leftPt", 2],
+				["topPt", 3],
+				["zoom", 4]
+			])
+		}
+	};
+	if (type === "Fit") return {
+		pageIndex: resolvedPageIndex,
+		target: { kind: "fit" }
+	};
+	if (type === "FitH") return {
+		pageIndex: resolvedPageIndex,
+		target: {
+			kind: "fitH",
+			...optionalCoords(arr, [["topPt", 2]])
+		}
+	};
+	if (type === "FitV") return {
+		pageIndex: resolvedPageIndex,
+		target: {
+			kind: "fitV",
+			...optionalCoords(arr, [["leftPt", 2]])
+		}
+	};
+	if (type === "FitR") return {
+		pageIndex: resolvedPageIndex,
+		target: {
+			kind: "fitR",
+			...optionalCoords(arr, [
+				["leftPt", 2],
+				["bottomPt", 3],
+				["rightPt", 4],
+				["topPt", 5]
+			])
+		}
+	};
+	if (type === "FitB") return {
+		pageIndex: resolvedPageIndex,
+		target: { kind: "fitB" }
+	};
+	if (type === "FitBH") return {
+		pageIndex: resolvedPageIndex,
+		target: {
+			kind: "fitBH",
+			...optionalCoords(arr, [["topPt", 2]])
+		}
+	};
+	if (type === "FitBV") return {
+		pageIndex: resolvedPageIndex,
+		target: {
+			kind: "fitBV",
+			...optionalCoords(arr, [["leftPt", 2]])
+		}
+	};
+	sink({
+		code: "pdf/destination-invalid",
+		severity: "warning",
+		message: `a destination carries unknown display type /${type ?? "?"}; skipping it`
+	});
+}
+function optionalCoords(arr, fields) {
+	const out = {};
+	for (const [field, index] of fields) {
+		const value = coordinateAt(arr, index);
+		if (value !== void 0) out[field] = value;
+	}
+	return out;
+}
+function createDestinationRegistry(catalog, resolver, pageIndex, sink) {
+	const entries = [];
+	const byName = /* @__PURE__ */ new Map();
+	const add = (name, parsed) => {
+		const entry = {
+			name,
+			pageIndex: parsed.pageIndex,
+			target: parsed.target
+		};
+		entries.push(entry);
+		byName.set(name, entry);
+	};
+	const destsDict = resolver.resolveDict(require_objects.dictGet(catalog, "Dests"));
+	if (destsDict !== void 0) for (const [name, value] of destsDict.entries) {
+		if (byName.has(name)) {
+			sink({
+				code: "pdf/destination-duplicate",
+				severity: "warning",
+				message: `destination name "${name}" is declared more than once; keeping the first`
+			});
+			continue;
+		}
+		const parsed = parseDestination(value, resolver, pageIndex, sink);
+		if (parsed !== void 0) add(name, parsed);
+	}
+	const namesRoot = resolver.resolveDict(require_objects.dictGet(catalog, "Names"));
+	for (const entry of require_names.walkNameTree(namesRoot === void 0 ? void 0 : require_objects.dictGet(namesRoot, "Dests"), resolver, sink)) {
+		if (byName.has(entry.name)) {
+			sink({
+				code: "pdf/destination-duplicate",
+				severity: "warning",
+				message: `destination name "${entry.name}" is declared more than once; keeping the first`
+			});
+			continue;
+		}
+		const parsed = parseDestination(entry.value, resolver, pageIndex, sink);
+		if (parsed !== void 0) add(entry.name, parsed);
+	}
+	const minted = (obj) => {
+		const parsed = parseDestination(obj, resolver, pageIndex, sink);
+		if (parsed === void 0) return;
+		let n = 1;
+		while (byName.has(`dest${n}`)) n++;
+		const name = `dest${n}`;
+		add(name, parsed);
+		return name;
+	};
+	return {
+		entries,
+		intern(obj) {
+			const resolved = resolver.resolve(obj);
+			if (resolved?.kind === "string") {
+				const name = require_pdf_text.decodePdfString(resolved.bytes);
+				if (byName.has(name)) return name;
+				sink({
+					code: "pdf/destination-unresolved",
+					severity: "warning",
+					message: `a destination names "${name}", which no /Dests or /Names /Dests entry declares`
+				});
+				return;
+			}
+			if (resolved?.kind === "array") return minted(resolved);
+		}
+	};
+}
+function readOutline(catalog, registry, resolver, sink) {
+	const root = resolver.resolveDict(require_objects.dictGet(catalog, "Outlines"));
+	const first = root === void 0 ? void 0 : resolver.resolveDict(require_objects.dictGet(root, "First"));
+	if (first === void 0) return [];
+	const items = [];
+	walkOutlineSiblings(first, items, registry, resolver, sink, /* @__PURE__ */ new Set());
+	return items;
+}
+function walkOutlineSiblings(node, out, registry, resolver, sink, visited) {
+	let current = node;
+	while (current !== void 0) {
+		if (visited.has(current)) {
+			sink({
+				code: "pdf/outline-cycle",
+				severity: "warning",
+				message: "the outline contains a cycle; stopping the sibling chain at the repeated item"
+			});
+			return;
+		}
+		visited.add(current);
+		const titleObj = require_objects.dictGet(current, "Title");
+		const children = [];
+		const childFirst = resolver.resolveDict(require_objects.dictGet(current, "First"));
+		if (childFirst !== void 0) walkOutlineSiblings(childFirst, children, registry, resolver, sink, visited);
+		const destination = internOutlineDestination(current, registry, resolver);
+		out.push({
+			title: titleObj?.kind === "string" ? require_pdf_text.decodePdfString(titleObj.bytes) : "",
+			...destination !== void 0 ? { destination } : {},
+			children
+		});
+		current = resolver.resolveDict(require_objects.dictGet(current, "Next"));
+	}
+}
+function internOutlineDestination(node, registry, resolver) {
+	const dest = require_objects.dictGet(node, "Dest");
+	if (dest !== void 0) return registry.intern(dest);
+	const action = resolver.resolveDict(require_objects.dictGet(node, "A"));
+	if (action !== void 0 && require_objects.asName(require_objects.dictGet(action, "S")) === "GoTo") return registry.intern(require_objects.dictGet(action, "D"));
+}
+//#endregion
+exports.createDestinationRegistry = createDestinationRegistry;
+exports.parseDestination = parseDestination;
+exports.readOutline = readOutline;

package/dist/navigation.d.cts

@@ -0,0 +1,18 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+import { PdfDict, PdfObject } from "./objects.cjs";
+import { PdfObjectResolver } from "./interpret.cjs";
+import { LayoutDestination, LayoutDestinationTarget, LayoutOutlineItem } from "./layout.cjs";
+//#region src/navigation.d.ts
+type PageIndexLookup = (obj: PdfObject | undefined) => number | undefined;
+declare function parseDestination(value: PdfObject | undefined, resolver: PdfObjectResolver, pageIndex: PageIndexLookup, sink: PdfDiagnosticSink): {
+  pageIndex: number;
+  target: LayoutDestinationTarget;
+} | undefined;
+interface DestinationRegistry {
+  readonly entries: readonly LayoutDestination[];
+  intern(obj: PdfObject | undefined): string | undefined;
+}
+declare function createDestinationRegistry(catalog: PdfDict, resolver: PdfObjectResolver, pageIndex: PageIndexLookup, sink: PdfDiagnosticSink): DestinationRegistry;
+declare function readOutline(catalog: PdfDict, registry: DestinationRegistry, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): LayoutOutlineItem[];
+//#endregion
+export { DestinationRegistry, PageIndexLookup, createDestinationRegistry, parseDestination, readOutline };

package/dist/navigation.d.ts

@@ -0,0 +1,18 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { PdfDict, PdfObject } from "./objects.js";
+import { PdfObjectResolver } from "./interpret.js";
+import { LayoutDestination, LayoutDestinationTarget, LayoutOutlineItem } from "./layout.js";
+//#region src/navigation.d.ts
+type PageIndexLookup = (obj: PdfObject | undefined) => number | undefined;
+declare function parseDestination(value: PdfObject | undefined, resolver: PdfObjectResolver, pageIndex: PageIndexLookup, sink: PdfDiagnosticSink): {
+  pageIndex: number;
+  target: LayoutDestinationTarget;
+} | undefined;
+interface DestinationRegistry {
+  readonly entries: readonly LayoutDestination[];
+  intern(obj: PdfObject | undefined): string | undefined;
+}
+declare function createDestinationRegistry(catalog: PdfDict, resolver: PdfObjectResolver, pageIndex: PageIndexLookup, sink: PdfDiagnosticSink): DestinationRegistry;
+declare function readOutline(catalog: PdfDict, registry: DestinationRegistry, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): LayoutOutlineItem[];
+//#endregion
+export { DestinationRegistry, PageIndexLookup, createDestinationRegistry, parseDestination, readOutline };