reamkit 1.5.0 → 1.6.0

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

@@ -0,0 +1,69 @@
+import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { parseToUnicodeCMap } from "./cmap.js";
+//#region src/pdf-reader/font.ts
+function buildContentFont(file, fontDict) {
+	const isType0 = asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) === "Type0";
+	let toUnicode = /* @__PURE__ */ new Map();
+	let codeBytes = isType0 ? 2 : 1;
+	const tu = file.resolve(fontDict.get("ToUnicode") ?? PDF_NULL);
+	if (tu instanceof PdfStream) {
+		const parsed = parseToUnicodeCMap(file.streamData(tu));
+		toUnicode = parsed.map;
+		codeBytes = parsed.codeBytes;
+	}
+	const width = isType0 ? cidWidths(file, fontDict) : simpleWidths(file, fontDict);
+	const bytesPerCode = codeBytes;
+	return {
+		bytesPerCode,
+		decode: (codes) => codes.map((c) => toUnicode.get(c) ?? (bytesPerCode === 1 ? String.fromCharCode(c) : "")).join(""),
+		width
+	};
+}
+function simpleWidths(file, fontDict) {
+	const first = asNumber(file.resolve(fontDict.get("FirstChar") ?? PDF_NULL), 0);
+	const widthsVal = file.resolve(fontDict.get("Widths") ?? PDF_NULL);
+	const widths = Array.isArray(widthsVal) ? widthsVal : [];
+	const descriptor = file.resolve(fontDict.get("FontDescriptor") ?? PDF_NULL);
+	const missing = descriptor instanceof Map ? asNumber(file.resolve(descriptor.get("MissingWidth") ?? PDF_NULL), 0) : 0;
+	return (code) => {
+		const w = widths[code - first];
+		return typeof w === "number" ? w : missing > 0 ? missing : 500;
+	};
+}
+function cidWidths(file, fontDict) {
+	const descFonts = file.resolve(fontDict.get("DescendantFonts") ?? PDF_NULL);
+	const desc0 = Array.isArray(descFonts) ? file.resolve(descFonts[0] ?? PDF_NULL) : PDF_NULL;
+	const cidFont = desc0 instanceof Map ? desc0 : /* @__PURE__ */ new Map();
+	const dw = asNumber(file.resolve(cidFont.get("DW") ?? PDF_NULL), 1e3);
+	const wMap = parseCidW(file, file.resolve(cidFont.get("W") ?? PDF_NULL));
+	return (cid) => wMap.get(cid) ?? (dw || 1e3);
+}
+function parseCidW(file, wVal) {
+	const out = /* @__PURE__ */ new Map();
+	if (!Array.isArray(wVal)) return out;
+	let i = 0;
+	while (i < wVal.length) {
+		const c = file.resolve(wVal[i++]);
+		if (typeof c !== "number") break;
+		const next = file.resolve(wVal[i] ?? PDF_NULL);
+		if (Array.isArray(next)) {
+			i++;
+			next.forEach((w, k) => {
+				if (typeof w === "number") out.set(c + k, w);
+			});
+		} else if (typeof next === "number") {
+			i++;
+			const w = file.resolve(wVal[i++] ?? PDF_NULL);
+			if (typeof w === "number") for (let cc = c; cc <= next && cc - c < 65536; cc++) out.set(cc, w);
+		} else break;
+	}
+	return out;
+}
+function asName(v) {
+	return v instanceof PdfName ? v.value : "";
+}
+function asNumber(v, dflt) {
+	return typeof v === "number" ? v : dflt;
+}
+//#endregion
+export { buildContentFont };

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

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

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

