pdf-codec 1.3.1 → 1.4.1

package/dist/xref.cjs

@@ -0,0 +1,325 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_reader = require("./bytes/reader.cjs");
+const require_lexer = require("./lexer.cjs");
+const require_objects = require("./objects.cjs");
+const require_filters = require("./filters.cjs");
+const require_parse = require("./parse.cjs");
+//#region src/xref.ts
+const STARTXREF_BYTES = new TextEncoder().encode("startxref");
+const OBJ_BYTES = new TextEncoder().encode("obj");
+const TRAILER_BYTES = new TextEncoder().encode("trailer");
+const DELIMITER_BYTES = /* @__PURE__ */ new Set([
+	40,
+	41,
+	60,
+	62,
+	91,
+	93,
+	123,
+	125,
+	47,
+	37
+]);
+const MAX_XREF_SECTIONS = 64;
+function readXref(bytes, sink) {
+	const startxrefOffset = findStartxrefOffset(bytes);
+	if (startxrefOffset !== void 0) {
+		const { entries, trailer } = walkXrefChain(bytes, startxrefOffset, sink);
+		if (isTableUsable(bytes, entries, trailer)) return {
+			entries,
+			trailer
+		};
+	}
+	sink({
+		code: "pdf/xref-recovered",
+		severity: "warning",
+		message: "the document's own cross-reference data was missing, unreadable, or did not check out against the bytes it points at; rebuilt the table by scanning the file for \"N G obj\" headers"
+	});
+	return recoverXrefByLinearScan(bytes, sink);
+}
+function findLastOccurrence(bytes, needle) {
+	outer: for (let i = bytes.length - needle.length; i >= 0; i--) {
+		for (let j = 0; j < needle.length; j++) if (bytes[i + j] !== needle[j]) continue outer;
+		return i;
+	}
+}
+function findStartxrefOffset(bytes) {
+	const at = findLastOccurrence(bytes, STARTXREF_BYTES);
+	if (at === void 0) return;
+	const reader = new require_bytes_reader.ByteReader(bytes);
+	reader.seek(at + STARTXREF_BYTES.length);
+	const token = require_lexer.nextToken(reader);
+	return token?.kind === "number" ? token.value : void 0;
+}
+function isTableUsable(bytes, entries, trailer) {
+	const root = require_objects.dictGet(trailer, "Root");
+	if (root?.kind !== "ref") return false;
+	const rootEntry = entries.get(root.num);
+	if (rootEntry === void 0) return false;
+	if (rootEntry.type === "compressed") return true;
+	return looksLikeObjectHeaderAt(bytes, rootEntry.offset, root.num);
+}
+function looksLikeObjectHeaderAt(bytes, offset, expectedNum) {
+	if (offset < 0 || offset >= bytes.length) return false;
+	const reader = new require_bytes_reader.ByteReader(bytes);
+	reader.seek(offset);
+	const numTok = require_lexer.nextToken(reader);
+	const genTok = require_lexer.nextToken(reader);
+	const objTok = require_lexer.nextToken(reader);
+	return numTok?.kind === "number" && numTok.value === expectedNum && genTok?.kind === "number" && objTok?.kind === "keyword" && objTok.value === "obj";
+}
+function walkXrefChain(bytes, startOffset, sink) {
+	const merged = /* @__PURE__ */ new Map();
+	const mergedTrailerEntries = /* @__PURE__ */ new Map();
+	const visited = /* @__PURE__ */ new Set();
+	let offset = startOffset;
+	let sections = 0;
+	while (offset !== void 0 && !visited.has(offset) && sections < MAX_XREF_SECTIONS) {
+		visited.add(offset);
+		sections++;
+		const section = readXrefSection(bytes, offset, sink);
+		if (section === void 0) {
+			sink({
+				code: "pdf/xref-entry-invalid",
+				severity: "warning",
+				message: `no readable cross-reference section at offset ${String(offset)}`
+			});
+			break;
+		}
+		for (const [num, entry] of section.entries) if (!merged.has(num)) merged.set(num, entry);
+		for (const [key, value] of section.trailer.entries) if (!mergedTrailerEntries.has(key)) mergedTrailerEntries.set(key, value);
+		offset = section.prevOffset;
+	}
+	return {
+		entries: merged,
+		trailer: require_objects.pdfDict(mergedTrailerEntries)
+	};
+}
+function readXrefSection(bytes, offset, sink) {
+	const reader = new require_bytes_reader.ByteReader(bytes);
+	reader.seek(offset);
+	const mark = reader.mark();
+	const token = require_lexer.nextToken(reader);
+	if (token?.kind === "keyword" && token.value === "xref") return readClassicXrefSection(reader, sink);
+	reader.reset(mark);
+	const indirect = require_parse.parseIndirectObject(reader, sink);
+	if (indirect?.value.kind === "stream") return readXrefStreamSection(indirect.value.dict, indirect.value.raw, sink);
+}
+function readClassicXrefSection(reader, sink) {
+	const entries = /* @__PURE__ */ new Map();
+	for (;;) {
+		const mark = reader.mark();
+		const startTok = require_lexer.nextToken(reader);
+		if (startTok?.kind !== "number") {
+			reader.reset(mark);
+			break;
+		}
+		const countTok = require_lexer.nextToken(reader);
+		if (countTok?.kind !== "number") {
+			sink({
+				code: "pdf/xref-entry-invalid",
+				severity: "warning",
+				message: "classic xref subsection header was not \"start count\""
+			});
+			reader.reset(mark);
+			break;
+		}
+		for (let i = 0; i < countTok.value; i++) {
+			const offsetTok = require_lexer.nextToken(reader);
+			const genTok = require_lexer.nextToken(reader);
+			const typeTok = require_lexer.nextToken(reader);
+			if (offsetTok?.kind !== "number" || genTok?.kind !== "number" || typeTok?.kind !== "keyword") {
+				sink({
+					code: "pdf/xref-entry-invalid",
+					severity: "warning",
+					message: `malformed classic xref entry for object ${String(startTok.value + i)}`
+				});
+				break;
+			}
+			if (typeTok.value === "n") entries.set(startTok.value + i, {
+				type: "offset",
+				offset: offsetTok.value,
+				gen: genTok.value
+			});
+		}
+	}
+	const trailerTok = require_lexer.nextToken(reader);
+	if (trailerTok?.kind !== "keyword" || trailerTok.value !== "trailer") {
+		sink({
+			code: "pdf/xref-entry-invalid",
+			severity: "warning",
+			message: "classic xref section was not followed by a \"trailer\" keyword"
+		});
+		return {
+			entries,
+			trailer: require_objects.pdfDict({}),
+			prevOffset: void 0
+		};
+	}
+	const trailerValue = require_parse.parseValue(reader, sink);
+	const trailer = require_objects.asDict(trailerValue) ?? require_objects.pdfDict({});
+	return {
+		entries,
+		trailer,
+		prevOffset: require_objects.asNumber(require_objects.dictGet(trailer, "Prev"))
+	};
+}
+function readXrefStreamSection(dict, raw, sink) {
+	const decoded = require_filters.decodeStream(raw, dict, sink);
+	const widths = require_objects.asArray(require_objects.dictGet(dict, "W"));
+	const w0 = widths !== void 0 ? require_objects.asNumber(widths[0]) ?? 0 : 1;
+	const w1 = widths !== void 0 ? require_objects.asNumber(widths[1]) ?? 0 : 1;
+	const w2 = widths !== void 0 ? require_objects.asNumber(widths[2]) ?? 0 : 1;
+	const rowLength = w0 + w1 + w2;
+	const size = require_objects.asNumber(require_objects.dictGet(dict, "Size")) ?? 0;
+	const indexArray = require_objects.asArray(require_objects.dictGet(dict, "Index"));
+	const ranges = [];
+	if (indexArray !== void 0) for (let i = 0; i + 1 < indexArray.length; i += 2) {
+		const start = require_objects.asNumber(indexArray[i]);
+		const count = require_objects.asNumber(indexArray[i + 1]);
+		if (start !== void 0 && count !== void 0) ranges.push([start, count]);
+	}
+	else ranges.push([0, size]);
+	const entries = /* @__PURE__ */ new Map();
+	let rowOffset = 0;
+	for (const [start, count] of ranges) for (let i = 0; i < count; i++) {
+		rowOffset += rowLength;
+		const base = rowOffset - rowLength;
+		if (rowLength === 0 || base + rowLength > decoded.bytes.length) {
+			sink({
+				code: "pdf/xref-entry-invalid",
+				severity: "warning",
+				message: `xref stream ran out of data before object ${String(start + i)}`
+			});
+			break;
+		}
+		const type = w0 === 0 ? 1 : readBigEndian(decoded.bytes, base, w0);
+		const field2 = readBigEndian(decoded.bytes, base + w0, w1);
+		const field3 = readBigEndian(decoded.bytes, base + w0 + w1, w2);
+		const objNum = start + i;
+		if (type === 0) continue;
+		else if (type === 1) entries.set(objNum, {
+			type: "offset",
+			offset: field2,
+			gen: field3
+		});
+		else if (type === 2) entries.set(objNum, {
+			type: "compressed",
+			streamObjNum: field2,
+			indexInStream: field3
+		});
+		else sink({
+			code: "pdf/xref-entry-invalid",
+			severity: "warning",
+			message: `xref stream row for object ${String(objNum)} has unrecognised type ${String(type)}`
+		});
+	}
+	return {
+		entries,
+		trailer: dict,
+		prevOffset: require_objects.asNumber(require_objects.dictGet(dict, "Prev"))
+	};
+}
+function readBigEndian(bytes, offset, width) {
+	let value = 0;
+	for (let i = 0; i < width; i++) value = value * 256 + (bytes[offset + i] ?? 0);
+	return value;
+}
+function isBoundaryByte(byte) {
+	return byte === void 0 || require_bytes_reader.isAsciiWhitespace(byte) || DELIMITER_BYTES.has(byte);
+}
+function findAllKeywordPositions(bytes, needle) {
+	const positions = [];
+	outer: for (let i = 0; i <= bytes.length - needle.length; i++) {
+		if (!isBoundaryByte(bytes[i - 1])) continue;
+		for (let j = 0; j < needle.length; j++) if (bytes[i + j] !== needle[j]) continue outer;
+		if (!isBoundaryByte(bytes[i + needle.length])) continue;
+		positions.push(i);
+	}
+	return positions;
+}
+function isDigitByte(byte) {
+	return byte !== void 0 && byte >= 48 && byte <= 57;
+}
+function scanBackWhile(bytes, end, predicate) {
+	let i = end;
+	while (i > 0 && predicate(bytes[i - 1])) i--;
+	return i;
+}
+function scanObjectHeaderBackward(bytes, objKeywordStart) {
+	const genEnd = scanBackWhile(bytes, objKeywordStart, require_bytes_reader.isAsciiWhitespace);
+	const genStart = scanBackWhile(bytes, genEnd, isDigitByte);
+	if (genStart === genEnd) return;
+	const numEnd = scanBackWhile(bytes, genStart, require_bytes_reader.isAsciiWhitespace);
+	const numStart = scanBackWhile(bytes, numEnd, isDigitByte);
+	if (numStart === numEnd) return;
+	const decoder = new TextDecoder("latin1");
+	return {
+		num: Number(decoder.decode(bytes.subarray(numStart, numEnd))),
+		gen: Number(decoder.decode(bytes.subarray(genStart, genEnd))),
+		headerStart: numStart
+	};
+}
+function recoverXrefByLinearScan(bytes, sink) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const objPos of findAllKeywordPositions(bytes, OBJ_BYTES)) {
+		const header = scanObjectHeaderBackward(bytes, objPos);
+		if (header === void 0) continue;
+		entries.set(header.num, {
+			type: "offset",
+			offset: header.headerStart,
+			gen: header.gen
+		});
+	}
+	let lastCatalogRef;
+	let lastXrefTrailerDict;
+	for (const [num, entry] of entries) {
+		if (entry.type !== "offset") continue;
+		const reader = new require_bytes_reader.ByteReader(bytes);
+		reader.seek(entry.offset);
+		const indirect = require_parse.parseIndirectObject(reader, sink);
+		if (indirect === void 0) continue;
+		const dict = require_objects.asDict(indirect.value);
+		if (dict === void 0) continue;
+		if (require_objects.isName(require_objects.dictGet(dict, "Type"), "Catalog")) lastCatalogRef = require_objects.pdfRef(num, entry.gen);
+		if (require_objects.isName(require_objects.dictGet(dict, "Type"), "XRef")) lastXrefTrailerDict = dict;
+		if (indirect.value.kind === "stream" && require_objects.isName(require_objects.dictGet(dict, "Type"), "ObjStm")) registerObjStmContents(num, indirect.value.dict, indirect.value.raw, entries, sink);
+	}
+	return {
+		entries,
+		trailer: findRecoveredTrailer(bytes, sink) ?? lastXrefTrailerDict ?? (lastCatalogRef !== void 0 ? require_objects.pdfDict({ Root: lastCatalogRef }) : require_objects.pdfDict({}))
+	};
+}
+function registerObjStmContents(streamObjNum, dict, raw, entries, sink) {
+	const decoded = require_filters.decodeStream(raw, dict, sink);
+	const n = require_objects.asNumber(require_objects.dictGet(dict, "N")) ?? 0;
+	const reader = new require_bytes_reader.ByteReader(decoded.bytes);
+	let index = 0;
+	for (let i = 0; i < n; i++) {
+		const numTok = require_lexer.nextToken(reader);
+		const offTok = require_lexer.nextToken(reader);
+		if (numTok?.kind !== "number" || offTok?.kind !== "number") {
+			sink({
+				code: "pdf/xref-entry-invalid",
+				severity: "warning",
+				message: `recovered object stream ${String(streamObjNum)} header is truncated at entry ${String(i)}`
+			});
+			break;
+		}
+		if (!entries.has(numTok.value)) entries.set(numTok.value, {
+			type: "compressed",
+			streamObjNum,
+			indexInStream: index
+		});
+		index++;
+	}
+}
+function findRecoveredTrailer(bytes, sink) {
+	const at = findLastOccurrence(bytes, TRAILER_BYTES);
+	if (at === void 0) return;
+	const reader = new require_bytes_reader.ByteReader(bytes);
+	reader.seek(at + TRAILER_BYTES.length);
+	return require_objects.asDict(require_parse.parseValue(reader, sink));
+}
+//#endregion
+exports.readXref = readXref;

