reamkit 1.6.0 → 1.7.0

package/dist/esm/pdf-reader/image-decode.d.ts

@@ -0,0 +1,15 @@
+import { PdfFile } from './document.js';
+import { PdfStream } from '../pdf/objects.js';
+export type DecodedImage = {
+    readonly ok: true;
+    readonly bytes: Uint8Array;
+    readonly format: 'png' | 'jpeg' | 'jpeg2000';
+    readonly widthPx: number;
+    readonly heightPx: number;
+    readonly degraded?: string;
+} | {
+    readonly ok: false;
+    readonly severity: 'dropped' | 'degraded';
+    readonly detail: string;
+};
+export declare function decodePdfImage(file: PdfFile, stream: PdfStream): DecodedImage;

package/dist/esm/pdf-reader/image-decode.js

@@ -0,0 +1,442 @@
+import { PDF_NULL, PdfHexString, PdfName, PdfStream } from "../pdf/objects.js";
+import { reversePredictor } from "./predictor.js";
+import { encodePng } from "./png-encode.js";
+import { unzlibSync } from "fflate";
+//#region src/pdf-reader/image-decode.ts
+var MAX_PIXELS = 4e7;
+function decodePdfImage(file, stream) {
+	const d = stream.dict;
+	const width = intOf(file.get(d, "Width")) || intOf(file.get(d, "W"));
+	const height = intOf(file.get(d, "Height")) || intOf(file.get(d, "H"));
+	if (width <= 0 || height <= 0) return fail("dropped", "image with no dimensions");
+	if (width * height > MAX_PIXELS) return fail("dropped", "image too large to decode");
+	if (boolOf(d.get("ImageMask")) || boolOf(d.get("IM"))) return fail("dropped", "stencil image mask not reconstructed");
+	const filters = filterNames(file, d);
+	const last = filters[filters.length - 1];
+	if (last === "DCTDecode" || last === "DCT") {
+		const degraded = hasSMask(file, d) ? "image transparency dropped (JPEG carries no alpha)" : void 0;
+		return {
+			ok: true,
+			bytes: applyChainExceptLast(filters, stream.data),
+			format: "jpeg",
+			widthPx: width,
+			heightPx: height,
+			...degraded ? { degraded } : {}
+		};
+	}
+	if (last === "JPXDecode") return {
+		ok: true,
+		bytes: applyChainExceptLast(filters, stream.data),
+		format: "jpeg2000",
+		widthPx: width,
+		heightPx: height,
+		degraded: "JPEG 2000 image — limited viewer support"
+	};
+	if (last === "CCITTFaxDecode" || last === "CCF" || last === "JBIG2Decode") return fail("dropped", "fax-encoded (CCITT/JBIG2) image not decoded");
+	if (last === "LZWDecode" || last === "LZW") return fail("dropped", "LZW-encoded image not decoded");
+	const decoded = decodeToSamples(file, stream, filters, width, height);
+	if (typeof decoded === "string") return fail("dropped", decoded);
+	const alpha = decodeSMask(file, d, width, height);
+	const { color, samples } = alpha ? combineAlpha(decoded, alpha) : decoded;
+	return {
+		ok: true,
+		bytes: encodePng(width, height, color, samples),
+		format: "png",
+		widthPx: width,
+		heightPx: height
+	};
+}
+function decodeToSamples(file, stream, filters, width, height) {
+	const d = stream.dict;
+	const raw = decodeChain(file, stream, filters);
+	if (!raw) return "undecodable image stream";
+	const cs = resolveColorSpace(file, d.get("ColorSpace") ?? d.get("CS"));
+	if (!cs) return "unsupported image colour space";
+	const bpc = intOf(file.get(d, "BitsPerComponent")) || intOf(file.get(d, "BPC")) || 8;
+	const decodeArr = decodeArrayOf(file, d);
+	return toColor(cs, unpackSamples(raw, width, height, cs.components, bpc), width * height, bpc, decodeArr);
+}
+function resolveColorSpace(file, csVal) {
+	const cs = file.resolve(csVal ?? PDF_NULL);
+	if (cs instanceof PdfName) return namedColorSpace(cs.value);
+	if (!Array.isArray(cs) || cs.length === 0) return void 0;
+	const head = file.resolve(cs[0]);
+	const tag = head instanceof PdfName ? head.value : "";
+	if (tag === "ICCBased") {
+		const profile = file.resolve(cs[1]);
+		if (profile instanceof PdfStream) {
+			const n = intOf(file.get(profile.dict, "N"));
+			if (n === 1) return {
+				kind: "gray",
+				components: 1
+			};
+			if (n === 3) return {
+				kind: "rgb",
+				components: 3
+			};
+			if (n === 4) return {
+				kind: "cmyk",
+				components: 4
+			};
+			const alt = resolveColorSpace(file, profile.dict.get("Alternate"));
+			if (alt) return alt;
+		}
+		return;
+	}
+	if (tag === "CalGray" || tag === "G") return {
+		kind: "gray",
+		components: 1
+	};
+	if (tag === "CalRGB" || tag === "RGB") return {
+		kind: "rgb",
+		components: 3
+	};
+	if (tag === "Indexed" || tag === "I") {
+		const base = resolveColorSpace(file, cs[1]);
+		const hival = intOf(file.resolve(cs[2] ?? PDF_NULL));
+		const lookup = valueToBytes(file, cs[3]);
+		if (!base || base.kind === "indexed" || !lookup) return void 0;
+		return {
+			kind: "indexed",
+			components: 1,
+			base,
+			hival,
+			lookup
+		};
+	}
+}
+function namedColorSpace(name) {
+	if (name === "DeviceGray" || name === "G" || name === "CalGray") return {
+		kind: "gray",
+		components: 1
+	};
+	if (name === "DeviceRGB" || name === "RGB" || name === "CalRGB") return {
+		kind: "rgb",
+		components: 3
+	};
+	if (name === "DeviceCMYK" || name === "CMYK") return {
+		kind: "cmyk",
+		components: 4
+	};
+}
+function toColor(cs, s, px, bpc, decode) {
+	const maxv = (1 << Math.min(bpc, 15)) * (bpc >= 16 ? 2 : 1) - 1;
+	const c01 = (v, comp) => {
+		const t = maxv > 0 ? v / maxv : 0;
+		if (decode && decode.length >= (comp + 1) * 2) {
+			const dmin = decode[comp * 2];
+			const dmax = decode[comp * 2 + 1];
+			return clamp01(dmin + t * (dmax - dmin));
+		}
+		return t;
+	};
+	const to8 = (v, comp) => Math.round(c01(v, comp) * 255);
+	if (cs.kind === "gray") {
+		const out = new Uint8Array(px);
+		for (let i = 0; i < px; i++) out[i] = to8(s[i], 0);
+		return {
+			color: "gray",
+			samples: out
+		};
+	}
+	if (cs.kind === "rgb") {
+		const out = new Uint8Array(px * 3);
+		for (let i = 0; i < px; i++) {
+			out[i * 3] = to8(s[i * 3], 0);
+			out[i * 3 + 1] = to8(s[i * 3 + 1], 1);
+			out[i * 3 + 2] = to8(s[i * 3 + 2], 2);
+		}
+		return {
+			color: "rgb",
+			samples: out
+		};
+	}
+	if (cs.kind === "cmyk") {
+		const out = new Uint8Array(px * 3);
+		for (let i = 0; i < px; i++) {
+			const c = c01(s[i * 4], 0);
+			const m = c01(s[i * 4 + 1], 1);
+			const y = c01(s[i * 4 + 2], 2);
+			const k = c01(s[i * 4 + 3], 3);
+			out[i * 3] = Math.round(255 * (1 - c) * (1 - k));
+			out[i * 3 + 1] = Math.round(255 * (1 - m) * (1 - k));
+			out[i * 3 + 2] = Math.round(255 * (1 - y) * (1 - k));
+		}
+		return {
+			color: "rgb",
+			samples: out
+		};
+	}
+	const base = cs.base;
+	const lookup = cs.lookup;
+	const hival = cs.hival ?? 255;
+	const bn = base.components;
+	if (base.kind === "gray") {
+		const out = new Uint8Array(px);
+		for (let i = 0; i < px; i++) out[i] = lookup[Math.min(s[i], hival) * bn] ?? 0;
+		return {
+			color: "gray",
+			samples: out
+		};
+	}
+	const out = new Uint8Array(px * 3);
+	for (let i = 0; i < px; i++) {
+		const [r, g, b] = paletteRgb(base, lookup, Math.min(s[i], hival) * bn);
+		out[i * 3] = r;
+		out[i * 3 + 1] = g;
+		out[i * 3 + 2] = b;
+	}
+	return {
+		color: "rgb",
+		samples: out
+	};
+}
+function paletteRgb(base, lookup, off) {
+	if (base.kind === "rgb") return [
+		lookup[off] ?? 0,
+		lookup[off + 1] ?? 0,
+		lookup[off + 2] ?? 0
+	];
+	if (base.kind === "cmyk") {
+		const c = (lookup[off] ?? 0) / 255;
+		const m = (lookup[off + 1] ?? 0) / 255;
+		const y = (lookup[off + 2] ?? 0) / 255;
+		const k = (lookup[off + 3] ?? 0) / 255;
+		return [
+			Math.round(255 * (1 - c) * (1 - k)),
+			Math.round(255 * (1 - m) * (1 - k)),
+			Math.round(255 * (1 - y) * (1 - k))
+		];
+	}
+	const g = lookup[off] ?? 0;
+	return [
+		g,
+		g,
+		g
+	];
+}
+function unpackSamples(raw, width, height, ncomp, bpc) {
+	const perRow = width * ncomp;
+	const out = new Uint16Array(perRow * height);
+	const rowBytes = Math.ceil(perRow * bpc / 8);
+	for (let y = 0; y < height; y++) {
+		const rowOff = y * rowBytes;
+		const base = y * perRow;
+		if (bpc === 8) for (let i = 0; i < perRow; i++) out[base + i] = raw[rowOff + i] ?? 0;
+		else if (bpc === 16) for (let i = 0; i < perRow; i++) out[base + i] = (raw[rowOff + 2 * i] ?? 0) << 8 | (raw[rowOff + 2 * i + 1] ?? 0);
+		else {
+			const mask = (1 << bpc) - 1;
+			let bit = 0;
+			for (let i = 0; i < perRow; i++) {
+				const bytePos = rowOff + (bit >> 3);
+				const shift = 8 - bpc - (bit & 7);
+				out[base + i] = ((raw[bytePos] ?? 0) >> shift & mask) >>> 0;
+				bit += bpc;
+			}
+		}
+	}
+	return out;
+}
+function decodeSMask(file, d, width, height) {
+	const sm = file.resolve(d.get("SMask") ?? PDF_NULL);
+	if (!(sm instanceof PdfStream)) return void 0;
+	const sw = intOf(file.get(sm.dict, "Width"));
+	const sh = intOf(file.get(sm.dict, "Height"));
+	if (sw <= 0 || sh <= 0) return void 0;
+	const decoded = decodeToSamples(file, sm, filterNames(file, sm.dict), sw, sh);
+	if (typeof decoded === "string") return void 0;
+	const ch = decoded.color === "rgb" ? 3 : 1;
+	const gray = new Uint8Array(sw * sh);
+	for (let i = 0; i < sw * sh; i++) gray[i] = decoded.samples[i * ch];
+	if (sw === width && sh === height) return { data: gray };
+	const out = new Uint8Array(width * height);
+	for (let y = 0; y < height; y++) {
+		const sy = Math.min(sh - 1, Math.floor(y * sh / height));
+		for (let x = 0; x < width; x++) {
+			const sx = Math.min(sw - 1, Math.floor(x * sw / width));
+			out[y * width + x] = gray[sy * sw + sx];
+		}
+	}
+	return { data: out };
+}
+function combineAlpha(color, alpha) {
+	const px = alpha.data.length;
+	if (color.color === "gray") {
+		const out = new Uint8Array(px * 2);
+		for (let i = 0; i < px; i++) {
+			out[i * 2] = color.samples[i];
+			out[i * 2 + 1] = alpha.data[i];
+		}
+		return {
+			color: "gray-alpha",
+			samples: out
+		};
+	}
+	const out = new Uint8Array(px * 4);
+	for (let i = 0; i < px; i++) {
+		out[i * 4] = color.samples[i * 3];
+		out[i * 4 + 1] = color.samples[i * 3 + 1];
+		out[i * 4 + 2] = color.samples[i * 3 + 2];
+		out[i * 4 + 3] = alpha.data[i];
+	}
+	return {
+		color: "rgba",
+		samples: out
+	};
+}
+function filterNames(file, d) {
+	const f = file.resolve(d.get("Filter") ?? PDF_NULL);
+	const arr = Array.isArray(f) ? f : [f];
+	const out = [];
+	for (const x of arr) {
+		const r = file.resolve(x);
+		if (r instanceof PdfName) out.push(r.value);
+	}
+	return out;
+}
+function decodeChain(file, stream, filters) {
+	let data = stream.data;
+	let flate = false;
+	for (const f of filters) if (f === "FlateDecode" || f === "Fl") try {
+		data = unzlibSync(data);
+		flate = true;
+	} catch {
+		return;
+	}
+	else if (f === "RunLengthDecode" || f === "RL") data = runLengthDecode(data);
+	else if (f === "ASCII85Decode" || f === "A85") data = ascii85Decode(data);
+	else if (f === "ASCIIHexDecode" || f === "AHx") data = asciiHexDecode(data);
+	else return;
+	return flate ? applyPredictor(file, stream.dict, data) : data;
+}
+function applyChainExceptLast(filters, raw) {
+	let data = raw;
+	for (let i = 0; i < filters.length - 1; i++) {
+		const f = filters[i];
+		if (f === "FlateDecode" || f === "Fl") try {
+			data = unzlibSync(data);
+		} catch {}
+		else if (f === "RunLengthDecode" || f === "RL") data = runLengthDecode(data);
+		else if (f === "ASCII85Decode" || f === "A85") data = ascii85Decode(data);
+		else if (f === "ASCIIHexDecode" || f === "AHx") data = asciiHexDecode(data);
+	}
+	return data;
+}
+function applyPredictor(file, d, data) {
+	const parms = decodeParmsOf(file, d);
+	if (!parms) return data;
+	const predictor = intOf(file.get(parms, "Predictor"));
+	if (predictor < 2) return data;
+	return reversePredictor(data, {
+		predictor,
+		colors: intOf(file.get(parms, "Colors")) || 1,
+		bitsPerComponent: intOf(file.get(parms, "BitsPerComponent")) || 8,
+		columns: intOf(file.get(parms, "Columns")) || 1
+	});
+}
+function runLengthDecode(data) {
+	const out = [];
+	let i = 0;
+	while (i < data.length) {
+		const len = data[i++];
+		if (len === 128) break;
+		if (len < 128) for (let j = 0; j <= len && i < data.length; j++) out.push(data[i++]);
+		else {
+			const b = data[i++] ?? 0;
+			for (let j = 0; j < 257 - len; j++) out.push(b);
+		}
+	}
+	return Uint8Array.from(out);
+}
+function ascii85Decode(data) {
+	const out = [];
+	let tuple = 0;
+	let count = 0;
+	for (const c of data) {
+		if (c === 126) break;
+		if (c <= 32) continue;
+		if (c === 122 && count === 0) {
+			out.push(0, 0, 0, 0);
+			continue;
+		}
+		if (c < 33 || c > 117) continue;
+		tuple = tuple * 85 + (c - 33);
+		if (++count === 5) {
+			out.push(tuple >>> 24 & 255, tuple >>> 16 & 255, tuple >>> 8 & 255, tuple & 255);
+			tuple = 0;
+			count = 0;
+		}
+	}
+	if (count > 0) {
+		for (let i = count; i < 5; i++) tuple = tuple * 85 + 84;
+		for (let i = 0; i < count - 1; i++) out.push(tuple >>> 24 - i * 8 & 255);
+	}
+	return Uint8Array.from(out);
+}
+function asciiHexDecode(data) {
+	const out = [];
+	let hi = -1;
+	for (const c of data) {
+		if (c === 62) break;
+		const v = hexVal(c);
+		if (v < 0) continue;
+		if (hi < 0) hi = v;
+		else {
+			out.push(hi << 4 | v);
+			hi = -1;
+		}
+	}
+	if (hi >= 0) out.push(hi << 4);
+	return Uint8Array.from(out);
+}
+function decodeParmsOf(file, d) {
+	const p = file.resolve(d.get("DecodeParms") ?? d.get("DP") ?? PDF_NULL);
+	if (p instanceof Map) return p;
+	if (Array.isArray(p)) for (const e of p) {
+		const r = file.resolve(e);
+		if (r instanceof Map) return r;
+	}
+}
+function decodeArrayOf(file, d) {
+	const v = file.resolve(d.get("Decode") ?? d.get("D") ?? PDF_NULL);
+	if (!Array.isArray(v)) return void 0;
+	const nums = v.map((x) => typeof x === "number" ? x : NaN);
+	return nums.some((n) => !Number.isFinite(n)) ? void 0 : nums;
+}
+function hasSMask(file, d) {
+	return file.resolve(d.get("SMask") ?? PDF_NULL) instanceof PdfStream;
+}
+function valueToBytes(file, v) {
+	const r = file.resolve(v ?? PDF_NULL);
+	if (r instanceof PdfHexString) return r.bytes;
+	if (typeof r === "string") {
+		const out = new Uint8Array(r.length);
+		for (let i = 0; i < r.length; i++) out[i] = r.charCodeAt(i) & 255;
+		return out;
+	}
+	if (r instanceof PdfStream) return file.streamData(r);
+}
+function intOf(v) {
+	return typeof v === "number" ? Math.round(v) : 0;
+}
+function boolOf(v) {
+	return v === true;
+}
+function clamp01(x) {
+	return x < 0 ? 0 : x > 1 ? 1 : x;
+}
+function hexVal(c) {
+	if (c >= 48 && c <= 57) return c - 48;
+	if (c >= 65 && c <= 70) return c - 65 + 10;
+	if (c >= 97 && c <= 102) return c - 97 + 10;
+	return -1;
+}
+function fail(severity, detail) {
+	return {
+		ok: false,
+		severity,
+		detail
+	};
+}
+//#endregion
+export { decodePdfImage };

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