@@ -0,0 +1,69 @@
+import { buildFlowDoc, paragraphBlock } from "./flow-build.js";
+import { extractPageText } from "./text.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 body = [];
+	for (const lines of pages) for (const para of groupIntoParagraphs(lines)) body.push(paragraphBlock(para.text, headingLevel(para.fontSize, medianFont)));
+	return buildFlowDoc(body);
+}
+function groupIntoLines(runs) {
+	const sorted = [...runs].sort((a, b) => b.y - a.y || a.x - b.x);
+	const clusters = [];
+	for (const run of sorted) {
+		const last = clusters[clusters.length - 1];
+		const tol = Math.max(1, (run.fontSizePt || 10) * .5);
+		if (last && Math.abs(last.y - run.y) <= tol) {
+			last.runs.push(run);
+			last.fontSize = Math.max(last.fontSize, run.fontSizePt || 0);
+		} else clusters.push({
+			y: run.y,
+			fontSize: run.fontSizePt || 10,
+			runs: [run]
+		});
+	}
+	return clusters.map((c) => {
+		const ordered = c.runs.sort((a, b) => a.x - b.x);
+		return {
+			y: c.y,
+			fontSize: c.fontSize || 10,
+			text: joinLine(ordered, c.fontSize || 10)
+		};
+	});
+}
+function joinLine(runs, fontSize) {
+	let text = "";
+	let prevEnd;
+	for (const run of runs) {
+		if (prevEnd !== void 0 && run.x - prevEnd > fontSize * .25) text += " ";
+		text += run.text;
+		prevEnd = run.x + run.text.length * (run.fontSizePt || fontSize) * .5;
+	}
+	return text.replace(/\s+/g, " ").trim();
+}
+function groupIntoParagraphs(lines) {
+	const groups = [];
+	let prevY;
+	for (const line of lines) {
+		const gap = prevY !== void 0 ? prevY - line.y : 0;
+		if (groups.length === 0 || prevY !== void 0 && gap > line.fontSize * 1.5) groups.push([]);
+		groups[groups.length - 1].push(line);
+		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))
+	}));
+}
+function headingLevel(fontSize, medianFont) {
+	if (fontSize >= medianFont * 1.5) return 0;
+	if (fontSize >= medianFont * 1.25) return 1;
+}
+function median(values) {
+	if (values.length === 0) return 0;
+	const sorted = [...values].sort((a, b) => a - b);
+	return sorted[Math.floor(sorted.length / 2)];
+}
+//#endregion
+export { reconstructByLayout };

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

@@ -0,0 +1,43 @@
+export type Token = {
+    readonly kind: 'num';
+    readonly value: number;
+} | {
+    readonly kind: 'name';
+    readonly value: string;
+} | {
+    readonly kind: 'str';
+    readonly value: string;
+} | {
+    readonly kind: 'hexstr';
+    readonly bytes: Uint8Array;
+} | {
+    readonly kind: 'arrayOpen';
+} | {
+    readonly kind: 'arrayClose';
+} | {
+    readonly kind: 'dictOpen';
+} | {
+    readonly kind: 'dictClose';
+} | {
+    readonly kind: 'keyword';
+    readonly value: string;
+} | {
+    readonly kind: 'eof';
+};
+export declare class Lexer {
+    private readonly buf;
+    pos: number;
+    constructor(buf: Uint8Array, pos?: number);
+    get length(): number;
+    byteAt(i: number): number;
+    skipWhitespace(): void;
+    nextToken(): Token;
+    private readNumber;
+    private readName;
+    private readKeyword;
+    private readHexString;
+    private readLiteralString;
+    indexOfAscii(needle: string, from: number): number;
+    readStreamBody(length: number | undefined): Uint8Array;
+}
+export declare function latin1(bytes: Uint8Array): string;

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

