reamkit 1.6.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

@@ -10,11 +10,18 @@ export declare class PdfFile {
     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;

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

@@ -1,6 +1,8 @@
 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 = [
@@ -10,8 +12,12 @@ var DEFAULT_MEDIA_BOX = [
 	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;
@@ -30,29 +36,66 @@ var PdfFile = class PdfFile {
 		} catch {}
 		if (xref.size === 0 || !(trailer.get("Root") instanceof PdfRef)) {
 			const scanned = bruteForceScan(bytes);
-			for (const [id, off] of scanned.xref) if (!xref.has(id)) xref.set(id, off);
+			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);
 			}
 		}
-		return new PdfFile(bytes, xref, trailer);
+		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 offset = this.xref.get(value.id);
-		if (offset === void 0 || offset < 0 || offset >= this.buf.length) return PDF_NULL;
+		const entry = this.xref.get(value.id);
+		if (entry === void 0) return PDF_NULL;
 		this.cache.set(value.id, PDF_NULL);
-		const obj = parseIndirectObject(new Lexer(this.buf, offset), (r) => {
-			const n = this.resolve(r);
-			return typeof n === "number" ? n : void 0;
-		});
-		const result = obj ? obj.value : 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);
 	}
@@ -60,6 +103,9 @@ var PdfFile = class PdfFile {
 		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");
@@ -105,10 +151,12 @@ var PdfFile = class PdfFile {
 		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 data;
+		return flate ? applyStreamPredictor(this, stream.dict, data) : data;
 	}
 };
 function findStartXref(buf) {
@@ -121,25 +169,33 @@ function readXrefChain(buf, offset) {
 	const xref = /* @__PURE__ */ new Map();
 	let trailer = /* @__PURE__ */ new Map();
 	const visited = /* @__PURE__ */ new Set();
-	let at = offset;
-	while (at !== void 0 && at >= 0 && at < buf.length && !visited.has(at)) {
+	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 = readXrefSection(buf, at);
-		if (!section) break;
-		for (const [id, off] of section.xref) if (!xref.has(id)) xref.set(id, off);
+		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");
-		at = typeof prev === "number" ? prev : void 0;
+		if (typeof prev === "number") queue.push(prev);
 	}
 	return {
 		xref,
 		trailer
 	};
 }
-function readXrefSection(buf, offset) {
+function readXrefAt(buf, offset) {
 	const lexer = new Lexer(buf, offset);
 	const head = lexer.nextToken();
-	if (!(head.kind === "keyword" && head.value === "xref")) return void 0;
+	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();
@@ -154,7 +210,10 @@ function readXrefSection(buf, offset) {
 			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, off.value);
+			if (type.value === "n" && !xref.has(first + i)) xref.set(first + i, {
+				kind: "uncompressed",
+				offset: off.value
+			});
 		}
 	}
 	const trailerVal = parseObject(lexer);
@@ -163,8 +222,99 @@ function readXrefSection(buf, offset) {
 		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;
@@ -175,13 +325,16 @@ function bruteForceScan(buf) {
 		const tok = lexer.nextToken();
 		if (tok.kind === "eof") break;
 		if (tok.kind === "keyword" && tok.value === "obj" && prev2 && prev1) {
-			xref.set(prev2.value, prev2.start);
-			if (root === void 0) {
-				const dict = parseIndirectObject(new Lexer(buf, prev2.start))?.value;
-				if (dict instanceof Map) {
-					const type = dict.get("Type");
-					if (type instanceof PdfName && type.value === "Catalog") root = new PdfRef(prev2.value, prev1.value);
-				}
+			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;
@@ -190,11 +343,41 @@ function bruteForceScan(buf) {
 			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);

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

@@ -1,4 +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 declare function buildFlowDoc(body: ReadonlyArray<BodyElement>): FlowDoc;
+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;

package/dist/esm/pdf-reader/flow-build.js

@@ -1,3 +1,4 @@
+import { pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
 import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
 import "../core/style-cascade/index.js";
@@ -14,14 +15,112 @@ function paragraphBlock(text, outlineLevel) {
 		}
 	};
 }
-function buildFlowDoc(body) {
+function paragraphFromRuns(spans, outlineLevel) {
+	const merged = [];
+	for (const s of spans) {
+		const last = merged[merged.length - 1];
+		if (last && last.href === s.href) last.text += s.text;
+		else if (s.href !== void 0) merged.push({
+			text: s.text,
+			href: s.href
+		});
+		else merged.push({ text: s.text });
+	}
+	const runs = merged.map((m) => ({
+		text: m.text.replace(/\s+/g, " "),
+		href: m.href
+	})).filter((m) => m.text.length > 0);
+	if (runs.length > 0) {
+		runs[0].text = runs[0].text.replace(/^ /, "");
+		runs[runs.length - 1].text = runs[runs.length - 1].text.replace(/ $/, "");
+	}
+	return {
+		kind: "paragraph",
+		paragraph: {
+			properties: outlineLevel !== void 0 ? { outlineLevel } : {},
+			runs: runs.filter((r) => r.text.length > 0).map((r) => ({
+				text: r.text,
+				properties: {},
+				...r.href ? { href: r.href } : {}
+			}))
+		}
+	};
+}
+function imageBlock(image, resources, alt) {
+	return {
+		kind: "image",
+		image: {
+			resource: resources.put(image.bytes),
+			width: pt(image.widthPt),
+			height: pt(image.heightPt),
+			paragraphProperties: {},
+			...alt ? { altText: alt } : {}
+		}
+	};
+}
+function dedupeLosses(losses) {
+	const byDetail = /* @__PURE__ */ new Map();
+	for (const loss of losses) if (!byDetail.has(loss.detail)) byDetail.set(loss.detail, loss);
+	return [...byDetail.values()];
+}
+function shapeBlock(v) {
+	const w = v.maxX - v.minX;
+	const h = v.maxY - v.minY;
+	const fx = (x) => x - v.minX;
+	const fy = (y) => v.maxY - y;
+	const commands = v.segs.map((s) => {
+		switch (s.op) {
+			case "move": return {
+				cmd: "move",
+				x: fx(s.x),
+				y: fy(s.y)
+			};
+			case "line": return {
+				cmd: "line",
+				x: fx(s.x),
+				y: fy(s.y)
+			};
+			case "cubic": return {
+				cmd: "cubic",
+				x1: fx(s.x1),
+				y1: fy(s.y1),
+				x2: fx(s.x2),
+				y2: fy(s.y2),
+				x: fx(s.x),
+				y: fy(s.y)
+			};
+			case "close": return { cmd: "close" };
+		}
+	});
+	return {
+		kind: "shape",
+		shape: {
+			width: pt(w),
+			height: pt(h),
+			geometry: {
+				kind: "custom",
+				custom: {
+					pathWidth: w,
+					pathHeight: h,
+					commands
+				}
+			},
+			fill: {
+				kind: "solid",
+				colorHex: v.fillHex
+			},
+			paragraphProperties: {}
+		}
+	};
+}
+function buildFlowDoc(body, resources = new ResourceStore()) {
 	return {
 		kind: "flow",
 		body: resolveBodyStyles([...body], EMPTY_STYLE_SHEET),
 		sections: [],
 		styles: EMPTY_STYLE_SHEET,
-		resources: new ResourceStore()
+		resources
 	};
 }
 //#endregion
-export { buildFlowDoc, paragraphBlock };
+export { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, shapeBlock };