@@ -0,0 +1,16 @@
+import { Loss } from '../core/ir/index.js';
+import { PdfFile, PdfPage } from './document.js';
+export interface PdfImage {
+    readonly bytes: Uint8Array;
+    readonly format: 'png' | 'jpeg' | 'jpeg2000';
+    readonly widthPt: number;
+    readonly heightPt: number;
+    readonly x: number;
+    readonly y: number;
+    readonly mcid?: number;
+}
+export interface PageImages {
+    readonly images: Array<PdfImage>;
+    readonly losses: Array<Loss>;
+}
+export declare function collectPageImages(file: PdfFile, page: PdfPage): PageImages;

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

@@ -0,0 +1,90 @@
+import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { FEATURES } from "../core/ir/features.js";
+import { interpretContent, multiply } from "./content.js";
+import { decodePdfImage } from "./image-decode.js";
+//#region src/pdf-reader/images.ts
+var NO_FONTS = /* @__PURE__ */ new Map();
+var MAX_FORM_DEPTH = 12;
+var MAX_IMAGES = 4096;
+function collectPageImages(file, page) {
+	const images = [];
+	const lossByDetail = /* @__PURE__ */ new Map();
+	const visiting = /* @__PURE__ */ new Set();
+	const addLoss = (severity, detail) => {
+		if (!lossByDetail.has(detail)) lossByDetail.set(detail, {
+			severity,
+			feature: FEATURES.images,
+			detail
+		});
+	};
+	const walk = (resources, content, baseCtm, depth, inheritedMcid) => {
+		const xobjects = resources ? file.get(resources, "XObject") : PDF_NULL;
+		const xobjDict = xobjects instanceof Map ? xobjects : void 0;
+		for (const placement of interpretContent(content, NO_FONTS, baseCtm).images) {
+			if (images.length >= MAX_IMAGES) return;
+			const stream = xobjDict ? file.resolve(xobjDict.get(placement.name) ?? PDF_NULL) : PDF_NULL;
+			if (!(stream instanceof PdfStream)) continue;
+			const subtype = nameOf(file.get(stream.dict, "Subtype"));
+			const mcid = placement.mcid ?? inheritedMcid;
+			if (subtype === "Image") {
+				const decoded = decodePdfImage(file, stream);
+				if (decoded.ok) {
+					images.push(geometry(placement.ctm, decoded, mcid));
+					if (decoded.degraded) addLoss("degraded", decoded.degraded);
+				} else addLoss(decoded.severity, decoded.detail);
+			} else if (subtype === "Form" && depth < MAX_FORM_DEPTH && !visiting.has(stream)) {
+				visiting.add(stream);
+				const formRes = file.get(stream.dict, "Resources");
+				walk(formRes instanceof Map ? formRes : resources, file.streamData(stream), multiply(matrixOf(file, stream.dict), placement.ctm), depth + 1, mcid);
+				visiting.delete(stream);
+			}
+		}
+	};
+	walk(page.resources, file.pageContent(page), [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	], 0, void 0);
+	return {
+		images,
+		losses: [...lossByDetail.values()]
+	};
+}
+function geometry(ctm, decoded, mcid) {
+	return {
+		bytes: decoded.bytes,
+		format: decoded.format,
+		widthPt: Math.hypot(ctm[0], ctm[1]) || 1,
+		heightPt: Math.hypot(ctm[2], ctm[3]) || 1,
+		x: ctm[4],
+		y: ctm[5],
+		...mcid !== void 0 ? { mcid } : {}
+	};
+}
+function matrixOf(file, dict) {
+	const m = file.resolve(dict.get("Matrix") ?? PDF_NULL);
+	if (Array.isArray(m) && m.length >= 6 && m.every((v) => typeof v === "number")) return [
+		m[0],
+		m[1],
+		m[2],
+		m[3],
+		m[4],
+		m[5]
+	];
+	return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+}
+function nameOf(v) {
+	return v instanceof PdfName ? v.value : "";
+}
+//#endregion
+export { collectPageImages };

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