@@ -0,0 +1,250 @@
+//#region src/pdf-reader/lexer.ts
+function isWhitespace(b) {
+	return b === 0 || b === 9 || b === 10 || b === 12 || b === 13 || b === 32;
+}
+function isDelimiter(b) {
+	return b === 40 || b === 41 || b === 60 || b === 62 || b === 91 || b === 93 || b === 123 || b === 125 || b === 47 || b === 37;
+}
+function isRegular(b) {
+	return !isWhitespace(b) && !isDelimiter(b);
+}
+function hexVal(b) {
+	if (b >= 48 && b <= 57) return b - 48;
+	if (b >= 65 && b <= 70) return b - 65 + 10;
+	if (b >= 97 && b <= 102) return b - 97 + 10;
+	return -1;
+}
+var Lexer = class {
+	pos;
+	constructor(buf, pos = 0) {
+		this.buf = buf;
+		this.pos = pos;
+	}
+	get length() {
+		return this.buf.length;
+	}
+	byteAt(i) {
+		return i >= 0 && i < this.buf.length ? this.buf[i] : -1;
+	}
+	skipWhitespace() {
+		const buf = this.buf;
+		while (this.pos < buf.length) {
+			const b = buf[this.pos];
+			if (isWhitespace(b)) this.pos++;
+			else if (b === 37) {
+				this.pos++;
+				while (this.pos < buf.length && buf[this.pos] !== 10 && buf[this.pos] !== 13) this.pos++;
+			} else break;
+		}
+	}
+	nextToken() {
+		this.skipWhitespace();
+		const buf = this.buf;
+		if (this.pos >= buf.length) return { kind: "eof" };
+		const b = buf[this.pos];
+		switch (b) {
+			case 91:
+				this.pos++;
+				return { kind: "arrayOpen" };
+			case 93:
+				this.pos++;
+				return { kind: "arrayClose" };
+			case 60:
+				if (buf[this.pos + 1] === 60) {
+					this.pos += 2;
+					return { kind: "dictOpen" };
+				}
+				return this.readHexString();
+			case 62:
+				if (buf[this.pos + 1] === 62) {
+					this.pos += 2;
+					return { kind: "dictClose" };
+				}
+				this.pos++;
+				return this.nextToken();
+			case 40: return this.readLiteralString();
+			case 47: return this.readName();
+			case 123:
+			case 125:
+				this.pos++;
+				return {
+					kind: "keyword",
+					value: String.fromCharCode(b)
+				};
+		}
+		if (b === 43 || b === 45 || b === 46 || b >= 48 && b <= 57) return this.readNumber();
+		if (isRegular(b)) return this.readKeyword();
+		this.pos++;
+		return this.nextToken();
+	}
+	readNumber() {
+		const buf = this.buf;
+		const start = this.pos;
+		if (buf[this.pos] === 43 || buf[this.pos] === 45) this.pos++;
+		while (this.pos < buf.length) {
+			const b = buf[this.pos];
+			if (b >= 48 && b <= 57 || b === 46) this.pos++;
+			else break;
+		}
+		const text = latin1(buf.subarray(start, this.pos));
+		const value = Number(text);
+		return {
+			kind: "num",
+			value: Number.isFinite(value) ? value : 0
+		};
+	}
+	readName() {
+		const buf = this.buf;
+		this.pos++;
+		const out = [];
+		while (this.pos < buf.length) {
+			const b = buf[this.pos];
+			if (!isRegular(b)) break;
+			if (b === 35 && this.pos + 2 < buf.length) {
+				const hi = hexVal(buf[this.pos + 1]);
+				const lo = hexVal(buf[this.pos + 2]);
+				if (hi >= 0 && lo >= 0) {
+					out.push(hi * 16 + lo);
+					this.pos += 3;
+					continue;
+				}
+			}
+			out.push(b);
+			this.pos++;
+		}
+		return {
+			kind: "name",
+			value: latin1(Uint8Array.from(out))
+		};
+	}
+	readKeyword() {
+		const buf = this.buf;
+		const start = this.pos;
+		while (this.pos < buf.length && isRegular(buf[this.pos])) this.pos++;
+		return {
+			kind: "keyword",
+			value: latin1(buf.subarray(start, this.pos))
+		};
+	}
+	readHexString() {
+		const buf = this.buf;
+		this.pos++;
+		const out = [];
+		let hi = -1;
+		while (this.pos < buf.length) {
+			const b = buf[this.pos];
+			this.pos++;
+			if (b === 62) break;
+			const v = hexVal(b);
+			if (v < 0) continue;
+			if (hi < 0) hi = v;
+			else {
+				out.push(hi * 16 + v);
+				hi = -1;
+			}
+		}
+		if (hi >= 0) out.push(hi * 16);
+		return {
+			kind: "hexstr",
+			bytes: Uint8Array.from(out)
+		};
+	}
+	readLiteralString() {
+		const buf = this.buf;
+		this.pos++;
+		const out = [];
+		let depth = 1;
+		while (this.pos < buf.length) {
+			const b = buf[this.pos];
+			this.pos++;
+			if (b === 92) {
+				if (this.pos >= buf.length) break;
+				const e = buf[this.pos];
+				this.pos++;
+				switch (e) {
+					case 110:
+						out.push(10);
+						break;
+					case 114:
+						out.push(13);
+						break;
+					case 116:
+						out.push(9);
+						break;
+					case 98:
+						out.push(8);
+						break;
+					case 102:
+						out.push(12);
+						break;
+					case 10: break;
+					case 13:
+						if (buf[this.pos] === 10) this.pos++;
+						break;
+					default: if (e >= 48 && e <= 55) {
+						let oct = e - 48;
+						for (let k = 0; k < 2 && this.pos < buf.length; k++) {
+							const d = buf[this.pos];
+							if (d < 48 || d > 55) break;
+							oct = oct * 8 + (d - 48);
+							this.pos++;
+						}
+						out.push(oct & 255);
+					} else out.push(e);
+				}
+				continue;
+			}
+			if (b === 40) {
+				depth++;
+				out.push(b);
+				continue;
+			}
+			if (b === 41) {
+				depth--;
+				if (depth === 0) break;
+				out.push(b);
+				continue;
+			}
+			out.push(b);
+		}
+		return {
+			kind: "str",
+			value: latin1(Uint8Array.from(out))
+		};
+	}
+	indexOfAscii(needle, from) {
+		const buf = this.buf;
+		const n = needle.length;
+		outer: for (let i = from; i <= buf.length - n; i++) {
+			for (let j = 0; j < n; j++) if (buf[i + j] !== needle.charCodeAt(j)) continue outer;
+			return i;
+		}
+		return -1;
+	}
+	readStreamBody(length) {
+		const buf = this.buf;
+		if (buf[this.pos] === 13 && buf[this.pos + 1] === 10) this.pos += 2;
+		else if (buf[this.pos] === 10 || buf[this.pos] === 13) this.pos += 1;
+		const start = this.pos;
+		if (length !== void 0 && length >= 0 && start + length <= buf.length) {
+			this.pos = start + length;
+			return buf.subarray(start, start + length);
+		}
+		const es = this.indexOfAscii("endstream", start);
+		const end = es < 0 ? buf.length : es;
+		let dataEnd = end;
+		if (dataEnd > start && buf[dataEnd - 1] === 10) {
+			dataEnd--;
+			if (dataEnd > start && buf[dataEnd - 1] === 13) dataEnd--;
+		} else if (dataEnd > start && buf[dataEnd - 1] === 13) dataEnd--;
+		this.pos = end;
+		return buf.subarray(start, dataEnd);
+	}
+};
+function latin1(bytes) {
+	let s = "";
+	for (const b of bytes) s += String.fromCharCode(b);
+	return s;
+}
+//#endregion
+export { Lexer };

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

