pdf-codec 3.1.4 → 3.2.0

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/optional-content.cjs

@@ -0,0 +1,63 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objects = require("./objects.cjs");
+const require_pdf_text = require("./pdf-text.cjs");
+//#region src/optional-content.ts
+function readOptionalContent(catalog, resolver, sink) {
+	const ocProperties = resolver.resolveDict(require_objects.dictGet(catalog, "OCProperties"));
+	if (ocProperties === void 0) return {
+		layers: [],
+		layerNameOf: () => void 0
+	};
+	const nameByGroup = /* @__PURE__ */ new Map();
+	const groups = [];
+	const ocgs = require_objects.asArray(resolver.resolve(require_objects.dictGet(ocProperties, "OCGs"))) ?? [];
+	for (const ocgRef of ocgs) {
+		const ocg = resolver.resolveDict(ocgRef);
+		if (ocg === void 0) {
+			sink({
+				code: "pdf/ocg-unresolved",
+				severity: "warning",
+				message: "an entry in /OCProperties /OCGs did not resolve to a dictionary; skipping it"
+			});
+			continue;
+		}
+		const nameObj = require_objects.dictGet(ocg, "Name");
+		const name = nameObj?.kind === "string" ? require_pdf_text.decodePdfString(nameObj.bytes) : mintLayerName(nameByGroup);
+		nameByGroup.set(ocg, name);
+		groups.push({
+			dict: ocg,
+			name
+		});
+	}
+	const defaultConfig = resolver.resolveDict(require_objects.dictGet(ocProperties, "D"));
+	const baseVisible = defaultConfig === void 0 || require_objects.asName(require_objects.dictGet(defaultConfig, "BaseState")) !== "OFF";
+	const groupsIn = (key) => {
+		const set = /* @__PURE__ */ new Set();
+		const arr = defaultConfig === void 0 ? void 0 : require_objects.asArray(resolver.resolve(require_objects.dictGet(defaultConfig, key)));
+		if (arr !== void 0) for (const entry of arr) {
+			const dict = resolver.resolveDict(entry);
+			if (dict !== void 0) set.add(dict);
+		}
+		return set;
+	};
+	const on = groupsIn("ON");
+	const off = groupsIn("OFF");
+	return {
+		layers: groups.map(({ dict, name }) => ({
+			name,
+			visible: off.has(dict) ? false : on.has(dict) ? true : baseVisible
+		})),
+		layerNameOf: (obj) => {
+			const dict = resolver.resolveDict(obj);
+			return dict !== void 0 ? nameByGroup.get(dict) : void 0;
+		}
+	};
+}
+function mintLayerName(taken) {
+	const used = new Set(taken.values());
+	let n = 1;
+	while (used.has(`layer${n}`)) n++;
+	return `layer${n}`;
+}
+//#endregion
+exports.readOptionalContent = readOptionalContent;

package/dist/optional-content.d.cts

@@ -0,0 +1,12 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+import { PdfDict, PdfObject } from "./objects.cjs";
+import { PdfObjectResolver } from "./interpret.cjs";
+import { LayoutLayer } from "./layout.cjs";
+//#region src/optional-content.d.ts
+interface OptionalContentContext {
+  readonly layers: readonly LayoutLayer[];
+  readonly layerNameOf: (obj: PdfObject | undefined) => string | undefined;
+}
+declare function readOptionalContent(catalog: PdfDict, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): OptionalContentContext;
+//#endregion
+export { OptionalContentContext, readOptionalContent };

package/dist/optional-content.d.ts

@@ -0,0 +1,12 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { PdfDict, PdfObject } from "./objects.js";
+import { PdfObjectResolver } from "./interpret.js";
+import { LayoutLayer } from "./layout.js";
+//#region src/optional-content.d.ts
+interface OptionalContentContext {
+  readonly layers: readonly LayoutLayer[];
+  readonly layerNameOf: (obj: PdfObject | undefined) => string | undefined;
+}
+declare function readOptionalContent(catalog: PdfDict, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): OptionalContentContext;
+//#endregion
+export { OptionalContentContext, readOptionalContent };

package/dist/optional-content.js

@@ -0,0 +1,62 @@
+import { asArray, asName, dictGet } from "./objects.js";
+import { decodePdfString } from "./pdf-text.js";
+//#region src/optional-content.ts
+function readOptionalContent(catalog, resolver, sink) {
+	const ocProperties = resolver.resolveDict(dictGet(catalog, "OCProperties"));
+	if (ocProperties === void 0) return {
+		layers: [],
+		layerNameOf: () => void 0
+	};
+	const nameByGroup = /* @__PURE__ */ new Map();
+	const groups = [];
+	const ocgs = asArray(resolver.resolve(dictGet(ocProperties, "OCGs"))) ?? [];
+	for (const ocgRef of ocgs) {
+		const ocg = resolver.resolveDict(ocgRef);
+		if (ocg === void 0) {
+			sink({
+				code: "pdf/ocg-unresolved",
+				severity: "warning",
+				message: "an entry in /OCProperties /OCGs did not resolve to a dictionary; skipping it"
+			});
+			continue;
+		}
+		const nameObj = dictGet(ocg, "Name");
+		const name = nameObj?.kind === "string" ? decodePdfString(nameObj.bytes) : mintLayerName(nameByGroup);
+		nameByGroup.set(ocg, name);
+		groups.push({
+			dict: ocg,
+			name
+		});
+	}
+	const defaultConfig = resolver.resolveDict(dictGet(ocProperties, "D"));
+	const baseVisible = defaultConfig === void 0 || asName(dictGet(defaultConfig, "BaseState")) !== "OFF";
+	const groupsIn = (key) => {
+		const set = /* @__PURE__ */ new Set();
+		const arr = defaultConfig === void 0 ? void 0 : asArray(resolver.resolve(dictGet(defaultConfig, key)));
+		if (arr !== void 0) for (const entry of arr) {
+			const dict = resolver.resolveDict(entry);
+			if (dict !== void 0) set.add(dict);
+		}
+		return set;
+	};
+	const on = groupsIn("ON");
+	const off = groupsIn("OFF");
+	return {
+		layers: groups.map(({ dict, name }) => ({
+			name,
+			visible: off.has(dict) ? false : on.has(dict) ? true : baseVisible
+		})),
+		layerNameOf: (obj) => {
+			const dict = resolver.resolveDict(obj);
+			return dict !== void 0 ? nameByGroup.get(dict) : void 0;
+		}
+	};
+}
+function mintLayerName(taken) {
+	const used = new Set(taken.values());
+	let n = 1;
+	while (used.has(`layer${n}`)) n++;
+	return `layer${n}`;
+}
+//#endregion
+export { readOptionalContent };

