reamkit 1.26.0 → 1.27.0

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

@@ -1,11 +1,14 @@
 import { pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
-import { displayOf, placeVectors } from "./display.js";
-import { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, sectionFromPdfPages, shapeBlock } from "./flow-build.js";
+import { FEATURES } from "../core/ir/features.js";
 import { collectEmbeddedFonts } from "./embedded-fonts.js";
-import { collectPageImages } from "./images.js";
 import { extractPageText } from "./text.js";
 import { collectPageVectors } from "./vector.js";
+import { displayOf, placeRuns, placeVectors } from "./display.js";
+import { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, sectionFromPdfPages, shapeBlock, withMeasuredMargins } from "./flow-build.js";
+import { collectPageImages } from "./images.js";
+import { markDrawnRules } from "./text-rules.js";
+import { endedParagraph } from "./layout.js";
 import { readStructTree } from "./struct-tree.js";
 //#region src/pdf-reader/tagged.ts
 var ASSUMED_CONTENT_WIDTH_PT = 468;
@@ -27,9 +30,23 @@ function reconstructTaggedPdf(file) {
 	const root = readStructTree(file);
 	if (!root) return void 0;
 	const pages = file.pages();
-	const pageRuns = pages.map((page) => {
+	const shown = pages.map((page) => displayOf(page));
+	const placedRuns = pages.map((page, i) => placeRuns(extractPageText(file, page), shown[i]));
+	const vectorLosses = [];
+	const pageVectors = pages.map((page, i) => {
+		const lifted = collectPageVectors(file, page, collectPageImages(file, page).images.map((img) => ({
+			minX: img.x,
+			minY: img.y,
+			maxX: img.x + img.widthPt,
+			maxY: img.y + img.heightPt
+		})));
+		vectorLosses.push(...lifted.losses);
+		return placeVectors(lifted.vectors, shown[i]);
+	});
+	const ruled = placedRuns.map((runs, i) => markDrawnRules(runs, pageVectors[i] ?? []));
+	const pageRuns = ruled.map(({ runs }) => {
 		const byMcid = /* @__PURE__ */ new Map();
-		for (const run of extractPageText(file, page)) {
+		for (const run of runs) {
 			if (run.mcid === void 0) continue;
 			const list = byMcid.get(run.mcid);
 			if (list) list.push(run);
@@ -37,7 +54,12 @@ function reconstructTaggedPdf(file) {
 		}
 		return byMcid;
 	});
-	const runsOfMcid = (page, mcid) => pageRuns[page]?.get(mcid) ?? [];
+	const claimed = /* @__PURE__ */ new Set();
+	const runsOfMcid = (page, mcid) => {
+		const runs = pageRuns[page]?.get(mcid) ?? [];
+		for (const run of runs) claimed.add(run);
+		return runs;
+	};
 	const resources = new ResourceStore();
 	const pageImages = pages.map((page) => collectPageImages(file, page));
 	const imageLosses = dedupeLosses(pageImages.flatMap((p) => p.losses));
@@ -58,23 +80,123 @@ function reconstructTaggedPdf(file) {
 		const spans = [];
 		node.mcids.forEach(({ page, mcid }, i) => {
 			if (i > 0) spans.push({ text: " " });
-			for (const run of runsOfMcid(page, mcid)) spans.push({
-				text: run.text,
-				sizePt: run.fontSizePt,
-				...run.colorHex !== "000000" ? { colorHex: run.colorHex } : {},
-				...run.fontName !== void 0 ? { fontName: run.fontName } : {},
-				...run.outlineHex !== void 0 ? { outline: {
-					colorHex: run.outlineHex,
-					widthPt: pt(run.outlineWidthPt ?? 1)
-				} } : {},
-				...run.bold ? { bold: true } : {},
-				...run.italic ? { italic: true } : {},
-				...run.href !== void 0 ? { href: run.href } : {}
-			});
+			for (const run of runsOfMcid(page, mcid)) spans.push(spanOf(run));
 		});
 		return spans;
 	};
+	/** One run as the span that carries everything the page showed it with. */
+	const spanOf = (run) => ({
+		text: run.text.replaceAll("�", ""),
+		sizePt: run.fontSizePt,
+		...run.colorHex !== "000000" ? { colorHex: run.colorHex } : {},
+		...run.fontName !== void 0 ? { fontName: run.fontName } : {},
+		...run.outlineHex !== void 0 ? { outline: {
+			colorHex: run.outlineHex,
+			widthPt: pt(run.outlineWidthPt ?? 1)
+		} } : {},
+		...run.bold ? { bold: true } : {},
+		...run.italic ? { italic: true } : {},
+		...run.markup !== void 0 ? { markup: run.markup } : {},
+		...run.href !== void 0 ? { href: run.href } : {}
+	});
 	const collectText = (node) => squash([textOf(node), ...node.children.map(collectText)].join(" "));
+	const setting = /* @__PURE__ */ new Map();
+	/** The topmost and bottommost baseline under a node, and its largest face. */
+	function baselinesOf(node) {
+		let top;
+		let bottom;
+		let size = 0;
+		const visit = (n) => {
+			for (const { page, mcid } of n.mcids) for (const run of runsOfMcid(page, mcid)) {
+				if (top === void 0 || run.y > top) top = run.y;
+				if (bottom === void 0 || run.y < bottom) bottom = run.y;
+				if (run.fontSizePt > size) size = run.fontSizePt;
+			}
+			for (const child of n.children) visit(child);
+		};
+		visit(node);
+		return top !== void 0 && bottom !== void 0 && size > 0 ? {
+			top,
+			bottom,
+			size
+		} : void 0;
+	}
+	/**
+	* The element's own lines, gathered into the paragraphs they were SET as.
+	*
+	* A tree names elements, not lines, and a producer may put a whole page under
+	* one: annotation-underline.pdf marks every glyph on its page with the same
+	* id, so a heading, a blank line and a body line came back as one paragraph
+	* and re-wrapped into a single run-together line. The page still says where
+	* one ended — a line stopping well short of the measure stopped because its
+	* author stopped it — and that is the rule the heuristic reading already uses
+	* ({@link endedParagraph}). A properly tagged paragraph's inner lines all
+	* reach the measure, so nothing there changes.
+	*/
+	function settingsOf(node) {
+		const spans = spansOf(node);
+		const lines = linesOf(node);
+		if (lines.length < 2) {
+			const set = baselinesOf(node);
+			return set ? [{
+				spans,
+				set
+			}] : [];
+		}
+		const measure = {
+			left: Math.min(...lines.map((l) => l.x)),
+			right: Math.max(...lines.map((l) => l.x + l.width))
+		};
+		const groups = [];
+		let prev;
+		for (const line of lines) {
+			const gap = prev === void 0 ? 0 : prev.y - line.y;
+			const opened = prev !== void 0 && gap > line.fontSize * 1.5;
+			if (groups.length === 0 || opened || prev && endedParagraph(prev, line, measure)) groups.push([]);
+			groups[groups.length - 1].push(line);
+			prev = line;
+		}
+		return groups.map((g) => ({
+			spans: g.flatMap((l, i) => i > 0 ? [{ text: " " }, ...l.spans] : [...l.spans]),
+			set: {
+				top: g[0].y,
+				bottom: g[g.length - 1].y,
+				size: Math.max(...g.map((l) => l.fontSize))
+			}
+		}));
+	}
+	/** The node's runs clustered onto the baselines they were shown on. */
+	function linesOf(node) {
+		const rows = [];
+		const visit = (n) => {
+			for (const { page, mcid } of n.mcids) for (const run of runsOfMcid(page, mcid)) {
+				if (run.angleDeg !== void 0) return;
+				const row = rows.find((r) => Math.abs(r.y - run.y) <= Math.max(r.size, run.fontSizePt) * .5);
+				if (row) {
+					row.runs.push(run);
+					row.size = Math.max(row.size, run.fontSizePt);
+					row.y = Math.min(row.y, run.y);
+				} else rows.push({
+					y: run.y,
+					size: run.fontSizePt,
+					runs: [run]
+				});
+			}
+			for (const child of n.children) visit(child);
+		};
+		visit(node);
+		return rows.sort((a, b) => b.y - a.y).map(({ y, runs }) => {
+			const ordered = [...runs].sort((a, b) => a.x - b.x);
+			const x = Math.min(...ordered.map((r) => r.x));
+			return {
+				y,
+				x,
+				width: Math.max(...ordered.map((r) => r.endX)) - x,
+				fontSize: Math.max(...ordered.map((r) => r.fontSizePt)),
+				spans: ordered.map((r) => spanOf(r))
+			};
+		}).filter((l) => l.spans.some((sp) => sp.text.trim().length > 0));
+	}
 	function emit(node, out) {
 		if (node.type === "Table") {
 			const table = buildTable(node);
@@ -94,7 +216,11 @@ function reconstructTaggedPdf(file) {
 			return;
 		}
 		if (node.children.length === 0) {
-			if (textOf(node).length > 0) out.push(paragraphFromRuns(spansOf(node), headingLevel(node.type)));
+			if (textOf(node).length > 0) for (const part of settingsOf(node)) {
+				const el = paragraphFromRuns(part.spans, headingLevel(node.type));
+				setting.set(el, part.set);
+				out.push(el);
+			}
 			return;
 		}
 		for (const child of node.children) emit(child, out);
@@ -164,21 +290,19 @@ function reconstructTaggedPdf(file) {
 	}
 	const body = [];
 	emit(root, body);
+	spaceParagraphs(body, setting, shown[0]?.height ?? 0);
 	let zOrder = -1e6;
-	pages.forEach((page, index) => {
-		const display = displayOf(page);
+	imageLosses.push(...vectorLosses);
+	pages.forEach((_page, index) => {
 		const frame = {
 			left: 0,
-			top: display.height
+			top: shown[index].height
 		};
-		const lifted = collectPageVectors(file, page, (pageImages[index]?.images ?? []).map((img) => ({
-			minX: img.x,
-			minY: img.y,
-			maxX: img.x + img.widthPt,
-			maxY: img.y + img.heightPt
-		})));
-		imageLosses.push(...lifted.losses);
-		for (const v of placeVectors(lifted.vectors, display)) body.push(shapeBlock(v, frame, zOrder++));
+		const taken = ruled[index]?.consumed;
+		for (const v of pageVectors[index] ?? []) {
+			if (taken?.has(v) === true) continue;
+			body.push(shapeBlock(v, frame, zOrder++, true));
+		}
 	});
 	const orphans = [];
 	pageImages.forEach((p, page) => {
@@ -190,8 +314,16 @@ function reconstructTaggedPdf(file) {
 	orphans.sort((a, b) => a.page - b.page || b.img.y - a.img.y);
 	for (const { img } of orphans) body.push(imageBlock(img, resources));
 	if (body.length === 0) return void 0;
+	if (placedRuns.some((page) => page.some((r) => r.text.includes("�")))) imageLosses.push({
+		severity: "dropped",
+		feature: FEATURES.text,
+		detail: "some glyphs map to no character — the font states no /ToUnicode and its program says nothing either, so that text is unrecoverable"
+	});
+	const onPage = placedRuns.flat().reduce((n, r) => n + r.text.length, 0);
+	const reached = [...claimed].reduce((n, r) => n + r.text.length, 0);
+	if (onPage > 0 && reached * 2 < onPage) return void 0;
 	return {
-		doc: buildFlowDoc(body, resources, sectionFromPdfPages(pages), collectEmbeddedFonts(file, pages)),
+		doc: buildFlowDoc(body, resources, withMeasuredMargins(sectionFromPdfPages(pages), shown, placedRuns), collectEmbeddedFonts(file, pages, imageLosses)),
 		losses: imageLosses
 	};
 }
@@ -289,5 +421,45 @@ function headingLevel(type) {
 	const m = /^H([1-6])$/.exec(type);
 	return m ? Number(m[1]) - 1 : void 0;
 }
+/**
+* §17.3.1.33 `w:spacing` — the space the SOURCE left before each paragraph.
+*
+* A structure tree names the words and says nothing about how far apart they
+* stood, so every tagged PDF came back at one flat leading: on
+* annotation-polyline-polygon-without-appearance.pdf the two labels, set a
+* third of a page apart above their own drawings, arrived as two lines
+* touching. The page still says it — the gap between the last baseline of one
+* paragraph and the first of the next, less the line it would have taken
+* anyway. This is the rule the heuristic reading already uses, applied to the
+* paragraphs the tree named.
+*
+* @param body       The body elements, in order; amended in place.
+* @param setting    Where each paragraph was set, for those that were.
+* @param pageHeight The shown page's height, which bounds any one gap.
+*/
+function spaceParagraphs(body, setting, pageHeight) {
+	let prev;
+	body.forEach((el, i) => {
+		const here = setting.get(el);
+		if (!here) return;
+		const gap = prev !== void 0 ? prev.bottom - here.top : 0;
+		prev = here;
+		if (!(gap > 0)) return;
+		const opened = gap - here.size * 1.2;
+		if (!(opened > here.size * .3)) return;
+		if (el.kind !== "paragraph") return;
+		const most = pageHeight > 0 ? pageHeight / 3 : here.size * 3;
+		body[i] = {
+			...el,
+			paragraph: {
+				...el.paragraph,
+				properties: {
+					...el.paragraph.properties,
+					spacingBefore: pt(Math.min(opened, most))
+				}
+			}
+		};
+	});
+}
 //#endregion
 export { reconstructTaggedPdf };

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

@@ -0,0 +1,16 @@
+import { TextRun } from './content.js';
+import { PdfVector } from './vector.js';
+/** The runs with their drawn rules read onto them, and the rules so read. */
+export interface DrawnRules {
+    readonly runs: Array<TextRun>;
+    /** The vectors the runs took over: painting them again would double them. */
+    readonly consumed: ReadonlySet<PdfVector>;
+}
+/**
+ * Read the underlines and strikeouts a page DREW onto the runs they mark.
+ *
+ * @param runs    The page's runs, placed on the shown page.
+ * @param vectors The page's lifted paths, placed the same way.
+ * @returns The runs, marked; and the paths that became those marks.
+ */
+export declare function markDrawnRules(runs: ReadonlyArray<TextRun>, vectors: ReadonlyArray<PdfVector>): DrawnRules;

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

@@ -0,0 +1,112 @@
+//#region src/pdf-reader/text-rules.ts
+/** A rule no thicker than this is a line under words, not a box. */
+var THICKEST_PT = 2;
+/** …and no thinner than this: below it the page drew a seam, not a mark. */
+var THINNEST_PT = .2;
+/** …or than this fraction of the face it underlines, for a large one. */
+var THICKEST_EM = .09;
+/** How much of a run's advance a rule must cover to be that run's own. */
+var COVERS = .6;
+/**
+* How far past the words it may run, in points, before it is a rule about
+* something else.
+*
+* An underline begins and ends with the words it underlines; a table's cell
+* border begins at the CELL, which is the text's own edge less the padding, and
+* ends at the cell's other edge however short the text stops. TAMReview.pdf's
+* tables are ruled 86.2 to 509.0 across a measure whose text stops well before
+* it, and a proportional allowance let every one of them through.
+*/
+var OVERHANG_PT = 2;
+/** An underline sits within this fraction of the size below the baseline. */
+var UNDER_EM = .35;
+/** A strikeout crosses between these fractions of the size ABOVE it. */
+var STRIKE_LOW = .15;
+var STRIKE_HIGH = .5;
+/**
+* Read the underlines and strikeouts a page DREW onto the runs they mark.
+*
+* @param runs    The page's runs, placed on the shown page.
+* @param vectors The page's lifted paths, placed the same way.
+* @returns The runs, marked; and the paths that became those marks.
+*/
+function markDrawnRules(runs, vectors) {
+	const marks = /* @__PURE__ */ new Map();
+	const consumed = /* @__PURE__ */ new Set();
+	for (const v of vectors) {
+		if (!isRule(v)) continue;
+		const under = coveredRuns(runs, v, "under");
+		const through = under.length > 0 ? [] : coveredRuns(runs, v, "through");
+		const hit = under.length > 0 ? under : through;
+		if (hit.length === 0) continue;
+		const left = Math.min(...hit.map((r) => Math.min(r.x, r.endX)));
+		const right = Math.max(...hit.map((r) => Math.max(r.x, r.endX)));
+		if (!(right - left > 0)) continue;
+		if (left - v.minX > OVERHANG_PT || v.maxX - right > OVERHANG_PT) continue;
+		for (const run of hit) {
+			const had = marks.get(run) ?? {};
+			marks.set(run, under.length > 0 && v.fillHex !== void 0 ? {
+				...had,
+				underline: v.fillHex
+			} : {
+				...had,
+				strike: true
+			});
+		}
+		consumed.add(v);
+	}
+	if (marks.size === 0) return {
+		runs: [...runs],
+		consumed
+	};
+	return {
+		runs: runs.map((run) => {
+			const mark = marks.get(run);
+			if (!mark) return run;
+			return {
+				...run,
+				markup: {
+					...run.markup,
+					...mark.underline !== void 0 && run.markup?.underline === void 0 ? {
+						underline: "single",
+						underlineHex: mark.underline
+					} : {},
+					...mark.strike === true ? { strike: true } : {}
+				}
+			};
+		}),
+		consumed
+	};
+}
+/** A thin filled bar, which is the only shape an underline is drawn as. */
+function isRule(v) {
+	if (v.fillHex === void 0 || v.strokeHex !== void 0 || v.gradient !== void 0) return false;
+	if (v.fillHex === "FFFFFF") return false;
+	const h = v.maxY - v.minY;
+	const w = v.maxX - v.minX;
+	return h >= THINNEST_PT && h <= THICKEST_PT && w > 2;
+}
+/**
+* The runs a rule marks: on one baseline, covered along their advance, and at
+* the offset from that baseline the mark is drawn at.
+*/
+function coveredRuns(runs, v, where) {
+	const out = [];
+	const mid = (v.minY + v.maxY) / 2;
+	for (const run of runs) {
+		const size = run.fontSizePt;
+		if (!(size > 0) || run.angleDeg !== void 0) continue;
+		if (v.maxY - v.minY > Math.max(THICKEST_PT, size * THICKEST_EM)) continue;
+		const below = run.y - mid;
+		if (!(where === "under" ? below > 0 && below < size * UNDER_EM : below < -size * STRIKE_LOW && below > -size * STRIKE_HIGH)) continue;
+		const left = Math.min(run.x, run.endX);
+		const right = Math.max(run.x, run.endX);
+		const advance = right - left;
+		if (!(advance > 0)) continue;
+		if (Math.min(right, v.maxX) - Math.max(left, v.minX) < advance * COVERS) continue;
+		out.push(run);
+	}
+	return out;
+}
+//#endregion
+export { markDrawnRules };

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

@@ -1,6 +1,8 @@
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
 import { IDENTITY, interpretContent, multiply } from "./content.js";
+import { textMarkupOf } from "./annot-draw.js";
 import { collectPageAppearances } from "./annots.js";
+import { hiddenProperties, hiddenXObject } from "./optional-content.js";
 import { buildContentFont } from "./font.js";
 import { patternTint } from "./pattern-tint.js";
 //#region src/pdf-reader/text.ts
@@ -21,17 +23,88 @@ function extractPageText(file, page) {
 	collectRuns(file, page.resources, file.pageContent(page), IDENTITY, 0, /* @__PURE__ */ new Set(), runs);
 	for (const appearance of collectPageAppearances(file, page)) collectRuns(file, appearance.resources ?? page.resources, file.streamData(appearance.stream), appearance.ctm, 1, new Set([appearance.stream]), runs);
 	const links = collectLinks(file, page);
-	if (links.length === 0) return runs;
-	return runs.map((run) => {
+	const marks = collectTextMarkup(file, page);
+	if (links.length === 0 && marks.length === 0) return runs;
+	return runs.flatMap((run) => {
 		const link = links.find((l) => inRect(run.x, run.y, l.rect));
-		return link ? {
+		const linked = link ? {
 			...run,
 			href: link.href
 		} : run;
+		const marked = marks.find((m) => m.quads.some((q) => touches(q, linked)));
+		if (!marked) return [linked];
+		const quad = marked.quads.find((q) => touches(q, linked));
+		return quad ? markedPieces(linked, quad, marked.mark) : [linked];
 	});
 }
+/**
+* §12.5.6.10 — whether a marked quad reaches this run at all.
+*
+* The quad is a box round a run of text and the run is a baseline with an
+* advance, so the test is the baseline falling inside the box's height while
+* the two overlap horizontally by more than a hair.
+*/
+function touches(q, run) {
+	if (run.y < q.y0 || run.y > q.y0 + q.h) return false;
+	const left = Math.min(run.x, run.endX);
+	const right = Math.max(run.x, run.endX);
+	return Math.min(right, q.x1) - Math.max(left, q.x0) > .5;
+}
+/**
+* The run cut at the quad's edges, so only what the quad covers is marked.
+*
+* A quad round ONE WORD of a line must not claim the line: highlight_popup.pdf
+* marks "PDF.js" in "Hello PDF.js World", which is one run, and the whole line
+* came back highlighted. The run states its advance and its text and not where
+* each glyph fell inside it, so the cut is made by proportion of the advance —
+* a word off by a fraction of a letter where the face is proportional, against
+* a line marked entirely wrongly.
+*/
+function markedPieces(run, q, mark) {
+	const left = Math.min(run.x, run.endX);
+	const advance = Math.max(run.x, run.endX) - left;
+	const chars = [...run.text];
+	if (!(advance > 0) || chars.length === 0) return [{
+		...run,
+		markup: mark
+	}];
+	const at = (x) => Math.max(0, Math.min(chars.length, Math.round((x - left) / advance * chars.length)));
+	const from = at(q.x0);
+	const to = at(q.x1);
+	if (from <= 0 && to >= chars.length) return [{
+		...run,
+		markup: mark
+	}];
+	if (to <= from) return [run];
+	const per = advance / chars.length;
+	const piece = (a, b, marked) => ({
+		...run,
+		text: chars.slice(a, b).join(""),
+		x: left + a * per,
+		endX: left + b * per,
+		...marked ? { markup: mark } : {}
+	});
+	return [
+		...from > 0 ? [piece(0, from, false)] : [],
+		piece(from, to, true),
+		...to < chars.length ? [piece(to, chars.length, false)] : []
+	];
+}
+/** Every text-markup annotation on the page, with the boxes it marks. */
+function collectTextMarkup(file, page) {
+	const annots = file.get(page.dict, "Annots");
+	if (!Array.isArray(annots)) return [];
+	const out = [];
+	for (const entry of annots) {
+		const annot = file.resolve(entry);
+		if (!(annot instanceof Map)) continue;
+		const mark = textMarkupOf(file, annot);
+		if (mark) out.push(mark);
+	}
+	return out;
+}
 function collectRuns(file, resources, content, baseCtm, depth, visiting, out) {
-	const result = interpretContent(content, buildFonts(file, resources), baseCtm);
+	const result = interpretContent(content, buildFonts(file, resources), baseCtm, void 0, void 0, void 0, hiddenProperties(file, resources));
 	out.push(...result.texts.map((r) => withPatternColour(file, resources, r, visiting)));
 	if (depth >= MAX_FORM_DEPTH) return;
 	for (const glyph of result.glyphs) {
@@ -46,6 +119,7 @@ function collectRuns(file, resources, content, baseCtm, depth, visiting, out) {
 	for (const placement of result.images) {
 		const stream = file.resolve(xobjects.get(placement.name) ?? PDF_NULL);
 		if (!(stream instanceof PdfStream) || visiting.has(stream)) continue;
+		if (hiddenXObject(file, stream)) continue;
 		const sub = file.get(stream.dict, "Subtype");
 		if (!(sub instanceof PdfName) || sub.value !== "Form") continue;
 		visiting.add(stream);

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

@@ -24,6 +24,11 @@ export interface PdfVector {
     readonly gradient?: ShapeGradient;
     /** §11.6.4.4 — how opaque the fill is, when the page asked for less than all. */
     readonly alpha?: number;
+    /**
+     * §11.3.5 — the fill only DARKENS what it covers, so the marks under it read
+     * through. A highlighter is this, and nothing on a page reads it as paint.
+     */
+    readonly darkens?: boolean;
     /** Present iff a qualifying stroke survived (EP11). */
     readonly strokeHex?: string;
     /** Stroke width in page-space points (EP11). */

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

@@ -1,30 +1,32 @@
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
 import { FEATURES } from "../core/ir/features.js";
 import { IDENTITY, interpretContent, multiply } from "./content.js";
+import { buildAlphaMap, buildColorSpaceMap, buildShadingMap } from "./shading.js";
 import { collectPageAppearances } from "./annots.js";
+import { hiddenProperties, hiddenXObject } from "./optional-content.js";
 import { buildFonts } from "./text.js";
-import { buildAlphaMap, buildColorSpaceMap, buildShadingMap } from "./shading.js";
 //#region src/pdf-reader/vector.ts
-/**
-* Every vector the page paints, its FORM XOBJECTS included (§8.8).
-*
-* A `Do` of a form is a call: its content stream draws in the caller's space
-* through the form's own `/Matrix`. Interpreting the page stream alone reads
-* only what the page drew directly, and a document that puts its artwork in
-* forms — as every CAD and drawing producer does — comes back with none of it.
-* 22060_A1_01_Plans.pdf holds eleven, and its floor plans were simply absent.
-*
-* The same walk `collectPageImages` already makes, with the same depth and
-* cycle guards, collecting paths instead of pictures.
-*/
-function paintedVectors(file, page, shadings, alphas, spaces) {
+function paintedVectors(file, page) {
 	const out = [];
 	const visiting = /* @__PURE__ */ new Set();
+	const stateCache = /* @__PURE__ */ new Map();
+	const mapsOf = (resources) => {
+		const had = stateCache.get(resources);
+		if (had) return had;
+		const made = {
+			shadings: buildShadingMap(file, resources),
+			alphas: buildAlphaMap(file, resources),
+			spaces: buildColorSpaceMap(file, resources)
+		};
+		stateCache.set(resources, made);
+		return made;
+	};
 	const walk = (resources, content, baseCtm, depth, prefix) => {
 		if (out.length >= MAX_VECTORS) return;
 		const xobjects = resources ? file.get(resources, "XObject") : PDF_NULL;
 		const xobjDict = xobjects instanceof Map ? xobjects : void 0;
-		const result = interpretContent(content, buildFonts(file, resources), baseCtm, shadings, alphas, spaces);
+		const maps = mapsOf(resources);
+		const result = interpretContent(content, buildFonts(file, resources), baseCtm, maps.shadings, maps.alphas, maps.spaces, hiddenProperties(file, resources));
 		const events = [
 			...result.vectors.map((vector) => ({
 				order: vector.order,
@@ -60,6 +62,7 @@ function paintedVectors(file, page, shadings, alphas, spaces) {
 			if (depth >= MAX_FORM_DEPTH) continue;
 			const stream = xobjDict ? file.resolve(xobjDict.get(placement.name) ?? PDF_NULL) : PDF_NULL;
 			if (!(stream instanceof PdfStream) || visiting.has(stream)) continue;
+			if (hiddenXObject(file, stream)) continue;
 			const subtype = file.get(stream.dict, "Subtype");
 			if (!(subtype instanceof PdfName) || subtype.value !== "Form") continue;
 			visiting.add(stream);
@@ -116,14 +119,22 @@ var MAX_FORM_DEPTH = 12;
 * clutter. Clips and the bare `sh` operator are not captured (a documented loss).
 */
 function collectPageVectors(file, page, occupied = []) {
-	const [px0, py0, px1, py1] = page.mediaBox;
+	const [px0, py0, px1, py1] = page.cropBox;
 	const pageArea = Math.max(1, Math.abs((px1 - px0) * (py1 - py0)));
-	const shadings = buildShadingMap(file, page);
-	const alphas = buildAlphaMap(file, page);
-	const spaces = buildColorSpaceMap(file, page);
 	const out = [];
 	const painted = [...occupied];
-	const raws = paintedVectors(file, page, shadings, alphas, spaces);
+	const raws = paintedVectors(file, page);
+	const losses = [];
+	const asked = /* @__PURE__ */ new Set();
+	for (const raw of raws) {
+		if (raw.masked === true) asked.add("PDF soft mask (/SMask in the graphics state) is not applied; the shape is drawn at full opacity throughout");
+		if (raw.blend !== void 0) asked.add(`PDF blend mode /${raw.blend} is not performed; the shape is drawn over what it was to blend with`);
+	}
+	for (const detail of asked) losses.push({
+		severity: "degraded",
+		feature: FEATURES.images,
+		detail
+	});
 	for (const raw of raws) {
 		if (out.length >= MAX_VECTORS) break;
 		const v = clipped(raw);
@@ -139,7 +150,7 @@ function collectPageVectors(file, page, occupied = []) {
 		const short = Math.min(w, h);
 		const isBox = short >= MIN_SIDE && area >= MIN_AREA;
 		const isRule = long >= MIN_RULE_LEN && short > 0;
-		const filled = (v.gradient !== void 0 || solidFill) && (isBox || isRule) && area <= .85 * pageArea;
+		const filled = (v.gradient !== void 0 || solidFill) && (isBox || isRule);
 		const stroked = v.strokeHex !== void 0 && (v.strokeHex !== "FFFFFF" || painted.some((box) => overlaps(box, b))) && Math.max(w, h) >= MIN_STROKE_LEN && area <= .85 * pageArea;
 		if (!filled && !stroked) continue;
 		painted.push(b);
@@ -148,6 +159,7 @@ function collectPageVectors(file, page, occupied = []) {
 			segs: v.segs,
 			...filled ? v.gradient ? { gradient: v.gradient } : v.fillHex !== void 0 ? { fillHex: v.fillHex } : {} : {},
 			...filled && v.alpha !== void 0 ? { alpha: v.alpha } : {},
+			...filled && v.darkens === true ? { darkens: true } : {},
 			...stroked ? {
 				strokeHex: v.strokeHex,
 				...v.lineWidth !== void 0 ? { lineWidth: v.lineWidth } : {}
@@ -156,13 +168,14 @@ function collectPageVectors(file, page, occupied = []) {
 			...v.mcid !== void 0 ? { mcid: v.mcid } : {}
 		});
 	}
+	if (out.length >= MAX_VECTORS || raws.length >= MAX_VECTORS) losses.push({
+		severity: "dropped",
+		feature: FEATURES.shapes,
+		detail: `page carries more than ${String(MAX_VECTORS)} painted paths; the rest were not read`
+	});
 	return {
 		vectors: out,
-		losses: out.length >= MAX_VECTORS || raws.length >= MAX_VECTORS ? [{
-			severity: "dropped",
-			feature: FEATURES.shapes,
-			detail: `page carries more than ${String(MAX_VECTORS)} painted paths; the rest were not read`
-		}] : []
+		losses
 	};
 }
 /** Whether two boxes share any area at all. */