@@ -1,3 +1,3 @@
-import { FlowDoc } from '../core/ir/flow.js';
 import { PdfFile } from './document.js';
-export declare function reconstructByLayout(file: PdfFile): FlowDoc;
+import { Reconstruction } from './flow-build.js';
+export declare function reconstructByLayout(file: PdfFile): Reconstruction;

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

@@ -1,12 +1,39 @@
-import { buildFlowDoc, paragraphBlock } from "./flow-build.js";
+import { ResourceStore } from "../core/ir/resources.js";
+import { buildFlowDoc, dedupeLosses, imageBlock, paragraphFromRuns, shapeBlock } from "./flow-build.js";
+import { collectPageImages } from "./images.js";
 import { extractPageText } from "./text.js";
+import { collectPageVectors } from "./vector.js";
 //#region src/pdf-reader/layout.ts
 function reconstructByLayout(file) {
-	const pages = file.pages().map((page) => groupIntoLines(extractPageText(file, page)).filter((l) => l.text.length > 0));
-	const medianFont = median(pages.flat().map((l) => l.fontSize)) || 12;
+	const pages = file.pages();
+	const pageLines = pages.map((page) => groupIntoLines(extractPageText(file, page)).filter((l) => l.text.length > 0));
+	const medianFont = median(pageLines.flat().map((l) => l.fontSize)) || 12;
+	const resources = new ResourceStore();
+	const losses = [];
 	const body = [];
-	for (const lines of pages) for (const para of groupIntoParagraphs(lines)) body.push(paragraphBlock(para.text, headingLevel(para.fontSize, medianFont)));
-	return buildFlowDoc(body);
+	pages.forEach((page, i) => {
+		const blocks = [];
+		for (const para of groupIntoParagraphs(pageLines[i])) blocks.push({
+			top: para.top,
+			el: paragraphFromRuns(para.spans, headingLevel(para.fontSize, medianFont))
+		});
+		const imgs = collectPageImages(file, page);
+		losses.push(...imgs.losses);
+		for (const img of imgs.images) blocks.push({
+			top: img.y + img.heightPt,
+			el: imageBlock(img, resources)
+		});
+		for (const v of collectPageVectors(file, page)) blocks.push({
+			top: v.maxY,
+			el: shapeBlock(v)
+		});
+		blocks.sort((a, b) => b.top - a.top);
+		for (const block of blocks) body.push(block.el);
+	});
+	return {
+		doc: buildFlowDoc(body, resources),
+		losses: dedupeLosses(losses)
+	};
 }
 function groupIntoLines(runs) {
 	const sorted = [...runs].sort((a, b) => b.y - a.y || a.x - b.x);
@@ -25,22 +52,28 @@ function groupIntoLines(runs) {
 	}
 	return clusters.map((c) => {
 		const ordered = c.runs.sort((a, b) => a.x - b.x);
+		const fontSize = c.fontSize || 10;
+		const spans = lineSpans(ordered, fontSize);
 		return {
 			y: c.y,
-			fontSize: c.fontSize || 10,
-			text: joinLine(ordered, c.fontSize || 10)
+			fontSize,
+			text: spans.map((s) => s.text).join("").replace(/\s+/g, " ").trim(),
+			spans
 		};
 	});
 }
