pdf-parser.js 3.0.7 → 4.5.1

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 { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.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 { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.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 };

package/dist/navigation.js

@@ -0,0 +1,207 @@
+import { asArray, asName, asNumber, dictGet } from "./objects.js";
+import { decodePdfString } from "./pdf-text.js";
+import { walkNameTree } from "./names.js";
+//#region src/navigation.ts
+function coordinateAt(arr, index) {
+	return asNumber(arr[index]);
+}
+function parseDestination(value, resolver, pageIndex, sink) {
+	const arr = 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 = 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(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(dictGet(catalog, "Names"));
+	for (const entry of walkNameTree(namesRoot === void 0 ? void 0 : 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 = 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(dictGet(catalog, "Outlines"));
+	const first = root === void 0 ? void 0 : resolver.resolveDict(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 = dictGet(current, "Title");
+		const children = [];
+		const childFirst = resolver.resolveDict(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" ? decodePdfString(titleObj.bytes) : "",
+			...destination !== void 0 ? { destination } : {},
+			children
+		});
+		current = resolver.resolveDict(dictGet(current, "Next"));
+	}
+}
+function internOutlineDestination(node, registry, resolver) {
+	const dest = dictGet(node, "Dest");
+	if (dest !== void 0) return registry.intern(dest);
+	const action = resolver.resolveDict(dictGet(node, "A"));
+	if (action !== void 0 && asName(dictGet(action, "S")) === "GoTo") return registry.intern(dictGet(action, "D"));
+}
+//#endregion
+export { createDestinationRegistry, parseDestination, readOutline };

package/dist/notes-annotation-author.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/notes-annotation-author.ts
+const NOTES_ANNOTATION_AUTHOR = "documents.js:notes";
+//#endregion
+exports.NOTES_ANNOTATION_AUTHOR = NOTES_ANNOTATION_AUTHOR;

package/dist/notes-annotation-author.d.cts

@@ -0,0 +1,4 @@
+//#region src/notes-annotation-author.d.ts
+declare const NOTES_ANNOTATION_AUTHOR = "documents.js:notes";
+//#endregion
+export { NOTES_ANNOTATION_AUTHOR };

package/dist/notes-annotation-author.d.ts

@@ -0,0 +1,4 @@
+//#region src/notes-annotation-author.d.ts
+declare const NOTES_ANNOTATION_AUTHOR = "documents.js:notes";
+//#endregion
+export { NOTES_ANNOTATION_AUTHOR };

package/dist/notes-annotation-author.js

@@ -0,0 +1,4 @@
+//#region src/notes-annotation-author.ts
+const NOTES_ANNOTATION_AUTHOR = "documents.js:notes";
+//#endregion
+export { NOTES_ANNOTATION_AUTHOR };

package/dist/objects-B7HdMeWS.d.cts

@@ -0,0 +1,59 @@
+//#region src/objects.d.ts
+type PdfObject = {
+  kind: "null";
+} | {
+  kind: "bool";
+  value: boolean;
+} | {
+  kind: "number";
+  value: number;
+} | {
+  kind: "name";
+  name: string;
+} | {
+  kind: "string";
+  bytes: Uint8Array<ArrayBuffer>;
+  hex: boolean;
+} | {
+  kind: "array";
+  items: PdfObject[];
+} | {
+  kind: "dict";
+  entries: Map<string, PdfObject>;
+} | {
+  kind: "stream";
+  dict: PdfDict;
+  raw: Uint8Array<ArrayBuffer>;
+} | {
+  kind: "ref";
+  num: number;
+  gen: number;
+};
+type PdfDict = Extract<PdfObject, {
+  kind: "dict";
+}>;
+type PdfArray = Extract<PdfObject, {
+  kind: "array";
+}>;
+type PdfStream = Extract<PdfObject, {
+  kind: "stream";
+}>;
+declare function pdfNull(): PdfObject;
+declare function pdfBool(value: boolean): PdfObject;
+declare function pdfNum(value: number): PdfObject;
+declare function pdfName(name: string): PdfObject;
+declare function pdfHexString(bytes: Uint8Array<ArrayBuffer>): PdfObject;
+declare function pdfLiteralString(bytes: Uint8Array<ArrayBuffer>): PdfObject;
+declare function pdfArray(items: PdfObject[]): PdfObject;
+declare function pdfDict(entries: Record<string, PdfObject> | Map<string, PdfObject>): PdfDict;
+declare function pdfStream(dict: PdfDict, raw: Uint8Array<ArrayBuffer>): PdfObject;
+declare function pdfRef(num: number, gen: number): PdfObject;
+declare function isName(obj: PdfObject | undefined, name: string): boolean;
+declare function asNumber(obj: PdfObject | undefined): number | undefined;
+declare function asName(obj: PdfObject | undefined): string | undefined;
+declare function asBool(obj: PdfObject | undefined): boolean | undefined;
+declare function asArray(obj: PdfObject | undefined): PdfObject[] | undefined;
+declare function asDict(obj: PdfObject | undefined): PdfDict | undefined;
+declare function dictGet(dict: PdfDict, key: string): PdfObject | undefined;
+//#endregion
+export { pdfName as _, asArray as a, pdfRef as b, asName as c, isName as d, pdfArray as f, pdfLiteralString as g, pdfHexString as h, PdfStream as i, asNumber as l, pdfDict as m, PdfDict as n, asBool as o, pdfBool as p, PdfObject as r, asDict as s, PdfArray as t, dictGet as u, pdfNull as v, pdfStream as x, pdfNum as y };

package/dist/objects-B7HdMeWS.d.ts

@@ -0,0 +1,59 @@
+//#region src/objects.d.ts
+type PdfObject = {
+  kind: "null";
+} | {
+  kind: "bool";
+  value: boolean;
+} | {
+  kind: "number";
+  value: number;
+} | {
+  kind: "name";
+  name: string;
+} | {
+  kind: "string";
+  bytes: Uint8Array<ArrayBuffer>;
+  hex: boolean;
+} | {
+  kind: "array";
+  items: PdfObject[];
+} | {
+  kind: "dict";
+  entries: Map<string, PdfObject>;
+} | {
+  kind: "stream";
+  dict: PdfDict;
+  raw: Uint8Array<ArrayBuffer>;
+} | {
+  kind: "ref";
+  num: number;
+  gen: number;
+};
+type PdfDict = Extract<PdfObject, {
+  kind: "dict";
+}>;
+type PdfArray = Extract<PdfObject, {
+  kind: "array";
+}>;
+type PdfStream = Extract<PdfObject, {
+  kind: "stream";
+}>;
+declare function pdfNull(): PdfObject;
+declare function pdfBool(value: boolean): PdfObject;
+declare function pdfNum(value: number): PdfObject;
+declare function pdfName(name: string): PdfObject;
+declare function pdfHexString(bytes: Uint8Array<ArrayBuffer>): PdfObject;
+declare function pdfLiteralString(bytes: Uint8Array<ArrayBuffer>): PdfObject;
+declare function pdfArray(items: PdfObject[]): PdfObject;
+declare function pdfDict(entries: Record<string, PdfObject> | Map<string, PdfObject>): PdfDict;
+declare function pdfStream(dict: PdfDict, raw: Uint8Array<ArrayBuffer>): PdfObject;
+declare function pdfRef(num: number, gen: number): PdfObject;
+declare function isName(obj: PdfObject | undefined, name: string): boolean;
+declare function asNumber(obj: PdfObject | undefined): number | undefined;
+declare function asName(obj: PdfObject | undefined): string | undefined;
+declare function asBool(obj: PdfObject | undefined): boolean | undefined;
+declare function asArray(obj: PdfObject | undefined): PdfObject[] | undefined;
+declare function asDict(obj: PdfObject | undefined): PdfDict | undefined;
+declare function dictGet(dict: PdfDict, key: string): PdfObject | undefined;
+//#endregion
+export { pdfName as _, asArray as a, pdfRef as b, asName as c, isName as d, pdfArray as f, pdfLiteralString as g, pdfHexString as h, PdfStream as i, asNumber as l, pdfDict as m, PdfDict as n, asBool as o, pdfBool as p, PdfObject as r, asDict as s, PdfArray as t, dictGet as u, pdfNull as v, pdfStream as x, pdfNum as y };

package/dist/objects.d.cts

@@ -1,59 +1,2 @@
-//#region src/objects.d.ts
-type PdfObject = {
-  kind: 'null';
-} | {
-  kind: 'bool';
-  value: boolean;
-} | {
-  kind: 'number';
-  value: number;
-} | {
-  kind: 'name';
-  name: string;
-} | {
-  kind: 'string';
-  bytes: Uint8Array<ArrayBuffer>;
-  hex: boolean;
-} | {
-  kind: 'array';
-  items: PdfObject[];
-} | {
-  kind: 'dict';
-  entries: Map<string, PdfObject>;
-} | {
-  kind: 'stream';
-  dict: PdfDict;
-  raw: Uint8Array<ArrayBuffer>;
-} | {
-  kind: 'ref';
-  num: number;
-  gen: number;
-};
-type PdfDict = Extract<PdfObject, {
-  kind: 'dict';
-}>;
-type PdfArray = Extract<PdfObject, {
-  kind: 'array';
-}>;
-type PdfStream = Extract<PdfObject, {
-  kind: 'stream';
-}>;
-declare function pdfNull(): PdfObject;
-declare function pdfBool(value: boolean): PdfObject;
-declare function pdfNum(value: number): PdfObject;
-declare function pdfName(name: string): PdfObject;
-declare function pdfHexString(bytes: Uint8Array<ArrayBuffer>): PdfObject;
-declare function pdfLiteralString(bytes: Uint8Array<ArrayBuffer>): PdfObject;
-declare function pdfArray(items: PdfObject[]): PdfObject;
-declare function pdfDict(entries: Record<string, PdfObject> | Map<string, PdfObject>): PdfDict;
-declare function pdfStream(dict: PdfDict, raw: Uint8Array<ArrayBuffer>): PdfObject;
-declare function pdfRef(num: number, gen: number): PdfObject;
-declare function isName(obj: PdfObject | undefined, name: string): boolean;
-declare function asNumber(obj: PdfObject | undefined): number | undefined;
-declare function asName(obj: PdfObject | undefined): string | undefined;
-declare function asBool(obj: PdfObject | undefined): boolean | undefined;
-declare function asArray(obj: PdfObject | undefined): PdfObject[] | undefined;
-declare function asDict(obj: PdfObject | undefined): PdfDict | undefined;
-declare function dictGet(dict: PdfDict, key: string): PdfObject | undefined;
-//#endregion
+import { _ as pdfName, a as asArray, b as pdfRef, c as asName, d as isName, f as pdfArray, g as pdfLiteralString, h as pdfHexString, i as PdfStream, l as asNumber, m as pdfDict, n as PdfDict, o as asBool, p as pdfBool, r as PdfObject, s as asDict, t as PdfArray, u as dictGet, v as pdfNull, x as pdfStream, y as pdfNum } from "./objects-B7HdMeWS.cjs";
 export { PdfArray, PdfDict, PdfObject, PdfStream, asArray, asBool, asDict, asName, asNumber, dictGet, isName, pdfArray, pdfBool, pdfDict, pdfHexString, pdfLiteralString, pdfName, pdfNull, pdfNum, pdfRef, pdfStream };