@@ -0,0 +1,10 @@
+import { Lexer } from './lexer.js';
+import { PdfValue, PdfRef } from '../pdf/objects.js';
+export type LengthResolver = (ref: PdfRef) => number | undefined;
+export interface IndirectObject {
+    readonly id: number;
+    readonly generation: number;
+    readonly value: PdfValue;
+}
+export declare function parseObject(lexer: Lexer, resolveLength?: LengthResolver): PdfValue;
+export declare function parseIndirectObject(lexer: Lexer, resolveLength?: LengthResolver): IndirectObject | undefined;

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

@@ -0,0 +1,86 @@
+import { PDF_NULL, PdfHexString, PdfName, PdfRef, PdfStream } from "../pdf/objects.js";
+//#region src/pdf-reader/parser.ts
+function parseObject(lexer, resolveLength) {
+	return parseValue(lexer, lexer.nextToken(), resolveLength);
+}
+function parseIndirectObject(lexer, resolveLength) {
+	const idTok = lexer.nextToken();
+	if (idTok.kind !== "num") return void 0;
+	const genTok = lexer.nextToken();
+	if (genTok.kind !== "num") return void 0;
+	const objTok = lexer.nextToken();
+	if (objTok.kind !== "keyword" || objTok.value !== "obj") return void 0;
+	const value = parseObject(lexer, resolveLength);
+	const save = lexer.pos;
+	const end = lexer.nextToken();
+	if (!(end.kind === "keyword" && end.value === "endobj")) lexer.pos = save;
+	return {
+		id: idTok.value,
+		generation: genTok.value,
+		value
+	};
+}
+function parseValue(lexer, tok, resolveLength) {
+	switch (tok.kind) {
+		case "num": return parseNumberOrRef(lexer, tok.value);
+		case "name": return new PdfName(tok.value);
+		case "str": return tok.value;
+		case "hexstr": return new PdfHexString(tok.bytes);
+		case "arrayOpen": return parseArray(lexer, resolveLength);
+		case "dictOpen": return parseDictOrStream(lexer, resolveLength);
+		case "keyword":
+			if (tok.value === "true") return true;
+			if (tok.value === "false") return false;
+			return PDF_NULL;
+		default: return PDF_NULL;
+	}
+}
+function parseNumberOrRef(lexer, first) {
+	if (!Number.isInteger(first) || first < 0) return first;
+	const save = lexer.pos;
+	const gen = lexer.nextToken();
+	if (gen.kind === "num" && Number.isInteger(gen.value)) {
+		const r = lexer.nextToken();
+		if (r.kind === "keyword" && r.value === "R") return new PdfRef(first, gen.value);
+	}
+	lexer.pos = save;
+	return first;
+}
+function parseArray(lexer, resolveLength) {
+	const out = [];
+	for (;;) {
+		const tok = lexer.nextToken();
+		if (tok.kind === "arrayClose" || tok.kind === "eof") break;
+		out.push(parseValue(lexer, tok, resolveLength));
+	}
+	return out;
+}
+function parseDictOrStream(lexer, resolveLength) {
+	const map = /* @__PURE__ */ new Map();
+	for (;;) {
+		const keyTok = lexer.nextToken();
+		if (keyTok.kind === "dictClose" || keyTok.kind === "eof") break;
+		if (keyTok.kind !== "name") {
+			if (keyTok.kind === "arrayOpen" || keyTok.kind === "dictOpen") parseValue(lexer, keyTok, resolveLength);
+			continue;
+		}
+		const value = parseObject(lexer, resolveLength);
+		map.set(keyTok.value, value);
+	}
+	const save = lexer.pos;
+	const next = lexer.nextToken();
+	if (next.kind === "keyword" && next.value === "stream") {
+		const lengthVal = map.get("Length");
+		let length;
+		if (typeof lengthVal === "number") length = lengthVal;
+		else if (lengthVal instanceof PdfRef && resolveLength) length = resolveLength(lengthVal);
+		const data = lexer.readStreamBody(length);
+		const endTok = lexer.nextToken();
+		if (!(endTok.kind === "keyword" && endTok.value === "endstream")) {}
+		return new PdfStream(map, data);
+	}
+	lexer.pos = save;
+	return map;
+}
+//#endregion
+export { parseIndirectObject, parseObject };

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