package/dist/xref.d.cts

@@ -0,0 +1,21 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+import { PdfDict } from "./objects.cjs";
+//#region src/xref.d.ts
+interface XrefOffsetEntry {
+  readonly type: 'offset';
+  readonly offset: number;
+  readonly gen: number;
+}
+interface XrefCompressedEntry {
+  readonly type: 'compressed';
+  readonly streamObjNum: number;
+  readonly indexInStream: number;
+}
+type XrefEntry = XrefOffsetEntry | XrefCompressedEntry;
+interface XrefTable {
+  readonly entries: ReadonlyMap<number, XrefEntry>;
+  readonly trailer: PdfDict;
+}
+declare function readXref(bytes: Uint8Array<ArrayBuffer>, sink: PdfDiagnosticSink): XrefTable;
+//#endregion
+export { XrefCompressedEntry, XrefEntry, XrefOffsetEntry, XrefTable, readXref };

package/dist/xref.d.ts

@@ -0,0 +1,21 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { PdfDict } from "./objects.js";
+//#region src/xref.d.ts
+interface XrefOffsetEntry {
+  readonly type: 'offset';
+  readonly offset: number;
+  readonly gen: number;
+}
+interface XrefCompressedEntry {
+  readonly type: 'compressed';
+  readonly streamObjNum: number;
+  readonly indexInStream: number;
+}
+type XrefEntry = XrefOffsetEntry | XrefCompressedEntry;
+interface XrefTable {
+  readonly entries: ReadonlyMap<number, XrefEntry>;
+  readonly trailer: PdfDict;
+}
+declare function readXref(bytes: Uint8Array<ArrayBuffer>, sink: PdfDiagnosticSink): XrefTable;
+//#endregion
+export { XrefCompressedEntry, XrefEntry, XrefOffsetEntry, XrefTable, readXref };

