reamkit 1.5.0 → 1.7.0

package/dist/esm/pdf-reader/decrypt.js

@@ -0,0 +1,199 @@
+import { PdfHexString, PdfName, PdfStream } from "../pdf/objects.js";
+import { aesCbcDecrypt, aesCbcEncrypt, md5, rc4, sha256, sha384, sha512 } from "./crypto.js";
+//#region src/pdf-reader/decrypt.ts
+var PAD = Uint8Array.from([
+	40,
+	191,
+	78,
+	94,
+	78,
+	117,
+	138,
+	65,
+	100,
+	0,
+	78,
+	86,
+	255,
+	250,
+	1,
+	8,
+	46,
+	46,
+	0,
+	182,
+	208,
+	104,
+	62,
+	128,
+	47,
+	12,
+	169,
+	254,
+	100,
+	83,
+	105,
+	122
+]);
+var AES_SALT = Uint8Array.from([
+	115,
+	65,
+	108,
+	84
+]);
+var ZERO16 = new Uint8Array(16);
+var EMPTY = new Uint8Array(0);
+function buildDecryptor(encrypt, idArray) {
+	const filter = encrypt.get("Filter");
+	if (!(filter instanceof PdfName) || filter.value !== "Standard") return void 0;
+	const v = numOf(encrypt.get("V"));
+	const r = numOf(encrypt.get("R"));
+	let fileKey;
+	let method;
+	if (r >= 5 || v >= 5) {
+		fileKey = deriveKeyR6(strBytes(encrypt.get("U")), strBytes(encrypt.get("UE")));
+		method = "aesv3";
+	} else {
+		const keyLen = (numOf(encrypt.get("Length")) || 40) / 8;
+		const id0 = Array.isArray(idArray) ? strBytes(idArray[0]) : EMPTY;
+		fileKey = deriveKeyLegacy(strBytes(encrypt.get("O")), numOf(encrypt.get("P")) | 0, id0, r, Math.max(5, Math.min(16, keyLen)), encrypt.get("EncryptMetadata") !== false);
+		const m = cipherMethod(encrypt, v);
+		if (m === void 0) return void 0;
+		method = m;
+	}
+	if (!fileKey) return void 0;
+	const key = fileKey;
+	return { decrypt: (value, objNum, gen) => decryptValue(value, objNum, gen, key, method) };
+}
+function deriveKeyLegacy(o, p, id0, r, keyLen, encryptMetadata) {
+	const tail = r >= 4 && !encryptMetadata ? Uint8Array.from([
+		255,
+		255,
+		255,
+		255
+	]) : EMPTY;
+	let hash = md5(concat(PAD, o.subarray(0, 32), p32le(p), id0, tail));
+	if (r >= 3) for (let i = 0; i < 50; i++) hash = md5(hash.subarray(0, keyLen));
+	return hash.subarray(0, keyLen);
+}
+function deriveKeyR6(u, ue) {
+	if (u.length < 48 || ue.length < 32) return void 0;
+	const validationSalt = u.subarray(32, 40);
+	const keySalt = u.subarray(40, 48);
+	if (!equal(hash2B(EMPTY, validationSalt, EMPTY), u.subarray(0, 32))) return void 0;
+	return aesCbcDecrypt(hash2B(EMPTY, keySalt, EMPTY), ZERO16, ue.subarray(0, 32), false);
+}
+function hash2B(pw, salt, udata) {
+	let k = sha256(concat(pw, salt, udata));
+	for (let round = 1; round <= 256; round++) {
+		const block = concat(pw, k, udata);
+		const k1 = new Uint8Array(block.length * 64);
+		for (let i = 0; i < 64; i++) k1.set(block, i * block.length);
+		const e = aesCbcEncrypt(k.subarray(0, 16), k.subarray(16, 32), k1);
+		let sum = 0;
+		for (let i = 0; i < 16; i++) sum += e[i];
+		const mod = sum % 3;
+		k = mod === 0 ? sha256(e) : mod === 1 ? sha384(e) : sha512(e);
+		if (round >= 64 && e[e.length - 1] <= round - 32) break;
+	}
+	return k.subarray(0, 32);
+}
+function cipherMethod(encrypt, v) {
+	if (v < 4) return "rc4";
+	const stmf = encrypt.get("StmF");
+	const cfName = stmf instanceof PdfName ? stmf.value : "StdCF";
+	if (cfName === "Identity") return void 0;
+	const cf = encrypt.get("CF");
+	const cfDict = cf instanceof Map ? cf.get(cfName) : void 0;
+	const cfm = cfDict instanceof Map ? cfDict.get("CFM") : void 0;
+	if (cfm instanceof PdfName) {
+		if (cfm.value === "AESV2") return "aesv2";
+		if (cfm.value === "AESV3") return "aesv3";
+	}
+	return "rc4";
+}
+function objectKey(fileKey, objNum, gen, aes) {
+	const extra = aes ? AES_SALT : EMPTY;
+	const seed = new Uint8Array(fileKey.length + 5 + extra.length);
+	seed.set(fileKey, 0);
+	seed[fileKey.length] = objNum & 255;
+	seed[fileKey.length + 1] = objNum >> 8 & 255;
+	seed[fileKey.length + 2] = objNum >> 16 & 255;
+	seed[fileKey.length + 3] = gen & 255;
+	seed[fileKey.length + 4] = gen >> 8 & 255;
+	seed.set(extra, fileKey.length + 5);
+	return md5(seed).subarray(0, Math.min(fileKey.length + 5, 16));
+}
+function decryptBytes(data, objNum, gen, fileKey, method) {
+	if (method === "aesv3") {
+		if (data.length < 16) return data;
+		return aesCbcDecrypt(fileKey, data.subarray(0, 16), data.subarray(16), true);
+	}
+	const key = objectKey(fileKey, objNum, gen, method === "aesv2");
+	if (method === "aesv2") {
+		if (data.length < 16) return data;
+		return aesCbcDecrypt(key, data.subarray(0, 16), data.subarray(16), true);
+	}
+	return rc4(key, data);
+}
+function decryptValue(value, objNum, gen, fileKey, method) {
+	if (typeof value === "string") return latin1(decryptBytes(strToBytes(value), objNum, gen, fileKey, method));
+	if (value instanceof PdfHexString) return new PdfHexString(decryptBytes(value.bytes, objNum, gen, fileKey, method));
+	if (value instanceof PdfStream) {
+		const dict = decryptValue(value.dict, objNum, gen, fileKey, method);
+		const data = decryptBytes(value.data, objNum, gen, fileKey, method);
+		return new PdfStream(dict instanceof Map ? dict : value.dict, data);
+	}
+	if (Array.isArray(value)) return value.map((v) => decryptValue(v, objNum, gen, fileKey, method));
+	if (value instanceof Map) {
+		const out = /* @__PURE__ */ new Map();
+		for (const [k, v] of value) out.set(k, decryptValue(v, objNum, gen, fileKey, method));
+		return out;
+	}
+	return value;
+}
+function numOf(v) {
+	return typeof v === "number" ? v : 0;
+}
+function strBytes(v) {
+	if (v instanceof PdfHexString) return v.bytes;
+	if (typeof v === "string") return strToBytes(v);
+	return EMPTY;
+}
+function strToBytes(s) {
+	const out = new Uint8Array(s.length);
+	for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i) & 255;
+	return out;
+}
+function latin1(b) {
+	let s = "";
+	for (const x of b) s += String.fromCharCode(x);
+	return s;
+}
+function p32le(p) {
+	const u = p >>> 0;
+	return Uint8Array.from([
+		u & 255,
+		u >> 8 & 255,
+		u >> 16 & 255,
+		u >> 24 & 255
+	]);
+}
+function concat(...parts) {
+	let total = 0;
+	for (const p of parts) total += p.length;
+	const out = new Uint8Array(total);
+	let off = 0;
+	for (const p of parts) {
+		out.set(p, off);
+		off += p.length;
+	}
+	return out;
+}
+function equal(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+//#endregion
+export { buildDecryptor };

package/dist/esm/pdf-reader/document.d.ts

@@ -0,0 +1,30 @@
+import { PdfArray, PdfDict, PdfValue, PdfStream } from '../pdf/objects.js';
+export type Rectangle = readonly [number, number, number, number];
+export interface PdfPage {
+    readonly dict: PdfDict;
+    readonly mediaBox: Rectangle;
+    readonly resources: PdfDict | undefined;
+}
+export declare class PdfFile {
+    private readonly buf;
+    private readonly xref;
+    readonly trailer: PdfDict;
+    private readonly cache;
+    private readonly objStmCache;
+    private decryptor;
+    private encryptObjNum;
+    private constructor();
+    static parse(bytes: Uint8Array): PdfFile;
+    private initEncryption;
+    private readonly lengthResolver;
+    resolve(value: PdfValue): PdfValue;
+    private objectFromStream;
+    get(dict: PdfDict, key: string): PdfValue;
+    get catalog(): PdfDict;
+    get encryptionUnsupported(): boolean;
+    pages(): Array<PdfPage>;
+    private walkPageTree;
+    pageContent(page: PdfPage): Uint8Array;
+    streamData(stream: PdfStream): Uint8Array;
+}
+export type { PdfArray };

package/dist/esm/pdf-reader/document.js

@@ -0,0 +1,413 @@
+import { PDF_NULL, PdfName, PdfRef, PdfStream } from "../pdf/objects.js";
+import { buildDecryptor } from "./decrypt.js";
+import { Lexer } from "./lexer.js";
+import { parseIndirectObject, parseObject } from "./parser.js";
+import { reversePredictor } from "./predictor.js";
+import { unzlibSync } from "fflate";
+//#region src/pdf-reader/document.ts
+var DEFAULT_MEDIA_BOX = [
+	0,
+	0,
+	612,
+	792
+];
+var MAX_PAGES = 5e4;
+var MAX_OBJSTM_N = 2e5;
+var PdfFile = class PdfFile {
+	cache = /* @__PURE__ */ new Map();
+	objStmCache = /* @__PURE__ */ new Map();
+	decryptor;
+	encryptObjNum = -1;
+	constructor(buf, xref, trailer) {
+		this.buf = buf;
+		this.xref = xref;
+		this.trailer = trailer;
+	}
+	static parse(bytes) {
+		let xref = /* @__PURE__ */ new Map();
+		let trailer = /* @__PURE__ */ new Map();
+		try {
+			const start = findStartXref(bytes);
+			if (start >= 0) {
+				const built = readXrefChain(bytes, start);
+				xref = built.xref;
+				trailer = built.trailer;
+			}
+		} catch {}
+		if (xref.size === 0 || !(trailer.get("Root") instanceof PdfRef)) {
+			const scanned = bruteForceScan(bytes);
+			for (const [id, entry] of scanned.xref) if (!xref.has(id)) xref.set(id, entry);
+			if (!(trailer.get("Root") instanceof PdfRef) && scanned.root) {
+				trailer = new Map(trailer);
+				trailer.set("Root", scanned.root);
+			}
+		}
+		const file = new PdfFile(bytes, xref, trailer);
+		file.initEncryption();
+		return file;
+	}
+	initEncryption() {
+		const encVal = this.trailer.get("Encrypt");
+		if (encVal === void 0) return;
+		if (encVal instanceof PdfRef) this.encryptObjNum = encVal.id;
+		const enc = this.resolve(encVal);
+		if (!(enc instanceof Map)) return;
+		const id = this.trailer.get("ID");
+		this.decryptor = buildDecryptor(enc, Array.isArray(id) ? id : void 0);
+	}
+	lengthResolver = (r) => {
+		const n = this.resolve(r);
+		return typeof n === "number" ? n : void 0;
+	};
+	resolve(value) {
+		if (!(value instanceof PdfRef)) return value;
+		const cached = this.cache.get(value.id);
+		if (cached !== void 0) return cached;
+		const entry = this.xref.get(value.id);
+		if (entry === void 0) return PDF_NULL;
+		this.cache.set(value.id, PDF_NULL);
+		let result = PDF_NULL;
+		if (entry.kind === "uncompressed") {
+			if (entry.offset >= 0 && entry.offset < this.buf.length) {
+				const obj = parseIndirectObject(new Lexer(this.buf, entry.offset), this.lengthResolver);
+				result = obj ? obj.value : PDF_NULL;
+				if (this.decryptor && value.id !== this.encryptObjNum) result = this.decryptor.decrypt(result, value.id, obj?.generation ?? 0);
+			}
+		} else result = this.objectFromStream(entry.streamObj).get(value.id) ?? PDF_NULL;
+		this.cache.set(value.id, result);
+		return result;
+	}
+	objectFromStream(streamObj) {
+		const cached = this.objStmCache.get(streamObj);
+		if (cached) return cached;
+		const out = /* @__PURE__ */ new Map();
+		this.objStmCache.set(streamObj, out);
+		const entry = this.xref.get(streamObj);
+		if (!entry || entry.kind !== "uncompressed") return out;
+		const obj = parseIndirectObject(new Lexer(this.buf, entry.offset), this.lengthResolver);
+		if (!obj || !(obj.value instanceof PdfStream)) return out;
+		let stream = obj.value;
+		if (this.decryptor) {
+			const dec = this.decryptor.decrypt(stream, streamObj, obj.generation);
+			if (dec instanceof PdfStream) stream = dec;
+		}
+		const data = inflateStream(stream);
+		const first = numOf(this.resolve(stream.dict.get("First") ?? PDF_NULL));
+		for (const member of objStmHeader(data, numOf(this.resolve(stream.dict.get("N") ?? PDF_NULL)))) out.set(member.id, parseObject(new Lexer(data, first + member.off), this.lengthResolver));
+		return out;
+	}
+	get(dict, key) {
+		return this.resolve(dict.get(key) ?? PDF_NULL);
+	}
+	get catalog() {
+		const root = this.resolve(this.trailer.get("Root") ?? PDF_NULL);
+		return root instanceof Map ? root : /* @__PURE__ */ new Map();
+	}
+	get encryptionUnsupported() {
+		return this.trailer.get("Encrypt") !== void 0 && this.decryptor === void 0;
+	}
+	pages() {
+		const out = [];
+		const root = this.get(this.catalog, "Pages");
+		if (root instanceof Map) this.walkPageTree(root, {}, out, /* @__PURE__ */ new Set());
+		return out;
+	}
+	walkPageTree(node, inherited, out, seen) {
+		if (out.length >= MAX_PAGES || seen.has(node)) return;
+		seen.add(node);
+		const mediaBox = readRectangle(this.get(node, "MediaBox")) ?? inherited.mediaBox;
+		const resourcesVal = this.get(node, "Resources");
+		const resources = resourcesVal instanceof Map ? resourcesVal : inherited.resources;
+		const type = node.get("Type");
+		const kids = this.get(node, "Kids");
+		if (type instanceof PdfName && type.value === "Pages" && Array.isArray(kids)) {
+			for (const kid of kids) {
+				const kidNode = this.resolve(kid);
+				if (kidNode instanceof Map) this.walkPageTree(kidNode, {
+					mediaBox,
+					resources
+				}, out, seen);
+				if (out.length >= MAX_PAGES) break;
+			}
+			return;
+		}
+		out.push({
+			dict: node,
+			mediaBox: mediaBox ?? DEFAULT_MEDIA_BOX,
+			resources
+		});
+	}
+	pageContent(page) {
+		const contents = this.get(page.dict, "Contents");
+		const streams = [];
+		if (contents instanceof PdfStream) streams.push(contents);
+		else if (Array.isArray(contents)) for (const c of contents) {
+			const s = this.resolve(c);
+			if (s instanceof PdfStream) streams.push(s);
+		}
+		return concatWithSpaces(streams.map((s) => this.streamData(s)));
+	}
+	streamData(stream) {
+		let data = stream.data;
+		const filter = this.resolve(stream.dict.get("Filter") ?? PDF_NULL);
+		const filters = Array.isArray(filter) ? filter : [filter];
+		let flate = false;
+		for (const f of filters) if (f instanceof PdfName && (f.value === "FlateDecode" || f.value === "Fl")) try {
+			data = unzlibSync(data);
+			flate = true;
+		} catch {}
+		return flate ? applyStreamPredictor(this, stream.dict, data) : data;
+	}
+};
+function findStartXref(buf) {
+	const tail = lastIndexOfAscii(buf, "startxref");
+	if (tail < 0) return -1;
+	const tok = new Lexer(buf, tail + 9).nextToken();
+	return tok.kind === "num" ? tok.value : -1;
+}
+function readXrefChain(buf, offset) {
+	const xref = /* @__PURE__ */ new Map();
+	let trailer = /* @__PURE__ */ new Map();
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [offset];
+	while (queue.length > 0) {
+		const at = queue.shift();
+		if (at < 0 || at >= buf.length || visited.has(at)) continue;
+		visited.add(at);
+		const section = readXrefAt(buf, at);
+		if (!section) continue;
+		for (const [id, entry] of section.xref) if (!xref.has(id)) xref.set(id, entry);
+		if (trailer.size === 0) trailer = section.trailer;
+		const xrefStm = section.trailer.get("XRefStm");
+		if (typeof xrefStm === "number") queue.push(xrefStm);
+		const prev = section.trailer.get("Prev");
+		if (typeof prev === "number") queue.push(prev);
+	}
+	return {
+		xref,
+		trailer
+	};
+}
+function readXrefAt(buf, offset) {
+	const lexer = new Lexer(buf, offset);
+	const head = lexer.nextToken();
+	if (head.kind === "keyword" && head.value === "xref") return readClassicXref(lexer);
+	const obj = parseIndirectObject(new Lexer(buf, offset));
+	if (obj && obj.value instanceof PdfStream) return readXrefStream(obj.value);
+}
+function readClassicXref(lexer) {
+	const xref = /* @__PURE__ */ new Map();
+	for (;;) {
+		const tok = lexer.nextToken();
+		if (tok.kind === "keyword" && tok.value === "trailer") break;
+		if (tok.kind !== "num") return void 0;
+		const first = tok.value;
+		const countTok = lexer.nextToken();
+		if (countTok.kind !== "num") return void 0;
+		const count = countTok.value;
+		for (let i = 0; i < count; i++) {
+			const off = lexer.nextToken();
+			const gen = lexer.nextToken();
+			const type = lexer.nextToken();
+			if (off.kind !== "num" || gen.kind !== "num" || type.kind !== "keyword") return void 0;
+			if (type.value === "n" && !xref.has(first + i)) xref.set(first + i, {
+				kind: "uncompressed",
+				offset: off.value
+			});
+		}
+	}
+	const trailerVal = parseObject(lexer);
+	return {
+		xref,
+		trailer: trailerVal instanceof Map ? trailerVal : /* @__PURE__ */ new Map()
+	};
+}
+function readXrefStream(stream) {
+	const dict = stream.dict;
+	const wv = dict.get("W");
+	if (!Array.isArray(wv) || wv.length < 3) return void 0;
+	const w0 = numOf(wv[0]);
+	const w1 = numOf(wv[1]);
+	const w2 = numOf(wv[2]);
+	const rowLen = w0 + w1 + w2;
+	if (rowLen <= 0) return void 0;
+	const data = inflateStream(stream);
+	const size = numOf(dict.get("Size"));
+	const indexV = dict.get("Index");
+	const index = Array.isArray(indexV) ? indexV.map(numOf) : [0, size];
+	const xref = /* @__PURE__ */ new Map();
+	let pos = 0;
+	for (let s = 0; s + 1 < index.length; s += 2) {
+		const start = index[s];
+		const count = index[s + 1];
+		for (let i = 0; i < count && pos + rowLen <= data.length; i++) {
+			const type = w0 === 0 ? 1 : readBE(data, pos, w0);
+			const f2 = readBE(data, pos + w0, w1);
+			const f3 = readBE(data, pos + w0 + w1, w2);
+			pos += rowLen;
+			const id = start + i;
+			if (xref.has(id)) continue;
+			if (type === 1) xref.set(id, {
+				kind: "uncompressed",
+				offset: f2
+			});
+			else if (type === 2) xref.set(id, {
+				kind: "compressed",
+				streamObj: f2,
+				index: f3
+			});
+		}
+	}
+	return {
+		xref,
+		trailer: dict
+	};
+}
+function objStmHeader(data, n) {
+	const out = [];
+	const lexer = new Lexer(data, 0);
+	for (let i = 0; i < Math.min(n, MAX_OBJSTM_N); i++) {
+		const idTok = lexer.nextToken();
+		const offTok = lexer.nextToken();
+		if (idTok.kind !== "num" || offTok.kind !== "num") break;
+		out.push({
+			id: idTok.value,
+			off: offTok.value
+		});
+	}
+	return out;
+}
+function inflateStream(stream) {
+	let data = stream.data;
+	const filter = stream.dict.get("Filter") ?? PDF_NULL;
+	const filters = Array.isArray(filter) ? filter : [filter];
+	for (const f of filters) if (f instanceof PdfName && (f.value === "FlateDecode" || f.value === "Fl")) try {
+		data = unzlibSync(data);
+	} catch {
+		return new Uint8Array(0);
+	}
+	const parmsVal = stream.dict.get("DecodeParms") ?? stream.dict.get("DP");
+	const parms = parmsVal instanceof Map ? parmsVal : Array.isArray(parmsVal) ? parmsVal.find((p) => p instanceof Map) : void 0;
+	if (parms) {
+		const predictor = numOf(parms.get("Predictor"));
+		if (predictor >= 2) data = reversePredictor(data, {
+			predictor,
+			colors: numOf(parms.get("Colors")) || 1,
+			bitsPerComponent: numOf(parms.get("BitsPerComponent")) || 8,
+			columns: numOf(parms.get("Columns")) || 1
+		});
+	}
+	return data;
+}
+function applyStreamPredictor(file, dict, data) {
+	const parmsVal = file.get(dict, "DecodeParms");
+	const parms = parmsVal instanceof Map ? parmsVal : void 0;
+	if (!parms) return data;
+	const predictor = numOf(file.get(parms, "Predictor"));
+	if (predictor < 2) return data;
+	return reversePredictor(data, {
+		predictor,
+		colors: numOf(file.get(parms, "Colors")) || 1,
+		bitsPerComponent: numOf(file.get(parms, "BitsPerComponent")) || 8,
+		columns: numOf(file.get(parms, "Columns")) || 1
+	});
+}
+function bruteForceScan(buf) {
+	const xref = /* @__PURE__ */ new Map();
+	const objStmObjs = [];
+	let root;
+	const lexer = new Lexer(buf);
+	let prev2;
+	let prev1;
+	for (;;) {
+		lexer.skipWhitespace();
+		const start = lexer.pos;
+		const tok = lexer.nextToken();
+		if (tok.kind === "eof") break;
+		if (tok.kind === "keyword" && tok.value === "obj" && prev2 && prev1) {
+			xref.set(prev2.value, {
+				kind: "uncompressed",
+				offset: prev2.start
+			});
+			const value = parseIndirectObject(new Lexer(buf, prev2.start))?.value;
+			const dict = value instanceof PdfStream ? value.dict : value;
+			if (dict instanceof Map) {
+				const type = dict.get("Type");
+				if (type instanceof PdfName && type.value === "Catalog" && root === void 0) root = new PdfRef(prev2.value, prev1.value);
+				else if (type instanceof PdfName && type.value === "ObjStm") objStmObjs.push(prev2.value);
+			}
+		}
+		prev2 = prev1;
+		prev1 = tok.kind === "num" ? {
+			start,
+			value: tok.value
+		} : void 0;
+	}
+	for (const streamObj of objStmObjs) {
+		const entry = xref.get(streamObj);
+		if (!entry || entry.kind !== "uncompressed") continue;
+		const obj = parseIndirectObject(new Lexer(buf, entry.offset));
+		if (!obj || !(obj.value instanceof PdfStream)) continue;
+		const data = inflateStream(obj.value);
+		const first = numOf(obj.value.dict.get("First") ?? PDF_NULL);
+		objStmHeader(data, numOf(obj.value.dict.get("N") ?? PDF_NULL)).forEach((member, index) => {
+			if (!xref.has(member.id)) xref.set(member.id, {
+				kind: "compressed",
+				streamObj,
+				index
+			});
+			if (root === void 0) {
+				const v = parseObject(new Lexer(data, first + member.off));
+				if (v instanceof Map) {
+					const t = v.get("Type");
+					if (t instanceof PdfName && t.value === "Catalog") root = new PdfRef(member.id, 0);
+				}
+			}
+		});
+	}
+	return {
+		xref,
+		root
+	};
+}
+function readBE(data, offset, width) {
+	let v = 0;
+	for (let i = 0; i < width; i++) v = v * 256 + (data[offset + i] ?? 0);
+	return v;
+}
+function numOf(v) {
+	return typeof v === "number" ? v : 0;
+}
+function readRectangle(value) {
+	if (!Array.isArray(value) || value.length < 4) return void 0;
+	const nums = value.slice(0, 4).map((v) => typeof v === "number" ? v : NaN);
+	if (nums.some((n) => !Number.isFinite(n))) return void 0;
+	return [
+		nums[0],
+		nums[1],
+		nums[2],
+		nums[3]
+	];
+}
+function concatWithSpaces(parts) {
+	if (parts.length === 1) return parts[0];
+	const total = parts.reduce((n, p) => n + p.length + 1, 0);
+	const out = new Uint8Array(Math.max(0, total - 1));
+	let at = 0;
+	parts.forEach((p, i) => {
+		out.set(p, at);
+		at += p.length;
+		if (i < parts.length - 1) out[at++] = 10;
+	});
+	return out;
+}
+function lastIndexOfAscii(buf, needle) {
+	const n = needle.length;
+	outer: for (let i = buf.length - n; i >= 0; i--) {
+		for (let j = 0; j < n; j++) if (buf[i + j] !== needle.charCodeAt(j)) continue outer;
+		return i;
+	}
+	return -1;
+}
+//#endregion
+export { PdfFile };

package/dist/esm/pdf-reader/flow-build.d.ts

@@ -0,0 +1,19 @@
+import { BodyElement } from '../core/document-model/index.js';
+import { FlowDoc } from '../core/ir/flow.js';
+import { Loss, ResourceStore } from '../core/ir/index.js';
+import { PdfImage } from './images.js';
+import { PdfVector } from './vector.js';
+export interface Reconstruction {
+    readonly doc: FlowDoc;
+    readonly losses: ReadonlyArray<Loss>;
+}
+export declare function paragraphBlock(text: string, outlineLevel?: number): BodyElement;
+export interface TextSpan {
+    readonly text: string;
+    readonly href?: string;
+}
+export declare function paragraphFromRuns(spans: ReadonlyArray<TextSpan>, outlineLevel?: number): BodyElement;
+export declare function imageBlock(image: PdfImage, resources: ResourceStore, alt?: string): BodyElement;
+export declare function dedupeLosses(losses: ReadonlyArray<Loss>): Array<Loss>;
+export declare function shapeBlock(v: PdfVector): BodyElement;
+export declare function buildFlowDoc(body: ReadonlyArray<BodyElement>, resources?: ResourceStore): FlowDoc;