reamkit 1.4.0 → 1.6.0

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

@@ -0,0 +1,72 @@
+import { Lexer } from "./lexer.js";
+//#region src/pdf-reader/cmap.ts
+var MAX_RANGE = 65536;
+function parseToUnicodeCMap(bytes) {
+	const lexer = new Lexer(bytes);
+	const map = /* @__PURE__ */ new Map();
+	let codeBytes = 1;
+	for (;;) {
+		const tok = lexer.nextToken();
+		if (tok.kind === "eof") break;
+		if (tok.kind !== "keyword") continue;
+		if (tok.value === "begincodespacerange") for (;;) {
+			const t = lexer.nextToken();
+			if (t.kind === "eof" || t.kind === "keyword" && t.value === "endcodespacerange") break;
+			if (t.kind === "hexstr") {
+				if (t.bytes.length >= 2) codeBytes = 2;
+				lexer.nextToken();
+			}
+		}
+		else if (tok.value === "beginbfchar") for (;;) {
+			const src = lexer.nextToken();
+			if (src.kind === "eof" || src.kind === "keyword" && src.value === "endbfchar") break;
+			if (src.kind !== "hexstr") continue;
+			const dst = lexer.nextToken();
+			if (dst.kind !== "hexstr") continue;
+			map.set(bytesToInt(src.bytes), utf16be(dst.bytes));
+		}
+		else if (tok.value === "beginbfrange") for (;;) {
+			const lo = lexer.nextToken();
+			if (lo.kind === "eof" || lo.kind === "keyword" && lo.value === "endbfrange") break;
+			if (lo.kind !== "hexstr") continue;
+			const hi = lexer.nextToken();
+			if (hi.kind !== "hexstr") continue;
+			const loN = bytesToInt(lo.bytes);
+			const hiN = bytesToInt(hi.bytes);
+			const dst = lexer.nextToken();
+			if (dst.kind === "hexstr") {
+				const base = utf16be(dst.bytes);
+				for (let i = 0; loN + i <= hiN && i < MAX_RANGE; i++) map.set(loN + i, incString(base, i));
+			} else if (dst.kind === "arrayOpen") {
+				let i = 0;
+				for (;;) {
+					const el = lexer.nextToken();
+					if (el.kind === "arrayClose" || el.kind === "eof") break;
+					if (el.kind === "hexstr") map.set(loN + i++, utf16be(el.bytes));
+				}
+			}
+		}
+	}
+	return {
+		map,
+		codeBytes
+	};
+}
+function bytesToInt(bytes) {
+	let n = 0;
+	for (const b of bytes) n = n * 256 + b;
+	return n;
+}
+function utf16be(bytes) {
+	let s = "";
+	for (let i = 0; i + 1 < bytes.length; i += 2) s += String.fromCharCode(bytes[i] << 8 | bytes[i + 1]);
+	if (bytes.length % 2 === 1) s += String.fromCharCode(bytes[bytes.length - 1]);
+	return s;
+}
+function incString(base, i) {
+	if (i === 0) return base;
+	if (base.length === 1) return String.fromCharCode(base.charCodeAt(0) + i);
+	return base;
+}
+//#endregion
+export { parseToUnicodeCMap };

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

@@ -0,0 +1,14 @@
+export interface ContentFont {
+    readonly bytesPerCode: 1 | 2;
+    decode: (codes: ReadonlyArray<number>) => string;
+    width: (code: number) => number;
+}
+export interface TextRun {
+    readonly text: string;
+    readonly x: number;
+    readonly y: number;
+    readonly fontSizePt: number;
+    readonly fontKey: string;
+    readonly mcid?: number;
+}
+export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>): Array<TextRun>;

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