-function joinLine(runs, fontSize) {
-	let text = "";
+function lineSpans(runs, fontSize) {
+	const spans = [];
 	let prevEnd;
 	for (const run of runs) {
-		if (prevEnd !== void 0 && run.x - prevEnd > fontSize * .25) text += " ";
-		text += run.text;
+		if (prevEnd !== void 0 && run.x - prevEnd > fontSize * .25) spans.push({ text: " " });
+		spans.push(run.href !== void 0 ? {
+			text: run.text,
+			href: run.href
+		} : { text: run.text });
 		prevEnd = run.x + run.text.length * (run.fontSizePt || fontSize) * .5;
 	}
-	return text.replace(/\s+/g, " ").trim();
+	return spans;
 }
 function groupIntoParagraphs(lines) {
 	const groups = [];
@@ -52,8 +85,9 @@ function groupIntoParagraphs(lines) {
 		prevY = line.y;
 	}
 	return groups.map((g) => ({
-		text: g.map((l) => l.text).join(" ").replace(/\s+/g, " ").trim(),
-		fontSize: Math.max(...g.map((l) => l.fontSize))
+		spans: g.flatMap((l, i) => i > 0 ? [{ text: " " }, ...l.spans] : [...l.spans]),
+		fontSize: Math.max(...g.map((l) => l.fontSize)),
+		top: g[0].y
 	}));
 }
 function headingLevel(fontSize, medianFont) {

package/dist/esm/pdf-reader/png-encode.d.ts

@@ -0,0 +1,2 @@
+export type PngColor = 'gray' | 'rgb' | 'gray-alpha' | 'rgba';
+export declare function encodePng(width: number, height: number, color: PngColor, samples: Uint8Array): Uint8Array;