package/dist/xref.js

@@ -0,0 +1,324 @@
+import { ByteReader, isAsciiWhitespace } from "./bytes/reader.js";
+import { nextToken } from "./lexer.js";
+import { asArray, asDict, asNumber, dictGet, isName, pdfDict, pdfRef } from "./objects.js";
+import { decodeStream } from "./filters.js";
+import { parseIndirectObject, parseValue } from "./parse.js";
+//#region src/xref.ts
+const STARTXREF_BYTES = new TextEncoder().encode("startxref");
+const OBJ_BYTES = new TextEncoder().encode("obj");
+const TRAILER_BYTES = new TextEncoder().encode("trailer");
+const DELIMITER_BYTES = /* @__PURE__ */ new Set([
+	40,
+	41,
+	60,
+	62,
+	91,
+	93,
+	123,
+	125,
+	47,
+	37
+]);
+const MAX_XREF_SECTIONS = 64;
+function readXref(bytes, sink) {
+	const startxrefOffset = findStartxrefOffset(bytes);
+	if (startxrefOffset !== void 0) {
+		const { entries, trailer } = walkXrefChain(bytes, startxrefOffset, sink);
+		if (isTableUsable(bytes, entries, trailer)) return {
+			entries,
+			trailer
+		};
+	}
+	sink({
+		code: "pdf/xref-recovered",
+		severity: "warning",
+		message: "the document's own cross-reference data was missing, unreadable, or did not check out against the bytes it points at; rebuilt the table by scanning the file for \"N G obj\" headers"
+	});
+	return recoverXrefByLinearScan(bytes, sink);
+}
+function findLastOccurrence(bytes, needle) {
+	outer: for (let i = bytes.length - needle.length; i >= 0; i--) {
+		for (let j = 0; j < needle.length; j++) if (bytes[i + j] !== needle[j]) continue outer;
+		return i;
+	}
+}
+function findStartxrefOffset(bytes) {
+	const at = findLastOccurrence(bytes, STARTXREF_BYTES);
+	if (at === void 0) return;
+	const reader = new ByteReader(bytes);
+	reader.seek(at + STARTXREF_BYTES.length);
+	const token = nextToken(reader);
+	return token?.kind === "number" ? token.value : void 0;
+}
+function isTableUsable(bytes, entries, trailer) {
+	const root = dictGet(trailer, "Root");
+	if (root?.kind !== "ref") return false;
+	const rootEntry = entries.get(root.num);
+	if (rootEntry === void 0) return false;
+	if (rootEntry.type === "compressed") return true;
+	return looksLikeObjectHeaderAt(bytes, rootEntry.offset, root.num);
+}
+function looksLikeObjectHeaderAt(bytes, offset, expectedNum) {
+	if (offset < 0 || offset >= bytes.length) return false;
+	const reader = new ByteReader(bytes);
+	reader.seek(offset);
+	const numTok = nextToken(reader);
+	const genTok = nextToken(reader);
+	const objTok = nextToken(reader);
+	return numTok?.kind === "number" && numTok.value === expectedNum && genTok?.kind === "number" && objTok?.kind === "keyword" && objTok.value === "obj";
+}
+function walkXrefChain(bytes, startOffset, sink) {
+	const merged = /* @__PURE__ */ new Map();
+	const mergedTrailerEntries = /* @__PURE__ */ new Map();
+	const visited = /* @__PURE__ */ new Set();
+	let offset = startOffset;
+	let sections = 0;
+	while (offset !== void 0 && !visited.has(offset) && sections < MAX_XREF_SECTIONS) {
+		visited.add(offset);
+		sections++;
+		const section = readXrefSection(bytes, offset, sink);
+		if (section === void 0) {
+			sink({
+				code: "pdf/xref-entry-invalid",
+				severity: "warning",
+				message: `no readable cross-reference section at offset ${String(offset)}`
+			});
+			break;
+		}
+		for (const [num, entry] of section.entries) if (!merged.has(num)) merged.set(num, entry);
+		for (const [key, value] of section.trailer.entries) if (!mergedTrailerEntries.has(key)) mergedTrailerEntries.set(key, value);
+		offset = section.prevOffset;
+	}
+	return {
+		entries: merged,
+		trailer: pdfDict(mergedTrailerEntries)
+	};
+}
+function readXrefSection(bytes, offset, sink) {
+	const reader = new ByteReader(bytes);
+	reader.seek(offset);
+	const mark = reader.mark();
+	const token = nextToken(reader);
+	if (token?.kind === "keyword" && token.value === "xref") return readClassicXrefSection(reader, sink);
+	reader.reset(mark);
+	const indirect = parseIndirectObject(reader, sink);
+	if (indirect?.value.kind === "stream") return readXrefStreamSection(indirect.value.dict, indirect.value.raw, sink);
+}
+function readClassicXrefSection(reader, sink) {
+	const entries = /* @__PURE__ */ new Map();
+	for (;;) {
+		const mark = reader.mark();
+		const startTok = nextToken(reader);
+		if (startTok?.kind !== "number") {
+			reader.reset(mark);
+			break;
+		}
+		const countTok = nextToken(reader);
+		if (countTok?.kind !== "number") {
+			sink({
+				code: "pdf/xref-entry-invalid",
+				severity: "warning",
+				message: "classic xref subsection header was not \"start count\""
+			});
+			reader.reset(mark);
+			break;
+		}
+		for (let i = 0; i < countTok.value; i++) {
+			const offsetTok = nextToken(reader);
+			const genTok = nextToken(reader);
+			const typeTok = nextToken(reader);
+			if (offsetTok?.kind !== "number" || genTok?.kind !== "number" || typeTok?.kind !== "keyword") {
+				sink({
+					code: "pdf/xref-entry-invalid",
+					severity: "warning",
+					message: `malformed classic xref entry for object ${String(startTok.value + i)}`
+				});
+				break;
+			}
+			if (typeTok.value === "n") entries.set(startTok.value + i, {
+				type: "offset",
+				offset: offsetTok.value,
+				gen: genTok.value
+			});
+		}
+	}
+	const trailerTok = nextToken(reader);
+	if (trailerTok?.kind !== "keyword" || trailerTok.value !== "trailer") {
+		sink({
+			code: "pdf/xref-entry-invalid",
+			severity: "warning",
+			message: "classic xref section was not followed by a \"trailer\" keyword"
+		});
+		return {
+			entries,
+			trailer: pdfDict({}),
+			prevOffset: void 0
+		};
+	}
+	const trailerValue = parseValue(reader, sink);
+	const trailer = asDict(trailerValue) ?? pdfDict({});
+	return {
+		entries,
+		trailer,
+		prevOffset: asNumber(dictGet(trailer, "Prev"))
+	};
+}
+function readXrefStreamSection(dict, raw, sink) {
+	const decoded = decodeStream(raw, dict, sink);
+	const widths = asArray(dictGet(dict, "W"));
+	const w0 = widths !== void 0 ? asNumber(widths[0]) ?? 0 : 1;
+	const w1 = widths !== void 0 ? asNumber(widths[1]) ?? 0 : 1;
+	const w2 = widths !== void 0 ? asNumber(widths[2]) ?? 0 : 1;
+	const rowLength = w0 + w1 + w2;
+	const size = asNumber(dictGet(dict, "Size")) ?? 0;
+	const indexArray = asArray(dictGet(dict, "Index"));
+	const ranges = [];
+	if (indexArray !== void 0) for (let i = 0; i + 1 < indexArray.length; i += 2) {
+		const start = asNumber(indexArray[i]);
+		const count = asNumber(indexArray[i + 1]);
+		if (start !== void 0 && count !== void 0) ranges.push([start, count]);
+	}
+	else ranges.push([0, size]);
+	const entries = /* @__PURE__ */ new Map();
+	let rowOffset = 0;
+	for (const [start, count] of ranges) for (let i = 0; i < count; i++) {
+		rowOffset += rowLength;
+		const base = rowOffset - rowLength;
+		if (rowLength === 0 || base + rowLength > decoded.bytes.length) {
+			sink({
+				code: "pdf/xref-entry-invalid",
+				severity: "warning",
+				message: `xref stream ran out of data before object ${String(start + i)}`
+			});
+			break;
+		}
+		const type = w0 === 0 ? 1 : readBigEndian(decoded.bytes, base, w0);
+		const field2 = readBigEndian(decoded.bytes, base + w0, w1);
+		const field3 = readBigEndian(decoded.bytes, base + w0 + w1, w2);
+		const objNum = start + i;
+		if (type === 0) continue;
+		else if (type === 1) entries.set(objNum, {
+			type: "offset",
+			offset: field2,
+			gen: field3
+		});
+		else if (type === 2) entries.set(objNum, {
+			type: "compressed",
+			streamObjNum: field2,
+			indexInStream: field3
+		});
+		else sink({
+			code: "pdf/xref-entry-invalid",
+			severity: "warning",
+			message: `xref stream row for object ${String(objNum)} has unrecognised type ${String(type)}`
+		});
+	}
+	return {
+		entries,
+		trailer: dict,
+		prevOffset: asNumber(dictGet(dict, "Prev"))
+	};
+}
+function readBigEndian(bytes, offset, width) {
+	let value = 0;
+	for (let i = 0; i < width; i++) value = value * 256 + (bytes[offset + i] ?? 0);
+	return value;
+}
+function isBoundaryByte(byte) {
+	return byte === void 0 || isAsciiWhitespace(byte) || DELIMITER_BYTES.has(byte);
+}
+function findAllKeywordPositions(bytes, needle) {
+	const positions = [];
+	outer: for (let i = 0; i <= bytes.length - needle.length; i++) {
+		if (!isBoundaryByte(bytes[i - 1])) continue;
+		for (let j = 0; j < needle.length; j++) if (bytes[i + j] !== needle[j]) continue outer;
+		if (!isBoundaryByte(bytes[i + needle.length])) continue;
+		positions.push(i);
+	}
+	return positions;
+}
+function isDigitByte(byte) {
+	return byte !== void 0 && byte >= 48 && byte <= 57;
+}
+function scanBackWhile(bytes, end, predicate) {
+	let i = end;
+	while (i > 0 && predicate(bytes[i - 1])) i--;
+	return i;
+}
+function scanObjectHeaderBackward(bytes, objKeywordStart) {
+	const genEnd = scanBackWhile(bytes, objKeywordStart, isAsciiWhitespace);
+	const genStart = scanBackWhile(bytes, genEnd, isDigitByte);
+	if (genStart === genEnd) return;
+	const numEnd = scanBackWhile(bytes, genStart, isAsciiWhitespace);
+	const numStart = scanBackWhile(bytes, numEnd, isDigitByte);
+	if (numStart === numEnd) return;
+	const decoder = new TextDecoder("latin1");
+	return {
+		num: Number(decoder.decode(bytes.subarray(numStart, numEnd))),
+		gen: Number(decoder.decode(bytes.subarray(genStart, genEnd))),
+		headerStart: numStart
+	};
+}
+function recoverXrefByLinearScan(bytes, sink) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const objPos of findAllKeywordPositions(bytes, OBJ_BYTES)) {
+		const header = scanObjectHeaderBackward(bytes, objPos);
+		if (header === void 0) continue;
+		entries.set(header.num, {
+			type: "offset",
+			offset: header.headerStart,
+			gen: header.gen
+		});
+	}
+	let lastCatalogRef;
+	let lastXrefTrailerDict;
+	for (const [num, entry] of entries) {
+		if (entry.type !== "offset") continue;
+		const reader = new ByteReader(bytes);
+		reader.seek(entry.offset);
+		const indirect = parseIndirectObject(reader, sink);
+		if (indirect === void 0) continue;
+		const dict = asDict(indirect.value);
+		if (dict === void 0) continue;
+		if (isName(dictGet(dict, "Type"), "Catalog")) lastCatalogRef = pdfRef(num, entry.gen);
+		if (isName(dictGet(dict, "Type"), "XRef")) lastXrefTrailerDict = dict;
+		if (indirect.value.kind === "stream" && isName(dictGet(dict, "Type"), "ObjStm")) registerObjStmContents(num, indirect.value.dict, indirect.value.raw, entries, sink);
+	}
+	return {
+		entries,
+		trailer: findRecoveredTrailer(bytes, sink) ?? lastXrefTrailerDict ?? (lastCatalogRef !== void 0 ? pdfDict({ Root: lastCatalogRef }) : pdfDict({}))
+	};
+}
+function registerObjStmContents(streamObjNum, dict, raw, entries, sink) {
+	const decoded = decodeStream(raw, dict, sink);
+	const n = asNumber(dictGet(dict, "N")) ?? 0;
+	const reader = new ByteReader(decoded.bytes);
+	let index = 0;
+	for (let i = 0; i < n; i++) {
+		const numTok = nextToken(reader);
+		const offTok = nextToken(reader);
+		if (numTok?.kind !== "number" || offTok?.kind !== "number") {
+			sink({
+				code: "pdf/xref-entry-invalid",
+				severity: "warning",
+				message: `recovered object stream ${String(streamObjNum)} header is truncated at entry ${String(i)}`
+			});
+			break;
+		}
+		if (!entries.has(numTok.value)) entries.set(numTok.value, {
+			type: "compressed",
+			streamObjNum,
+			indexInStream: index
+		});
+		index++;
+	}
+}
+function findRecoveredTrailer(bytes, sink) {
+	const at = findLastOccurrence(bytes, TRAILER_BYTES);
+	if (at === void 0) return;
+	const reader = new ByteReader(bytes);
+	reader.seek(at + TRAILER_BYTES.length);
+	return asDict(parseValue(reader, sink));
+}
+//#endregion
+export { readXref };