reamkit 1.26.0 → 1.28.0

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

@@ -0,0 +1,185 @@
+//#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 { rule: v, parts } of joinRules(vectors)) {
+		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) ?? {};
+			const hex = ruleHex(v);
+			marks.set(run, under.length > 0 && hex !== void 0 ? {
+				...had,
+				underline: hex
+			} : {
+				...had,
+				strike: true
+			});
+		}
+		for (const part of parts) consumed.add(part);
+	}
+	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
+	};
+}
+/** Two segments this far apart are still one line: a word space, no more. */
+var JOIN_PT = 6;
+/** Two segments within this of each other sit at the same height. */
+var SAME_HEIGHT_PT = .5;
+/**
+* The rules, with the ones a page drew in PIECES joined back into one.
+*
+* An underline is a mark about a phrase, but a producer may stroke it a word at
+* a time: TAMReview.pdf draws its copyright licence as six segments end to end.
+* Matched one by one none of them covers enough of the long run it belongs to,
+* so each was rejected and the phrase came back unmarked.
+*
+* Joined only along a straight, level line, with no more than a word space
+* between the pieces — which is what a broken underline is and what a row of
+* separate table rules is not.
+*/
+function joinRules(vectors) {
+	const rules = vectors.filter((v) => isRule(v));
+	const byRow = /* @__PURE__ */ new Map();
+	for (const v of rules) {
+		const mid = (v.minY + v.maxY) / 2;
+		const key = `${ruleHex(v) ?? ""}@${String(Math.round(mid / SAME_HEIGHT_PT))}`;
+		const row = byRow.get(key);
+		if (row) row.push(v);
+		else byRow.set(key, [v]);
+	}
+	const out = [];
+	for (const row of byRow.values()) {
+		row.sort((a, b) => a.minX - b.minX);
+		let run = [];
+		const flush = () => {
+			if (run.length === 0) return;
+			const first = run[0];
+			out.push({
+				rule: {
+					...first,
+					minX: Math.min(...run.map((v) => v.minX)),
+					maxX: Math.max(...run.map((v) => v.maxX)),
+					minY: Math.min(...run.map((v) => v.minY)),
+					maxY: Math.max(...run.map((v) => v.maxY))
+				},
+				parts: run
+			});
+			run = [];
+		};
+		for (const v of row) {
+			const last = run[run.length - 1];
+			if (last && v.minX - last.maxX > JOIN_PT) flush();
+			run.push(v);
+		}
+		flush();
+	}
+	return out;
+}
+/**
+* A thin bar under words — filled OR stroked.
+*
+* A page draws an underline either way, and the stroked one is the commoner:
+* TAMReview.pdf strokes its copyright licence with six zero-height segments,
+* one per word. Read as a filled bar only, none of them was a mark at all —
+* they stayed artwork, and when the words re-set the artwork stayed where it
+* was drawn and came back crossing the line it should have sat under.
+*/
+function isRule(v) {
+	if (v.gradient !== void 0) return false;
+	const stroked = v.strokeHex !== void 0 && v.fillHex === void 0;
+	const colour = stroked ? v.strokeHex : v.fillHex;
+	if (colour === void 0) return false;
+	if (colour === "FFFFFF") return false;
+	if (v.maxX - v.minX <= 2) return false;
+	if (stroked) {
+		if (v.maxY - v.minY > THICKEST_PT) return false;
+		return (v.lineWidth ?? 1) <= THICKEST_PT;
+	}
+	const h = v.maxY - v.minY;
+	return h >= THINNEST_PT && h <= THICKEST_PT;
+}
+/** The colour a rule marks in, whichever way the page drew it. */
+function ruleHex(v) {
+	return v.fillHex ?? v.strokeHex;
+}
+/**
+* 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,9 @@
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { buildColorSpaceMap, buildShadingMap } from "./shading.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 +24,166 @@ 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);
+	const shown = withoutRestrikes(runs);
+	if (links.length === 0 && marks.length === 0) return shown;
+	return shown.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;
+}
+/**
+* §9.4.3 — the same text struck again in the same place, dropped.
+*
+* A page with no bold face to hand fakes one by drawing its text several times
+* a fraction of a point apart, and every copy is a run of its own.
+* bug900822.pdf draws one line FOUR times — twice 0.16pt apart across, twice
+* 0.32pt apart down — and read as four lines its letters came back interleaved:
+* "TTTTeeeesssstttt" where the page shows "Test test".
+*
+* A copy is a run with the SAME text and size within a small fraction of an em
+* of another. That is well inside the advance of even the narrowest letter, so
+* a word that really does repeat a character is never mistaken for one. The
+* LAST copy is the one kept: it is the one painted on top.
+*
+* The extra strikes are not read as WEIGHT. It is tempting — the offset is
+* exactly how a face with no bold cut is emboldened — but two strikes a tenth
+* of a point apart are a hair of ink and not a bold face:
+* issue11150_reduced.pdf strikes each of its three letters twice and every
+* renderer shows them at the weight of the text around them.
+*
+* @param runs The page's runs, in painting order.
+* @returns The runs a reader sees, each drawn once.
+*/
+function withoutRestrikes(runs) {
+	const kept = /* @__PURE__ */ new Map();
+	const out = [];
+	for (const run of runs) {
+		if (run.text.length === 0) {
+			out.push(run);
+			continue;
+		}
+		const tol = Math.max((run.fontSizePt || 10) * RESTRIKE_EM, .05);
+		const cell = (x, y) => `${run.text}|${run.fontSizePt.toFixed(1)}|${String(Math.round(x / tol))}|${String(Math.round(y / tol))}`;
+		let at = -1;
+		for (const dx of [
+			-1,
+			0,
+			1
+		]) for (const dy of [
+			-1,
+			0,
+			1
+		]) {
+			const had = kept.get(cell(run.x + dx * tol, run.y + dy * tol));
+			if (had !== void 0) at = had;
+		}
+		if (at >= 0) {
+			out[at] = run;
+			kept.set(cell(run.x, run.y), at);
+			continue;
+		}
+		kept.set(cell(run.x, run.y), out.length);
+		out.push(run);
+	}
+	return out;
+}
+/** How near, in ems, a re-strike of the same text lands to the one it thickens. */
+var RESTRIKE_EM = .08;
+var spaceCache = /* @__PURE__ */ new WeakMap();
+/** The page's shading patterns, read once per resource dictionary. */
+var shadingCache = /* @__PURE__ */ new WeakMap();
+function shadingsOf(file, resources) {
+	if (!resources) return /* @__PURE__ */ new Map();
+	const had = shadingCache.get(resources);
+	if (had) return had;
+	const made = buildShadingMap(file, resources);
+	shadingCache.set(resources, made);
+	return made;
+}
+function spacesOf(file, resources) {
+	if (!resources) return /* @__PURE__ */ new Map();
+	const had = spaceCache.get(resources);
+	if (had) return had;
+	const made = buildColorSpaceMap(file, resources);
+	spaceCache.set(resources, made);
+	return made;
+}
 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, shadingsOf(file, resources), void 0, spacesOf(file, resources), 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 +198,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/type1-outline.d.ts

@@ -0,0 +1,21 @@
+import { PathSeg } from './content.js';
+/** What an embedded Type 1 program says about its glyphs. */
+export interface Type1Font {
+    /** The contours of one glyph, by NAME — a Type 1 font indexes by nothing else. */
+    readonly path: (name: string) => Array<PathSeg> | undefined;
+    /**
+     * Whether the program holds a glyph of that name at all. One it holds which
+     * draws nothing is a BLANK glyph — a space — and not one it lacks.
+     */
+    readonly has: (name: string) => boolean;
+    /** The program's own `/Encoding`: code → glyph name, where it states one. */
+    readonly encoding?: ReadonlyMap<number, string>;
+}
+/**
+ * Read an embedded Type 1 program.
+ *
+ * @param program The raw `/FontFile` bytes — the cleartext header, the
+ *                `eexec`-encrypted body, and the trailing zeros.
+ * @returns A reader, or `undefined` where the program cannot be read.
+ */
+export declare function type1Font(program: Uint8Array): Type1Font | undefined;