package/dist/parse.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_lexer = require("./lexer.cjs");
 const require_objects = require("./objects.cjs");
+const require_lexer = require("./lexer.cjs");
 //#region src/parse.ts
 function parseValue(reader, sink) {
 	const token = require_lexer.nextToken(reader);

package/dist/parse.d.cts

@@ -1,6 +1,6 @@
-import { ByteReader } from "./bytes/reader.cjs";
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
 import { PdfObject } from "./objects.cjs";
+import { ByteReader } from "./bytes/reader.cjs";
 //#region src/parse.d.ts
 declare function parseValue(reader: ByteReader, sink: PdfDiagnosticSink): PdfObject | undefined;
 interface ParsedIndirectObject {

package/dist/parse.d.ts

@@ -1,6 +1,6 @@
-import { ByteReader } from "./bytes/reader.js";
 import { PdfDiagnosticSink } from "./diagnostics.js";
 import { PdfObject } from "./objects.js";
+import { ByteReader } from "./bytes/reader.js";
 //#region src/parse.d.ts
 declare function parseValue(reader: ByteReader, sink: PdfDiagnosticSink): PdfObject | undefined;
 interface ParsedIndirectObject {

package/dist/parse.js

@@ -1,5 +1,5 @@
-import { nextToken } from "./lexer.js";
 import { dictGet, pdfArray, pdfBool, pdfDict, pdfHexString, pdfLiteralString, pdfName, pdfNull, pdfNum, pdfRef, pdfStream } from "./objects.js";
+import { nextToken } from "./lexer.js";
 //#region src/parse.ts
 function parseValue(reader, sink) {
 	const token = nextToken(reader);

package/dist/pdf-text.cjs

@@ -0,0 +1,21 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/pdf-text.ts
+function decodePdfString(bytes) {
+	if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255) {
+		let out = "";
+		for (let i = 2; i + 1 < bytes.length; i += 2) out += String.fromCharCode((bytes[i] ?? 0) << 8 | (bytes[i + 1] ?? 0));
+		return out;
+	}
+	return Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+}
+const PDF_DATE_PATTERN = /^D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?([+\-Z])?(\d{2})?'?(\d{2})?'?$/;
+function parsePdfDate(raw) {
+	if (raw === void 0) return;
+	const match = PDF_DATE_PATTERN.exec(raw);
+	if (match === null) return;
+	const [, year, month = "01", day = "01", hour = "00", minute = "00", second = "00", tzSign, tzHour = "00", tzMinute = "00"] = match;
+	return `${year}-${month}-${day}T${hour}:${minute}:${second}${tzSign === void 0 || tzSign === "Z" ? "Z" : `${tzSign}${tzHour}:${tzMinute}`}`;
+}
+//#endregion
+exports.decodePdfString = decodePdfString;
+exports.parsePdfDate = parsePdfDate;

package/dist/pdf-text.d.cts

@@ -0,0 +1,5 @@
+//#region src/pdf-text.d.ts
+declare function decodePdfString(bytes: Uint8Array<ArrayBuffer>): string;
+declare function parsePdfDate(raw: string | undefined): string | undefined;
+//#endregion
+export { decodePdfString, parsePdfDate };

package/dist/pdf-text.d.ts

@@ -0,0 +1,5 @@
+//#region src/pdf-text.d.ts
+declare function decodePdfString(bytes: Uint8Array<ArrayBuffer>): string;
+declare function parsePdfDate(raw: string | undefined): string | undefined;
+//#endregion
+export { decodePdfString, parsePdfDate };

package/dist/pdf-text.js

@@ -0,0 +1,19 @@
+//#region src/pdf-text.ts
+function decodePdfString(bytes) {
+	if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255) {
+		let out = "";
+		for (let i = 2; i + 1 < bytes.length; i += 2) out += String.fromCharCode((bytes[i] ?? 0) << 8 | (bytes[i + 1] ?? 0));
+		return out;
+	}
+	return Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+}
+const PDF_DATE_PATTERN = /^D:(\d{4})(\d{2})?(\d{2})?(\d{2})?(\d{2})?(\d{2})?([+\-Z])?(\d{2})?'?(\d{2})?'?$/;
+function parsePdfDate(raw) {
+	if (raw === void 0) return;
+	const match = PDF_DATE_PATTERN.exec(raw);
+	if (match === null) return;
+	const [, year, month = "01", day = "01", hour = "00", minute = "00", second = "00", tzSign, tzHour = "00", tzMinute = "00"] = match;
+	return `${year}-${month}-${day}T${hour}:${minute}:${second}${tzSign === void 0 || tzSign === "Z" ? "Z" : `${tzSign}${tzHour}:${tzMinute}`}`;
+}
+//#endregion
+export { decodePdfString, parsePdfDate };