reamkit 1.24.0 → 1.25.0

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

@@ -26,10 +26,11 @@ var PdfFile = class PdfFile {
 	objStmCache = /* @__PURE__ */ new Map();
 	decryptor;
 	encryptObjNum = -1;
-	constructor(buf, xref, trailer) {
+	constructor(buf, xref, trailer, filters = {}) {
 		this.buf = buf;
 		this.xref = xref;
 		this.trailer = trailer;
+		this.filters = filters;
 	}
 	/**
 	* Parse a whole PDF byte buffer: read the cross-reference chain (or brute-force
@@ -38,28 +39,31 @@ var PdfFile = class PdfFile {
 	* @param bytes    The complete PDF file bytes.
 	* @param password The user password for an encrypted source (EP14); the empty
 	*                 string opens permissions-only encryption.
+	* @param filters  Decoders for `/Filter` names this reader does not implement.
 	* @returns A ready-to-query {@link PdfFile}.
 	*/
-	static parse(bytes, password = "") {
+	static parse(bytes, password = "", filters = {}) {
+		const unknownFilters = /* @__PURE__ */ new Set();
 		let xref = /* @__PURE__ */ new Map();
 		let trailer = /* @__PURE__ */ new Map();
 		try {
 			const start = findStartXref(bytes);
 			if (start >= 0) {
-				const built = readXrefChain(bytes, start);
+				const built = readXrefChain(bytes, start, unknownFilters, filters);
 				xref = built.xref;
 				trailer = built.trailer;
 			}
 		} catch {}
 		if (xref.size === 0 || !(trailer.get("Root") instanceof PdfRef)) {
-			const scanned = bruteForceScan(bytes);
+			const scanned = bruteForceScan(bytes, unknownFilters, filters);
 			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);
+		const file = new PdfFile(bytes, xref, trailer, filters);
+		for (const name of unknownFilters) file.unknownFilters.add(name);
 		file.initEncryption(password);
 		return file;
 	}
@@ -121,7 +125,7 @@ var PdfFile = class PdfFile {
 			const dec = this.decryptor.decrypt(stream, streamObj, obj.generation);
 			if (dec instanceof PdfStream) stream = dec;
 		}
-		const data = inflateStream(stream);
+		const data = inflateStream(stream, this.unknownFilters, this.filters);
 		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;
@@ -160,6 +164,7 @@ var PdfFile = class PdfFile {
 		const mediaBox = readRectangle(this.get(node, "MediaBox")) ?? inherited.mediaBox;
 		const resourcesVal = this.get(node, "Resources");
 		const resources = resourcesVal instanceof Map ? resourcesVal : inherited.resources;
+		const rotate = readRotate(this.get(node, "Rotate")) ?? inherited.rotate;
 		const type = node.get("Type");
 		const kids = this.get(node, "Kids");
 		if (type instanceof PdfName && type.value === "Pages" && Array.isArray(kids)) {
@@ -167,7 +172,8 @@ var PdfFile = class PdfFile {
 				const kidNode = this.resolve(kid);
 				if (kidNode instanceof Map) this.walkPageTree(kidNode, {
 					mediaBox,
-					resources
+					resources,
+					rotate
 				}, out, seen);
 				if (out.length >= MAX_PAGES) break;
 			}
@@ -176,6 +182,7 @@ var PdfFile = class PdfFile {
 		out.push({
 			dict: node,
 			mediaBox: mediaBox ?? DEFAULT_MEDIA_BOX,
+			rotate: rotate ?? 0,
 			resources
 		});
 	}
@@ -202,20 +209,57 @@ var PdfFile = class PdfFile {
 		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 {}
+		for (const f of filters) {
+			if (!(f instanceof PdfName)) continue;
+			if (f.value === "FlateDecode" || f.value === "Fl") try {
+				data = unzlibSync(data);
+				flate = true;
+			} catch {}
+			else if (this.filters[f.value]) {
+				const decoded = runFilter(this.filters[f.value], data);
+				if (decoded) data = decoded;
+				else this.unknownFilters.add(f.value);
+			} else if (!PASSTHROUGH_FILTERS.has(f.value)) this.unknownFilters.add(f.value);
+		}
 		return flate ? applyStreamPredictor(this, stream.dict, data) : data;
 	}
+	/** Filter names met in this file that nothing here can undo. */
+	unknownFilters = /* @__PURE__ */ new Set();
 };
+/** Run a supplied filter, treating a throw as a filter that cannot decode. */
+function runFilter(filter, data) {
+	if (!filter) return void 0;
+	try {
+		const out = filter(data);
+		return out.length > 0 ? out : void 0;
+	} catch {
+		return;
+	}
+}
+var PASSTHROUGH_FILTERS = new Set([
+	"LZWDecode",
+	"LZW",
+	"RunLengthDecode",
+	"RL",
+	"ASCII85Decode",
+	"A85",
+	"ASCIIHexDecode",
+	"AHx",
+	"DCTDecode",
+	"DCT",
+	"JPXDecode",
+	"JBIG2Decode",
+	"CCITTFaxDecode",
+	"CCF",
+	"Crypt"
+]);
 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) {
+function readXrefChain(buf, offset, unknown, filters = {}) {
 	const xref = /* @__PURE__ */ new Map();
 	let trailer = /* @__PURE__ */ new Map();
 	const visited = /* @__PURE__ */ new Set();
@@ -224,7 +268,7 @@ function readXrefChain(buf, offset) {
 		const at = queue.shift();
 		if (at < 0 || at >= buf.length || visited.has(at)) continue;
 		visited.add(at);
-		const section = readXrefAt(buf, at);
+		const section = readXrefAt(buf, at, unknown, filters);
 		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;
@@ -238,12 +282,12 @@ function readXrefChain(buf, offset) {
 		trailer
 	};
 }
-function readXrefAt(buf, offset) {
+function readXrefAt(buf, offset, unknown, filters = {}) {
 	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);
+	if (obj && obj.value instanceof PdfStream) return readXrefStream(obj.value, unknown, filters);
 }
 function readClassicXref(lexer) {
 	const xref = /* @__PURE__ */ new Map();
@@ -272,7 +316,7 @@ function readClassicXref(lexer) {
 		trailer: trailerVal instanceof Map ? trailerVal : /* @__PURE__ */ new Map()
 	};
 }
-function readXrefStream(stream) {
+function readXrefStream(stream, unknown, filters = {}) {
 	const dict = stream.dict;
 	const wv = dict.get("W");
 	if (!Array.isArray(wv) || wv.length < 3) return void 0;
@@ -281,7 +325,7 @@ function readXrefStream(stream) {
 	const w2 = numOf(wv[2]);
 	const rowLen = w0 + w1 + w2;
 	if (rowLen <= 0) return void 0;
-	const data = inflateStream(stream);
+	const data = inflateStream(stream, unknown, filters);
 	const size = numOf(dict.get("Size"));
 	const indexV = dict.get("Index");
 	const index = Array.isArray(indexV) ? indexV.map(numOf) : [0, size];
@@ -327,14 +371,22 @@ function objStmHeader(data, n) {
 	}
 	return out;
 }
-function inflateStream(stream) {
+function inflateStream(stream, unknown, filters = {}) {
 	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 chain = Array.isArray(filter) ? filter : [filter];
+	for (const f of chain) {
+		if (!(f instanceof PdfName)) continue;
+		if (f.value === "FlateDecode" || f.value === "Fl") try {
+			data = unzlibSync(data);
+		} catch {
+			return new Uint8Array(0);
+		}
+		else if (!PASSTHROUGH_FILTERS.has(f.value)) {
+			const decoded = runFilter(filters[f.value], data);
+			if (decoded) data = decoded;
+			else unknown?.add(f.value);
+		}
 	}
 	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;
@@ -362,7 +414,7 @@ function applyStreamPredictor(file, dict, data) {
 		columns: numOf(file.get(parms, "Columns")) || 1
 	});
 }
-function bruteForceScan(buf) {
+function bruteForceScan(buf, unknown, filters = {}) {
 	const xref = /* @__PURE__ */ new Map();
 	const objStmObjs = [];
 	let root;
@@ -398,7 +450,7 @@ function bruteForceScan(buf) {
 		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 data = inflateStream(obj.value, unknown, filters);
 		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, {
@@ -439,6 +491,21 @@ function readRectangle(value) {
 		nums[3]
 	];
 }
+/**
+* §14.11.1 `/Rotate` — a multiple of 90, and the spec says so, but a file is
+* free to write −90 or 450 and readers take both. Anything that is not a
+* quarter turn is no turn at all.
+*/
+function readRotate(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+	if (value % 90 !== 0) return void 0;
+	return [
+		0,
+		90,
+		180,
+		270
+	][(value / 90 % 4 + 4) % 4];
+}
 function concatWithSpaces(parts) {
 	if (parts.length === 1) return parts[0];
 	const total = parts.reduce((n, p) => n + p.length + 1, 0);

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

@@ -0,0 +1,31 @@
+import { PdfDict } from '../pdf/objects.js';
+import { PdfFile, PdfPage } from './document.js';
+import { FontRegistry } from '../core/font/index.js';
+/**
+ * Every embedded TrueType program the pages use, by the name a run will ask for
+ * — the `/BaseFont` lowercased, with the subset prefix dropped.
+ *
+ * Each PDF font object becomes its OWN entry rather than being folded into a
+ * family: `Arial-BoldMT` is a different program from `ArialMT` and the run that
+ * uses it names it exactly, so nothing has to guess at weights or match faces
+ * up. A face the reader cannot parse is left out and the writer substitutes for
+ * it as before.
+ *
+ * Only `/FontFile2` is read. A CFF program (`/FontFile3`) and a Type 1 one
+ * (`/FontFile`) are different formats that the layout's parser does not take;
+ * those keep their substitute.
+ *
+ * @param file  The owning file.
+ * @param pages The pages whose fonts are wanted.
+ * @returns Name → a one-face registry holding that program.
+ */
+export declare function collectEmbeddedFonts(file: PdfFile, pages: ReadonlyArray<PdfPage>): Map<string, FontRegistry>;
+/**
+ * The name a run set in `fontDict` will ask for: its `/BaseFont` without the
+ * six-capital subset prefix (§9.6.4), lowercased.
+ *
+ * @param file     The owning file.
+ * @param fontDict A `/Font` dictionary.
+ * @returns The name, or `undefined` when the font states none.
+ */
+export declare function embeddedFontName(file: PdfFile, fontDict: PdfDict): string | undefined;

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

@@ -0,0 +1,94 @@
+import { FontRegistry } from "../core/font/font-registry.js";
+import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+//#region src/pdf-reader/embedded-fonts.ts
+var MAX_FORM_DEPTH = 8;
+/**
+* Every embedded TrueType program the pages use, by the name a run will ask for
+* — the `/BaseFont` lowercased, with the subset prefix dropped.
+*
+* Each PDF font object becomes its OWN entry rather than being folded into a
+* family: `Arial-BoldMT` is a different program from `ArialMT` and the run that
+* uses it names it exactly, so nothing has to guess at weights or match faces
+* up. A face the reader cannot parse is left out and the writer substitutes for
+* it as before.
+*
+* Only `/FontFile2` is read. A CFF program (`/FontFile3`) and a Type 1 one
+* (`/FontFile`) are different formats that the layout's parser does not take;
+* those keep their substitute.
+*
+* @param file  The owning file.
+* @param pages The pages whose fonts are wanted.
+* @returns Name → a one-face registry holding that program.
+*/
+function collectEmbeddedFonts(file, pages) {
+	const out = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	const visiting = /* @__PURE__ */ new Set();
+	const addFont = (fontDict) => {
+		if (seen.has(fontDict)) return;
+		seen.add(fontDict);
+		const name = embeddedFontName(file, fontDict);
+		if (name === void 0 || out.has(name)) return;
+		const program = fontProgram(file, fontDict);
+		if (!program) return;
+		try {
+			out.set(name, FontRegistry.fromBytes({ regular: program }));
+		} catch {}
+	};
+	const walk = (resources, depth) => {
+		if (!resources) return;
+		const fonts = file.get(resources, "Font");
+		if (fonts instanceof Map) for (const value of fonts.values()) {
+			const dict = file.resolve(value);
+			if (dict instanceof Map) addFont(dict);
+		}
+		if (depth >= MAX_FORM_DEPTH) return;
+		const xobjects = file.get(resources, "XObject");
+		if (!(xobjects instanceof Map)) return;
+		for (const value of xobjects.values()) {
+			const stream = file.resolve(value);
+			if (!(stream instanceof PdfStream) || visiting.has(stream)) continue;
+			const subtype = file.get(stream.dict, "Subtype");
+			if (!(subtype instanceof PdfName) || subtype.value !== "Form") continue;
+			visiting.add(stream);
+			const own = file.get(stream.dict, "Resources");
+			walk(own instanceof Map ? own : resources, depth + 1);
+			visiting.delete(stream);
+		}
+	};
+	for (const page of pages) walk(page.resources, 0);
+	return out;
+}
+/**
+* The name a run set in `fontDict` will ask for: its `/BaseFont` without the
+* six-capital subset prefix (§9.6.4), lowercased.
+*
+* @param file     The owning file.
+* @param fontDict A `/Font` dictionary.
+* @returns The name, or `undefined` when the font states none.
+*/
+function embeddedFontName(file, fontDict) {
+	const base = file.resolve(fontDict.get("BaseFont") ?? PDF_NULL);
+	if (!(base instanceof PdfName)) return void 0;
+	const name = base.value.replace(/^[A-Z]{6}\+/u, "").trim();
+	return name.length > 0 ? name.toLowerCase() : void 0;
+}
+/** §9.9 `/FontFile2` — the TrueType program, off the font or its descendant. */
+function fontProgram(file, fontDict) {
+	const owner = descendant(file, fontDict) ?? fontDict;
+	const descriptor = file.resolve(owner.get("FontDescriptor") ?? PDF_NULL);
+	if (!(descriptor instanceof Map)) return void 0;
+	const program = file.resolve(descriptor.get("FontFile2") ?? PDF_NULL);
+	if (!(program instanceof PdfStream)) return void 0;
+	const bytes = file.streamData(program);
+	return bytes.length > 0 ? bytes : void 0;
+}
+/** §9.7.4 — a `/Type0` font's descendant CIDFont, which owns the descriptor. */
+function descendant(file, fontDict) {
+	const list = file.resolve(fontDict.get("DescendantFonts") ?? PDF_NULL);
+	if (!Array.isArray(list)) return void 0;
+	const first = file.resolve(list[0] ?? PDF_NULL);
+	return first instanceof Map ? first : void 0;
+}
+//#endregion
+export { collectEmbeddedFonts, embeddedFontName };

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

@@ -1,5 +1,6 @@
-import { BodyElement, SectionProperties } from '../core/document-model/index.js';
+import { BodyElement, SectionProperties, TextOutline } from '../core/document-model/index.js';
 import { FlowDoc } from '../core/ir/flow.js';
+import { FontRegistry } from '../core/font/index.js';
 import { Loss, ResourceStore } from '../core/ir/index.js';
 import { PdfImage } from './images.js';
 import { PdfPage } from './document.js';
@@ -12,6 +13,20 @@ export interface Reconstruction {
     readonly doc: FlowDoc;
     readonly losses: ReadonlyArray<Loss>;
 }
+/**
+ * The corner a page's marks are measured from, in the SHOWN page's own y-up
+ * frame — see `./display`, which puts every mark into it.
+ *
+ * The shown page starts at its own origin, so `left` is zero and `top` is its
+ * height; the two are kept as a pair because a caller that has not been through
+ * `display` (none, today) would state something else.
+ */
+export interface PageFrame {
+    /** Left edge — subtract it to get an offset from the page. */
+    readonly left: number;
+    /** Top edge — subtract from it to flip into a top-down frame. */
+    readonly top: number;
+}
 /**
  * Build a paragraph {@link BodyElement} from a single plain-text string,
  * optionally at the given outline (heading) level. Empty text yields a
@@ -22,6 +37,18 @@ export declare function paragraphBlock(text: string, outlineLevel?: number): Bod
 export interface TextSpan {
     readonly text: string;
     readonly href?: string;
+    /** The size the glyphs were SHOWN at (§9.3.1 Tf), so the run keeps it. */
+    readonly sizePt?: number;
+    /** §8.6.8 — the colour they were painted in, when it is not plain black. */
+    readonly colorHex?: string;
+    /** §9.6.2 — the face's own name, for a document that embeds its programs. */
+    readonly fontName?: string;
+    /** §9.3.6 — a line round the glyphs, when the page asked for one. */
+    readonly outline?: TextOutline;
+    /** §9.8.1 — the face was a bold one. */
+    readonly bold?: boolean;
+    /** §9.8.1 — the face was a slanted one. */
+    readonly italic?: boolean;
 }
 /**
  * Build a paragraph {@link BodyElement} from positioned {@link TextSpan}s,
@@ -35,17 +62,45 @@ export declare function paragraphFromRuns(spans: ReadonlyArray<TextSpan>, outlin
  * {@link BodyElement} that references them, sized in points from the placement
  * CTM. `alt` becomes the block's alt text when given.
  */
-export declare function imageBlock(image: PdfImage, resources: ResourceStore, alt?: string): BodyElement;
+export declare function imageBlock(image: PdfImage, resources: ResourceStore, alt?: string, frame?: PageFrame, zOrder?: number): BodyElement;
+/**
+ * A line of text as an anchored box, standing where the page set it.
+ *
+ * The flowed reconstruction reads a document OUT of a page: paragraphs in
+ * reading order, re-flowable, free to land wherever the next medium puts them.
+ * A form is not that document. 160F-2019.pdf is a grid of ruled boxes with a
+ * label in each, and a label means nothing an inch from the box it labels — the
+ * artwork is placed absolutely, so text that flows beside it lines up with none
+ * of it.
+ *
+ * @param spans       The line's runs.
+ * @param box         Its page-space rectangle (y-up, as PDF measures).
+ * @param frame       The page's own corner, to measure the box off.
+ * @param zOrder      Its place in the page's painting order.
+ * @param rotation60k §20.1.7.6 — how far the box turns about its own centre,
+ *                    for a baseline the page did not set flat.
+ * @returns A shape carrying the text, anchored where the glyphs were.
+ */
+export declare function positionedText(spans: ReadonlyArray<TextSpan>, box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, frame: PageFrame, zOrder: number, rotation60k?: number): BodyElement;
 /** Collapse losses sharing a `detail` message (the same colour space dropped on many pages). */
 export declare function dedupeLosses(losses: ReadonlyArray<Loss>): Array<Loss>;
 /**
  * Turn a lifted {@link PdfVector} path (filled EP10 / stroked EP11) into a
  * custom-geometry shape {@link BodyElement}. Page-space points (y-up) become
  * path-space (bbox-relative, y-down); the shape is sized from the bounding box
- * (plus the stroke thickness) and placed in flow order by the caller. A fill
- * becomes a solid fill, a stroke becomes the outline.
+ * (plus the stroke thickness). A fill becomes a solid fill, a stroke the outline.
+ *
+ * Given the page's frame the shape is ANCHORED where the page drew it, behind
+ * the text, rather than taking a place of its own in the flow. A drawing is not
+ * a paragraph: 22060_A1_01_Plans.pdf is one A3 sheet of vectors, and stacking
+ * its forty-nine paths one under another spilled it onto a second page.
  */
-export declare function shapeBlock(v: PdfVector): BodyElement;
+export declare function shapeBlock(v: PdfVector, frame?: PageFrame, zOrder?: number): BodyElement;
 /**
  * Derive the {@link SectionProperties} geometry from the source pages so a
  * reconstructed PDF re-renders at its real page size and orientation rather than
@@ -65,4 +120,4 @@ export declare function sectionFromPdfPages(pages: ReadonlyArray<PdfPage>): Sect
  * both reconstruction paths (the tagged fast-path EP3 and the heuristic layout
  * path EP4).
  */
-export declare function buildFlowDoc(body: ReadonlyArray<BodyElement>, resources?: ResourceStore, section?: SectionProperties): FlowDoc;
+export declare function buildFlowDoc(body: ReadonlyArray<BodyElement>, resources?: ResourceStore, section?: SectionProperties, embeddedFonts?: ReadonlyMap<string, FontRegistry>): FlowDoc;