@@ -0,0 +1,4 @@
+import { DocumentReader, ReadResult } from '../core/ir/adapters.js';
+import { FlowDoc } from '../core/ir/flow.js';
+export declare function readPdf(bytes: Uint8Array): ReadResult<FlowDoc>;
+export declare const pdfReader: DocumentReader<FlowDoc>;

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

@@ -0,0 +1,43 @@
+import { FEATURES } from "../core/ir/features.js";
+import { PdfFile } from "./document.js";
+import { reconstructByLayout } from "./layout.js";
+import { reconstructTaggedPdf } from "./tagged.js";
+//#region src/pdf-reader/reader.ts
+function sniffPdf(bytes) {
+	const limit = Math.min(bytes.length - 5, 1024);
+	for (let i = 0; i <= limit; i++) if (bytes[i] === 37 && bytes[i + 1] === 80 && bytes[i + 2] === 68 && bytes[i + 3] === 70 && bytes[i + 4] === 45) return true;
+	return false;
+}
+function readPdf(bytes) {
+	const file = PdfFile.parse(bytes);
+	const losses = [];
+	const tagged = reconstructTaggedPdf(file);
+	const doc = tagged ?? reconstructByLayout(file);
+	if (!tagged) losses.push({
+		severity: "degraded",
+		feature: FEATURES.text,
+		detail: "untagged PDF — text and headings reconstructed heuristically from glyph positions; structure is approximate"
+	});
+	losses.push({
+		severity: "dropped",
+		feature: FEATURES.images,
+		detail: "PDF images and vector graphics are not reconstructed"
+	});
+	return {
+		doc,
+		losses
+	};
+}
+var pdfReader = {
+	id: "pdf",
+	produces: "flow",
+	supports: new Set([
+		FEATURES.text,
+		FEATURES.tables,
+		FEATURES.lists
+	]),
+	sniff: sniffPdf,
+	read: (bytes) => readPdf(bytes)
+};
+//#endregion
+export { pdfReader };

