reamkit 1.27.0 → 1.28.0

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

@@ -1,4 +1,6 @@
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { cieToSrgb } from "./cie-color.js";
+import { iccTransform } from "./icc.js";
 import { readFunction } from "./function.js";
 //#region src/pdf-reader/shading.ts
 /**
@@ -29,10 +31,34 @@ function buildShadingMap(file, resources) {
 	}
 	return out;
 }
+/**
+* §8.7.4.5.2 — an axial or radial shading as a gradient, for a bare `sh`.
+*
+* A `sh` paints the CLIP rather than a path, so what it needs is not a fill for
+* a shape the page drew but the gradient itself, to fill the region with. It is
+* the same reading `buildShadingMap` does for a pattern.
+*
+* @param file The owning file.
+* @param sh   The shading dictionary.
+* @returns The gradient, or `undefined` for a type this does not read.
+*/
+function gradientShading(file, sh) {
+	return parseShading(file, sh);
+}
+/**
+* §8.7.4.5 — which kind of shading this is, as the file states it.
+*
+* @param file The owning file.
+* @param sh   The shading dictionary.
+* @returns Its `/ShadingType`, or 0 where the file states none.
+*/
+function shadingTypeOf(file, sh) {
+	return numOf(file.get(sh, "ShadingType"));
+}
 function parseShading(file, sh) {
 	const type = numOf(file.get(sh, "ShadingType"));
 	if (type !== 2 && type !== 3) return void 0;
-	const stops = parseFunction(file, sh.get("Function"));
+	const stops = parseFunction(file, sh.get("Function"), shadingSpace(file, sh));
 	if (!stops || stops.length === 0) return void 0;
 	if (type === 3) return {
 		kind: "radial",
@@ -45,14 +71,14 @@ function parseShading(file, sh) {
 		stops
 	};
 }
-function parseFunction(file, value) {
+function parseFunction(file, value, space) {
 	const resolved = value !== void 0 ? file.resolve(value) : void 0;
 	const dict = dictOf(resolved);
 	if (!dict) return void 0;
 	const type = numOf(file.get(dict, "FunctionType"));
 	if (type === 2) {
-		const c0 = colorOf(numArray(file, dict.get("C0")) ?? [0]);
-		const c1 = colorOf(numArray(file, dict.get("C1")) ?? [1]);
+		const c0 = colorOf(numArray(file, dict.get("C0")) ?? [0], space);
+		const c1 = colorOf(numArray(file, dict.get("C1")) ?? [1], space);
 		return [{
 			offset: 0,
 			colorHex: c0
@@ -77,7 +103,7 @@ function parseFunction(file, value) {
 		const stops = [];
 		const span = d1 - d0 || 1;
 		for (let i = 0; i < subs.length; i++) {
-			const sub = parseFunction(file, subs[i]);
+			const sub = parseFunction(file, subs[i], space);
 			if (!sub || sub.length === 0) continue;
 			const lo = ((edges[i] ?? d0) - d0) / span;
 			const hi = ((edges[i + 1] ?? d1) - d0) / span;
@@ -85,7 +111,7 @@ function parseFunction(file, value) {
 		}
 		return stops.length > 0 ? stops : void 0;
 	}
-	if (type === 0 && resolved instanceof PdfStream) return sampleFunction(file, resolved);
+	if (type === 0 && resolved instanceof PdfStream) return sampleFunction(file, resolved, space);
 	if (type === 4) {
 		const fn = readFunction(file, resolved);
 		if (!fn) return void 0;
@@ -95,14 +121,82 @@ function parseFunction(file, value) {
 		const stops = [];
 		for (let s = 0; s < PS_STOPS; s++) {
 			const off = s / (PS_STOPS - 1);
-			pushStop(stops, off, colorOf(fn([d0 + off * (d1 - d0)])));
+			pushStop(stops, off, colorOf(fn([d0 + off * (d1 - d0)]), space));
 		}
 		return stops.length > 0 ? stops : void 0;
 	}
 }
+/**
+* §8.7.4.5.3 — a FUNCTION-BASED shading, sampled into a picture.
+*
+* Type 1 is not a ramp between two points: it is a function of two variables
+* over a rectangle, and no gradient can stand for one. Painted by a bare `sh`
+* it fills the clip, and nothing here lifted it at all —
+* function_based_shading.pdf is nine such squares and 43% of the page's ink,
+* and reconstructed to a blank sheet.
+*
+* Sampled it is exactly a picture, which every format downstream can show. The
+* grid is fixed: the function is smooth by construction (§8.7.4.5.3 gives it a
+* `/Domain` and nothing else), so more samples buy nothing a reader can see.
+*
+* @param file    The owning file.
+* @param shading The shading dictionary.
+* @returns The picture and the domain it covers, or `undefined` for a shading
+*          of another type or one whose function cannot be run.
+*/
+function sampledShading(file, shading) {
+	if (numOf(file.get(shading, "ShadingType")) !== 1) return void 0;
+	const space = shadingSpace(file, shading);
+	const fn = readFunction(file, shading.get("Function"));
+	if (!fn) return void 0;
+	const d = numArray(file, shading.get("Domain")) ?? [
+		0,
+		1,
+		0,
+		1
+	];
+	if (d.length < 4) return void 0;
+	const domain = [
+		d[0],
+		d[1],
+		d[2],
+		d[3]
+	];
+	const size = SAMPLED_SIDE;
+	const rgb = new Uint8Array(size * size * 3);
+	for (let row = 0; row < size; row++) {
+		const y = domain[3] - (row + .5) / size * (domain[3] - domain[2]);
+		for (let col = 0; col < size; col++) {
+			const hex = colorOf(fn([domain[0] + (col + .5) / size * (domain[1] - domain[0]), y]), space);
+			const at = (row * size + col) * 3;
+			rgb[at] = Number.parseInt(hex.slice(0, 2), 16);
+			rgb[at + 1] = Number.parseInt(hex.slice(2, 4), 16);
+			rgb[at + 2] = Number.parseInt(hex.slice(4, 6), 16);
+		}
+	}
+	return {
+		rgb,
+		size,
+		domain
+	};
+}
+/**
+* §8.7.4.5 — the colour space a shading's function lands in.
+*
+* The components alone do not say: a `/Separation` function gives ONE number
+* and that number is a strength of ink, not a grey level.
+* function_based_shading_cmyk.pdf's third square is a spot colour whose full
+* tint is a warm red, and read as grey it came back a black-to-white ramp.
+*/
+function shadingSpace(file, sh) {
+	const cs = sh.get("ColorSpace");
+	return cs === void 0 ? void 0 : colorSpaceAt(file, file.resolve(cs), 0);
+}
+/** How many samples a side a function-based shading is drawn at. */
+var SAMPLED_SIDE = 128;
 /** How many places a type-4 gradient is sampled at along its domain. */
 var PS_STOPS = 16;
-function sampleFunction(file, stream) {
+function sampleFunction(file, stream, space) {
 	const d = stream.dict;
 	const size = numArray(file, d.get("Size"));
 	const range = numArray(file, d.get("Range"));
@@ -149,18 +243,63 @@ function numArray(file, v) {
 	if (!Array.isArray(r)) return void 0;
 	return r.map((x) => typeof x === "number" ? x : 0);
 }
-function colorOf(c) {
-	if (c.length >= 4) {
-		const k = c[3];
-		return hex255(255 * (1 - c[0]) * (1 - k), 255 * (1 - c[1]) * (1 - k), 255 * (1 - c[2]) * (1 - k));
+function colorOf(c, space) {
+	return spaceColor(c, space) ?? spaceColor(c, void 0) ?? grayHex(c[0] ?? 0);
+}
+/**
+* §8.6.8 — the colour a run of `sc` / `scn` components comes to.
+*
+* The space in force decides, and where it was not read the COUNT is the next
+* best witness: three numbers are RGB and four are CMYK on every device space
+* there is. One number is the ambiguous case — grey in a device space, but the
+* strength of a colorant in a Separation, where 1 is the ink at full and reads
+* dark — so a lone component is only taken where the space said what it means.
+*
+* @param nums  The components, as the page or a shading's function states them.
+* @param space The space in force, where it was read.
+* @returns The colour as 6 hex digits, or `undefined` where the numbers do not
+*          say what colour they are.
+*/
+function spaceColor(nums, space) {
+	if (nums.length === 0) return void 0;
+	if (space?.icc && nums.length >= space.components) {
+		const [r, g, b] = space.icc(nums);
+		return rgbHex(r, g, b);
+	}
+	if (space?.cie) {
+		const [r, g, b] = cieToSrgb(space.cie, nums);
+		return rgbHex(r, g, b);
+	}
+	switch (space?.kind ?? (nums.length === 3 ? "rgb" : nums.length === 4 ? "cmyk" : void 0)) {
+		case "rgb": return nums.length >= 3 ? rgbHex(nums[0], nums[1], nums[2]) : void 0;
+		case "cmyk": return nums.length >= 4 ? cmykHex(nums[0], nums[1], nums[2], nums[3]) : void 0;
+		case "gray": return grayHex(nums[0]);
+		case "tint":
+			if (space?.tint) {
+				const hex = spaceColor(space.tint.transform(nums), space.tint.alternate);
+				if (hex !== void 0) return hex;
+			}
+			return grayHex(1 - Math.max(...nums));
+		default: return;
 	}
-	if (c.length === 3) return hex255(c[0] * 255, c[1] * 255, c[2] * 255);
-	const g = (c[0] ?? 0) * 255;
-	return hex255(g, g, g);
 }
-function hex255(r, g, b) {
-	const h = (x) => Math.max(0, Math.min(255, Math.round(x))).toString(16).padStart(2, "0");
-	return (h(r) + h(g) + h(b)).toUpperCase();
+function clamp255(v) {
+	return Math.max(0, Math.min(255, Math.round(v * 255)));
+}
+function hex2(v) {
+	return clamp255(v).toString(16).padStart(2, "0");
+}
+/** Three channels, each 0..1, as 6 upper-case hex digits. */
+function rgbHex(r, g, b) {
+	return (hex2(r) + hex2(g) + hex2(b)).toUpperCase();
+}
+/** One grey level, 0..1, as 6 upper-case hex digits. */
+function grayHex(v) {
+	return rgbHex(v, v, v);
+}
+/** §8.6.4.4 — four inks, each 0..1, as 6 upper-case hex digits. */
+function cmykHex(c, m, y, k) {
+	return rgbHex((1 - c) * (1 - k), (1 - m) * (1 - k), (1 - y) * (1 - k));
 }
 function pushStop(stops, offset, colorHex) {
 	const o = Math.max(0, Math.min(1, offset));
@@ -203,19 +342,23 @@ function buildAlphaMap(file, resources) {
 		const state = file.resolve(value);
 		if (!(state instanceof Map)) continue;
 		const ca = file.resolve(state.get("ca") ?? PDF_NULL);
-		const alpha = typeof ca === "number" && ca >= 0 && ca < 1 ? ca : void 0;
+		const alpha = typeof ca === "number" && ca >= 0 && ca <= 1 ? ca : void 0;
 		const bm = file.resolve(state.get("BM") ?? PDF_NULL);
 		const first = Array.isArray(bm) ? file.resolve(bm[0] ?? PDF_NULL) : bm;
 		const mode = first instanceof PdfName ? first.value : void 0;
 		const darkens = mode === "Multiply" || mode === "Darken";
 		const blend = mode !== void 0 && mode !== "Normal" && mode !== "Compatible" && !darkens ? mode : void 0;
-		const masked = file.resolve(state.get("SMask") ?? PDF_NULL) instanceof Map;
-		if (alpha === void 0 && !darkens && blend === void 0 && !masked) continue;
+		const statesMask = state.has("SMask");
+		const masked = statesMask ? file.resolve(state.get("SMask") ?? PDF_NULL) instanceof Map : void 0;
+		if (alpha === void 0 && mode === void 0 && !statesMask) continue;
 		out.set(name, {
 			...alpha !== void 0 ? { alpha } : {},
-			...darkens ? { darkens: true } : {},
+			...mode !== void 0 ? {
+				statesBlend: true,
+				darkens
+			} : {},
 			...blend !== void 0 ? { blend } : {},
-			...masked ? { masked: true } : {}
+			...masked !== void 0 ? { masked } : {}
 		});
 	}
 	return out;
@@ -249,9 +392,32 @@ function colorSpaceAt(file, cs, depth) {
 	if (head.value === "ICCBased") {
 		const stream = file.resolve(cs[1] ?? PDF_NULL);
 		const n = stream instanceof PdfStream ? file.get(stream.dict, "N") : void 0;
-		return byFamily("ICCBased", typeof n === "number" ? n : 3);
+		const base = byFamily("ICCBased", typeof n === "number" ? n : 3);
+		if (!base || !(stream instanceof PdfStream)) return base;
+		let icc;
+		try {
+			icc = iccTransform(file.streamData(stream));
+		} catch {
+			icc = void 0;
+		}
+		return icc ? {
+			...base,
+			icc
+		} : base;
 	}
 	if (head.value === "Indexed") return;
+	if (head.value === "CalRGB") {
+		const params = file.resolve(cs[1] ?? PDF_NULL);
+		const cie = params instanceof Map ? cieParams(file, params, true) : void 0;
+		const base = {
+			kind: "rgb",
+			components: 3
+		};
+		return cie ? {
+			...base,
+			cie
+		} : base;
+	}
 	if (head.value === "CalGray") {
 		const params = file.resolve(cs[1] ?? PDF_NULL);
 		const cie = params instanceof Map ? cieParams(file, params, false) : void 0;
@@ -350,4 +516,4 @@ function byFamily(family, n) {
 	}
 }
 //#endregion
-export { buildAlphaMap, buildColorSpaceMap, buildShadingMap };
+export { buildAlphaMap, buildColorSpaceMap, buildShadingMap, cmykHex, gradientShading, grayHex, rgbHex, sampledShading, shadingTypeOf, spaceColor };

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

@@ -0,0 +1,6 @@
+/** §7.4.5 — a byte, then that many literal bytes, or a run of one repeated. */
+export declare function runLengthDecode(data: Uint8Array): Uint8Array;
+/** §7.4.3 — four bytes as five base-85 digits, `z` for four zeroes, `~>` ends. */
+export declare function ascii85Decode(data: Uint8Array): Uint8Array;
+/** §7.4.2 — one byte as two hex digits, `>` ends, an odd last digit is halved. */
+export declare function asciiHexDecode(data: Uint8Array): Uint8Array;

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

@@ -0,0 +1,67 @@
+//#region src/pdf-reader/stream-filters.ts
+/** §7.4.5 — a byte, then that many literal bytes, or a run of one repeated. */
+function runLengthDecode(data) {
+	const out = [];
+	let i = 0;
+	while (i < data.length) {
+		const len = data[i++];
+		if (len === 128) break;
+		if (len < 128) for (let j = 0; j <= len && i < data.length; j++) out.push(data[i++]);
+		else {
+			const b = data[i++] ?? 0;
+			for (let j = 0; j < 257 - len; j++) out.push(b);
+		}
+	}
+	return Uint8Array.from(out);
+}
+/** §7.4.3 — four bytes as five base-85 digits, `z` for four zeroes, `~>` ends. */
+function ascii85Decode(data) {
+	const out = [];
+	let tuple = 0;
+	let count = 0;
+	for (const c of data) {
+		if (c === 126) break;
+		if (c <= 32) continue;
+		if (c === 122 && count === 0) {
+			out.push(0, 0, 0, 0);
+			continue;
+		}
+		if (c < 33 || c > 117) continue;
+		tuple = tuple * 85 + (c - 33);
+		if (++count === 5) {
+			out.push(tuple >>> 24 & 255, tuple >>> 16 & 255, tuple >>> 8 & 255, tuple & 255);
+			tuple = 0;
+			count = 0;
+		}
+	}
+	if (count > 0) {
+		for (let i = count; i < 5; i++) tuple = tuple * 85 + 84;
+		for (let i = 0; i < count - 1; i++) out.push(tuple >>> 24 - i * 8 & 255);
+	}
+	return Uint8Array.from(out);
+}
+/** §7.4.2 — one byte as two hex digits, `>` ends, an odd last digit is halved. */
+function asciiHexDecode(data) {
+	const out = [];
+	let hi = -1;
+	for (const c of data) {
+		if (c === 62) break;
+		const v = hexVal(c);
+		if (v < 0) continue;
+		if (hi < 0) hi = v;
+		else {
+			out.push(hi << 4 | v);
+			hi = -1;
+		}
+	}
+	if (hi >= 0) out.push(hi << 4);
+	return Uint8Array.from(out);
+}
+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;
+}
+//#endregion
+export { ascii85Decode, asciiHexDecode, runLengthDecode };

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

@@ -33,8 +33,7 @@ var STRIKE_HIGH = .5;
 function markDrawnRules(runs, vectors) {
 	const marks = /* @__PURE__ */ new Map();
 	const consumed = /* @__PURE__ */ new Set();
-	for (const v of vectors) {
-		if (!isRule(v)) continue;
+	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;
@@ -45,15 +44,16 @@ function markDrawnRules(runs, vectors) {
 		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 ? {
+			const hex = ruleHex(v);
+			marks.set(run, under.length > 0 && hex !== void 0 ? {
 				...had,
-				underline: v.fillHex
+				underline: hex
 			} : {
 				...had,
 				strike: true
 			});
 		}
-		consumed.add(v);
+		for (const part of parts) consumed.add(part);
 	}
 	if (marks.size === 0) return {
 		runs: [...runs],
@@ -78,13 +78,86 @@ function markDrawnRules(runs, vectors) {
 		consumed
 	};
 }
-/** A thin filled bar, which is the only shape an underline is drawn as. */
+/** 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.fillHex === void 0 || v.strokeHex !== void 0 || v.gradient !== void 0) return false;
-	if (v.fillHex === "FFFFFF") return false;
+	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;
-	const w = v.maxX - v.minX;
-	return h >= THINNEST_PT && h <= THICKEST_PT && w > 2;
+	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

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

@@ -1,4 +1,5 @@
 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";
@@ -24,8 +25,9 @@ function extractPageText(file, page) {
 	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);
 	const marks = collectTextMarkup(file, page);
-	if (links.length === 0 && marks.length === 0) return runs;
-	return runs.flatMap((run) => {
+	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));
 		const linked = link ? {
 			...run,
@@ -103,8 +105,85 @@ function collectTextMarkup(file, page) {
 	}
 	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, void 0, void 0, void 0, hiddenProperties(file, resources));
+	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) {

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;