@@ -0,0 +1,292 @@
+import { PDF_NULL, PdfHexString, PdfName } from "../pdf/objects.js";
+import { Lexer } from "./lexer.js";
+//#region src/pdf-reader/content.ts
+var IDENTITY = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+function multiply(a, b) {
+	return [
+		a[0] * b[0] + a[1] * b[2],
+		a[0] * b[1] + a[1] * b[3],
+		a[2] * b[0] + a[3] * b[2],
+		a[2] * b[1] + a[3] * b[3],
+		a[4] * b[0] + a[5] * b[2] + b[4],
+		a[4] * b[1] + a[5] * b[3] + b[5]
+	];
+}
+function translation(tx, ty) {
+	return [
+		1,
+		0,
+		0,
+		1,
+		tx,
+		ty
+	];
+}
+var FALLBACK_FONT = {
+	bytesPerCode: 1,
+	decode: (codes) => codes.map((c) => String.fromCharCode(c)).join(""),
+	width: () => 500
+};
+function initialState() {
+	return {
+		ctm: IDENTITY,
+		fontKey: "",
+		font: FALLBACK_FONT,
+		fontSize: 0,
+		charSpacing: 0,
+		wordSpacing: 0,
+		hScale: 1,
+		leading: 0,
+		rise: 0
+	};
+}
+function interpretContent(bytes, fonts) {
+	const runs = [];
+	const lexer = new Lexer(bytes);
+	const stack = [];
+	let state = initialState();
+	let tm = IDENTITY;
+	let tlm = IDENTITY;
+	let operands = [];
+	const mcStack = [];
+	const num = (i) => {
+		const v = operands[i];
+		return typeof v === "number" ? v : 0;
+	};
+	const advanceGlyph = (code) => {
+		const w0 = state.font.width(code) / 1e3;
+		const isSpace = state.font.bytesPerCode === 1 && code === 32;
+		tm = multiply(translation((w0 * state.fontSize + state.charSpacing + (isSpace ? state.wordSpacing : 0)) * state.hScale, 0), tm);
+	};
+	const consume = (operand) => {
+		const codes = splitCodes(toBytes(operand), state.font.bytesPerCode);
+		for (const code of codes) advanceGlyph(code);
+		return state.font.decode(codes);
+	};
+	const emitAt = (origin, text) => {
+		if (text.length === 0) return;
+		const scaleY = Math.hypot(origin[2], origin[3]) || 1;
+		const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
+		runs.push({
+			text,
+			x: origin[4],
+			y: origin[5],
+			fontSizePt: state.fontSize * scaleY,
+			fontKey: state.fontKey,
+			...mcid !== void 0 ? { mcid } : {}
+		});
+	};
+	const showString = (operand) => {
+		emitAt(multiply(tm, state.ctm), consume(operand));
+	};
+	const showArray = (arr) => {
+		const origin = multiply(tm, state.ctm);
+		let text = "";
+		for (const el of arr) if (typeof el === "number") tm = multiply(translation(-el / 1e3 * state.fontSize * state.hScale, 0), tm);
+		else if (typeof el === "string" || el instanceof PdfHexString) text += consume(el);
+		emitAt(origin, text);
+	};
+	const exec = (op) => {
+		switch (op) {
+			case "q":
+				stack.push({ ...state });
+				break;
+			case "Q":
+				state = stack.pop() ?? state;
+				break;
+			case "cm":
+				state.ctm = multiply(matrixFromOperands(operands), state.ctm);
+				break;
+			case "BT":
+				tm = IDENTITY;
+				tlm = IDENTITY;
+				break;
+			case "ET": break;
+			case "Tf": {
+				const key = operands[0] instanceof PdfName ? operands[0].value : "";
+				state.fontKey = key;
+				state.font = fonts.get(key) ?? FALLBACK_FONT;
+				state.fontSize = num(1);
+				break;
+			}
+			case "Td":
+				tlm = multiply(translation(num(0), num(1)), tlm);
+				tm = tlm;
+				break;
+			case "TD":
+				state.leading = -num(1);
+				tlm = multiply(translation(num(0), num(1)), tlm);
+				tm = tlm;
+				break;
+			case "Tm":
+				tlm = matrixFromOperands(operands);
+				tm = tlm;
+				break;
+			case "T*":
+				tlm = multiply(translation(0, -state.leading), tlm);
+				tm = tlm;
+				break;
+			case "TL":
+				state.leading = num(0);
+				break;
+			case "Tc":
+				state.charSpacing = num(0);
+				break;
+			case "Tw":
+				state.wordSpacing = num(0);
+				break;
+			case "Tz":
+				state.hScale = num(0) / 100;
+				break;
+			case "Ts":
+				state.rise = num(0);
+				break;
+			case "Tj":
+				if (operands.length > 0) showString(operands[operands.length - 1]);
+				break;
+			case "TJ":
+				if (Array.isArray(operands[0])) showArray(operands[0]);
+				break;
+			case "'":
+				tlm = multiply(translation(0, -state.leading), tlm);
+				tm = tlm;
+				if (operands.length > 0) showString(operands[operands.length - 1]);
+				break;
+			case "\"":
+				state.wordSpacing = num(0);
+				state.charSpacing = num(1);
+				tlm = multiply(translation(0, -state.leading), tlm);
+				tm = tlm;
+				if (operands.length > 2) showString(operands[2]);
+				break;
+			case "BDC": {
+				const tag = operands[operands.length - 2];
+				const props = operands[operands.length - 1];
+				const mcidVal = !(tag instanceof PdfName && tag.value === "Artifact") && props instanceof Map ? props.get("MCID") : void 0;
+				mcStack.push(typeof mcidVal === "number" ? mcidVal : void 0);
+				break;
+			}
+			case "BMC":
+				mcStack.push(void 0);
+				break;
+			case "EMC":
+				mcStack.pop();
+				break;
+			default: break;
+		}
+	};
+	for (;;) {
+		lexer.skipWhitespace();
+		const tok = lexer.nextToken();
+		if (tok.kind === "eof") break;
+		switch (tok.kind) {
+			case "num":
+				operands.push(tok.value);
+				break;
+			case "name":
+				operands.push(new PdfName(tok.value));
+				break;
+			case "str":
+				operands.push(tok.value);
+				break;
+			case "hexstr":
+				operands.push(new PdfHexString(tok.bytes));
+				break;
+			case "arrayOpen":
+				operands.push(readArray(lexer));
+				break;
+			case "dictOpen":
+				operands.push(readDict(lexer));
+				break;
+			case "keyword":
+				if (tok.value === "BI") skipInlineImage(lexer);
+				else exec(tok.value);
+				operands = [];
+				break;
+			default:
+				operands = [];
+				break;
+		}
+	}
+	return runs;
+}
+function matrixFromOperands(operands) {
+	const n = (i) => typeof operands[i] === "number" ? operands[i] : 0;
+	return [
+		n(0),
+		n(1),
+		n(2),
+		n(3),
+		n(4),
+		n(5)
+	];
+}
+function toBytes(operand) {
+	if (operand instanceof PdfHexString) return operand.bytes;
+	if (typeof operand === "string") {
+		const out = new Uint8Array(operand.length);
+		for (let i = 0; i < operand.length; i++) out[i] = operand.charCodeAt(i) & 255;
+		return out;
+	}
+	return new Uint8Array(0);
+}
+function splitCodes(bytes, bytesPerCode) {
+	const out = [];
+	if (bytesPerCode === 2) {
+		for (let i = 0; i + 1 < bytes.length; i += 2) out.push(bytes[i] << 8 | bytes[i + 1]);
+		if (bytes.length % 2 === 1) out.push(bytes[bytes.length - 1]);
+	} else for (const b of bytes) out.push(b);
+	return out;
+}
+function readArray(lexer) {
+	const out = [];
+	for (;;) {
+		const tok = lexer.nextToken();
+		if (tok.kind === "arrayClose" || tok.kind === "eof") break;
+		if (tok.kind === "num") out.push(tok.value);
+		else if (tok.kind === "str") out.push(tok.value);
+		else if (tok.kind === "hexstr") out.push(new PdfHexString(tok.bytes));
+	}
+	return out;
+}
+function readDict(lexer) {
+	const map = /* @__PURE__ */ new Map();
+	for (;;) {
+		const key = lexer.nextToken();
+		if (key.kind === "dictClose" || key.kind === "eof") break;
+		if (key.kind !== "name") continue;
+		map.set(key.value, readValue(lexer));
+	}
+	return map;
+}
+function readValue(lexer) {
+	const tok = lexer.nextToken();
+	switch (tok.kind) {
+		case "num": return tok.value;
+		case "name": return new PdfName(tok.value);
+		case "str": return tok.value;
+		case "hexstr": return new PdfHexString(tok.bytes);
+		case "arrayOpen": return readArray(lexer);
+		case "dictOpen": return readDict(lexer);
+		case "keyword": return tok.value === "true" ? true : tok.value === "false" ? false : PDF_NULL;
+		default: return PDF_NULL;
+	}
+}
+function skipInlineImage(lexer) {
+	for (;;) {
+		const tok = lexer.nextToken();
+		if (tok.kind === "eof") return;
+		if (tok.kind === "keyword" && tok.value === "ID") break;
+	}
+	const ei = lexer.indexOfAscii("EI", lexer.pos);
+	lexer.pos = ei < 0 ? lexer.length : ei + 2;
+}
+//#endregion
+export { interpretContent };

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