package/dist/esm/pdf-reader/struct-tree.d.ts

@@ -0,0 +1,14 @@
+import { PdfFile } from './document.js';
+export interface StructMcid {
+    readonly page: number;
+    readonly mcid: number;
+}
+export interface StructNode {
+    readonly type: string;
+    readonly mcids: ReadonlyArray<StructMcid>;
+    readonly children: ReadonlyArray<StructNode>;
+    readonly alt?: string;
+    readonly colSpan?: number;
+    readonly rowSpan?: number;
+}
+export declare function readStructTree(file: PdfFile): StructNode | undefined;

package/dist/esm/pdf-reader/struct-tree.js

@@ -0,0 +1,92 @@
+import { PDF_NULL, PdfName } from "../pdf/objects.js";
+//#region src/pdf-reader/struct-tree.ts
+var MAX_NODES = 2e5;
+function readStructTree(file) {
+	const stRoot = file.get(file.catalog, "StructTreeRoot");
+	if (!(stRoot instanceof Map)) return void 0;
+	const pageMap = /* @__PURE__ */ new Map();
+	file.pages().forEach((p, i) => pageMap.set(p.dict, i));
+	const pageIndexOf = (pgVal) => {
+		const pg = file.resolve(pgVal);
+		return pg instanceof Map ? pageMap.get(pg) : void 0;
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const read = (value, parentPage) => {
+		const elem = file.resolve(value);
+		if (!(elem instanceof Map) || seen.has(elem) || seen.size > MAX_NODES) return void 0;
+		seen.add(elem);
+		const ownPage = pageIndexOf(elem.get("Pg") ?? PDF_NULL) ?? parentPage;
+		const mcids = [];
+		const children = [];
+		for (const kid of kidList(file, elem.get("K"))) {
+			const rk = file.resolve(kid);
+			if (typeof rk === "number") {
+				if (ownPage >= 0) mcids.push({
+					page: ownPage,
+					mcid: rk
+				});
+			} else if (rk instanceof Map) {
+				const kind = nameOf(rk.get("Type"));
+				if (kind === "MCR") {
+					const m = rk.get("MCID");
+					const page = pageIndexOf(rk.get("Pg") ?? PDF_NULL) ?? ownPage;
+					if (typeof m === "number" && page >= 0) mcids.push({
+						page,
+						mcid: m
+					});
+				} else if (kind === "OBJR") {} else {
+					const child = read(rk, ownPage);
+					if (child) children.push(child);
+				}
+			}
+		}
+		const alt = elem.get("Alt");
+		const { colSpan, rowSpan } = readSpans(file, elem.get("A") ?? PDF_NULL);
+		return {
+			type: nameOf(elem.get("S")),
+			mcids,
+			children,
+			...typeof alt === "string" ? { alt } : {},
+			...colSpan > 1 ? { colSpan } : {},
+			...rowSpan > 1 ? { rowSpan } : {}
+		};
+	};
+	const roots = kidList(file, stRoot.get("K")).map((k) => read(k, -1)).filter((n) => n !== void 0);
+	if (roots.length === 1) return roots[0];
+	return {
+		type: "Document",
+		mcids: [],
+		children: roots
+	};
+}
+function kidList(file, kVal) {
+	if (kVal === void 0) return [];
+	const k = file.resolve(kVal);
+	if (Array.isArray(k)) return k;
+	if (k === PDF_NULL) return [];
+	return [k];
+}
+function nameOf(v) {
+	return v instanceof PdfName ? v.value : "";
+}
+function readSpans(file, aVal) {
+	let colSpan = 1;
+	let rowSpan = 1;
+	const a = file.resolve(aVal);
+	const attrs = Array.isArray(a) ? a : [a];
+	for (const entry of attrs) {
+		const d = file.resolve(entry);
+		if (d instanceof Map) {
+			const cs = d.get("ColSpan");
+			const rs = d.get("RowSpan");
+			if (typeof cs === "number") colSpan = cs;
+			if (typeof rs === "number") rowSpan = rs;
+		}
+	}
+	return {
+		colSpan,
+		rowSpan
+	};
+}
+//#endregion
+export { readStructTree };

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

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