@@ -0,0 +1,23 @@
+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 constructor();
+    static parse(bytes: Uint8Array): PdfFile;
+    resolve(value: PdfValue): PdfValue;
+    get(dict: PdfDict, key: string): PdfValue;
+    get catalog(): PdfDict;
+    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,230 @@
+import { PDF_NULL, PdfName, PdfRef, PdfStream } from "../pdf/objects.js";
+import { Lexer } from "./lexer.js";
+import { parseIndirectObject, parseObject } from "./parser.js";
+import { unzlibSync } from "fflate";
+//#region src/pdf-reader/document.ts
+var DEFAULT_MEDIA_BOX = [
+	0,
+	0,
+	612,
+	792
+];
+var MAX_PAGES = 5e4;
+var PdfFile = class PdfFile {
+	cache = /* @__PURE__ */ new Map();
+	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, off] of scanned.xref) if (!xref.has(id)) xref.set(id, off);
+			if (!(trailer.get("Root") instanceof PdfRef) && scanned.root) {
+				trailer = new Map(trailer);
+				trailer.set("Root", scanned.root);
+			}
+		}
+		return new PdfFile(bytes, xref, trailer);
+	}
+	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;
+		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;
+		this.cache.set(value.id, result);
+		return result;
+	}
+	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();
+	}
+	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];
+		for (const f of filters) if (f instanceof PdfName && (f.value === "FlateDecode" || f.value === "Fl")) try {
+			data = unzlibSync(data);
+		} catch {}
+		return 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();
+	let at = offset;
+	while (at !== void 0 && at >= 0 && at < buf.length && !visited.has(at)) {
+		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);
+		if (trailer.size === 0) trailer = section.trailer;
+		const prev = section.trailer.get("Prev");
+		at = typeof prev === "number" ? prev : void 0;
+	}
+	return {
+		xref,
+		trailer
+	};
+}
+function readXrefSection(buf, offset) {
+	const lexer = new Lexer(buf, offset);
+	const head = lexer.nextToken();
+	if (!(head.kind === "keyword" && head.value === "xref")) return void 0;
+	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, off.value);
+		}
+	}
+	const trailerVal = parseObject(lexer);
+	return {
+		xref,
+		trailer: trailerVal instanceof Map ? trailerVal : /* @__PURE__ */ new Map()
+	};
+}
+function bruteForceScan(buf) {
+	const xref = /* @__PURE__ */ new Map();
+	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, 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);
+				}
+			}
+		}
+		prev2 = prev1;
+		prev1 = tok.kind === "num" ? {
+			start,
+			value: tok.value
+		} : void 0;
+	}
+	return {
+		xref,
+		root
+	};
+}
+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,4 @@
+import { BodyElement } from '../core/document-model/index.js';
+import { FlowDoc } from '../core/ir/flow.js';
+export declare function paragraphBlock(text: string, outlineLevel?: number): BodyElement;
+export declare function buildFlowDoc(body: ReadonlyArray<BodyElement>): FlowDoc;

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

@@ -0,0 +1,27 @@
+import { ResourceStore } from "../core/ir/resources.js";
+import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
+import "../core/style-cascade/index.js";
+//#region src/pdf-reader/flow-build.ts
+function paragraphBlock(text, outlineLevel) {
+	return {
+		kind: "paragraph",
+		paragraph: {
+			properties: outlineLevel !== void 0 ? { outlineLevel } : {},
+			runs: text.length > 0 ? [{
+				text,
+				properties: {}
+			}] : []
+		}
+	};
+}
+function buildFlowDoc(body) {
+	return {
+		kind: "flow",
+		body: resolveBodyStyles([...body], EMPTY_STYLE_SHEET),
+		sections: [],
+		styles: EMPTY_STYLE_SHEET,
+		resources: new ResourceStore()
+	};
+}
+//#endregion
+export { buildFlowDoc, paragraphBlock };

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

@@ -0,0 +1,4 @@
+import { PdfDict } from '../pdf/objects.js';
+import { ContentFont } from './content.js';
+import { PdfFile } from './document.js';
+export declare function buildContentFont(file: PdfFile, fontDict: PdfDict): ContentFont;