reamkit 1.29.0 → 1.31.0

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

@@ -1,6 +1,9 @@
 import { PDF_NULL, PdfHexString, PdfName } from "../pdf/objects.js";
+import { bidiClass } from "../core/bidi/char-types.js";
+import { reorderVisual } from "../core/bidi/algorithm.js";
+import { analyzeString, hasBidiCharacters } from "../core/bidi/index.js";
 import { Lexer } from "./lexer.js";
-import { cmykHex, grayHex, rgbHex, spaceColor } from "./shading.js";
+import { cmykHex, dashLengths, grayHex, rgbHex, spaceColor } from "./shading.js";
 //#region src/pdf-reader/content.ts
 /**
 * A painted path emitted by the path-painting operators (§8.5.3), captured in
@@ -101,9 +104,13 @@ function initialState() {
 		fillColor: "000000",
 		strokeColor: "000000",
 		lineWidth: 1,
+		dash: [],
+		lineCap: 0,
 		fillGradient: void 0,
 		fillPattern: void 0,
+		fillPatternPaint: void 0,
 		fillAlpha: 1,
+		strokeAlpha: 1,
 		fillDarkens: false,
 		blendMode: void 0,
 		softMask: false,
@@ -184,6 +191,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 	const glyphs = [];
 	const painted = [];
 	const outlines = [];
+	const codesShown = /* @__PURE__ */ new Map();
 	const lexer = new Lexer(bytes);
 	const stack = [];
 	let state = initialState();
@@ -229,6 +237,25 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			y
 		});
 	};
+	const currentPoint = () => {
+		for (let i = path.length - 1; i >= 0; i--) {
+			const seg = path[i];
+			if (seg.op === "close") {
+				for (let k = i - 1; k >= 0; k--) {
+					const start = path[k];
+					if (start.op === "move") return {
+						x: start.x,
+						y: start.y
+					};
+				}
+				return;
+			}
+			return {
+				x: seg.x,
+				y: seg.y
+			};
+		}
+	};
 	const rectTo = (x, y, w, h) => {
 		moveTo(x, y);
 		lineTo(x + w, y);
@@ -241,6 +268,11 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		const scale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])) || 1;
 		return state.lineWidth * scale;
 	};
+	const ctmDash = () => {
+		const m = state.ctm;
+		const scale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])) || 1;
+		return state.dash.map((n) => n * scale);
+	};
 	const paintPath = (fill, stroke) => {
 		if (path.length >= 2 && (fill || stroke) && visible()) {
 			const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
@@ -249,6 +281,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				segs: path,
 				...state.clip ? { clip: state.clip } : {},
 				...fill && state.fillPattern !== void 0 ? { patternName: state.fillPattern } : {},
+				...fill && state.fillPattern !== void 0 && state.fillPatternPaint !== void 0 ? { patternPaint: state.fillPatternPaint } : {},
 				...fill ? { fillHex: state.fillColor } : {},
 				...fill && state.fillAlpha < 1 ? { alpha: state.fillAlpha } : {},
 				...fill && state.fillDarkens ? { darkens: true } : {},
@@ -259,6 +292,10 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 					strokeHex: state.strokeColor,
 					lineWidth: ctmLineWidth()
 				} : {},
+				...stroke && state.dash.length > 0 ? { dash: ctmDash() } : {},
+				...stroke && state.lineCap === 1 ? { cap: "round" } : {},
+				...stroke && state.lineCap === 2 ? { cap: "square" } : {},
+				...stroke && state.strokeAlpha < 1 ? { strokeAlpha: state.strokeAlpha } : {},
 				...mcid !== void 0 ? { mcid } : {}
 			});
 		}
@@ -337,6 +374,11 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		const bytes = toBytes(operand);
 		const codes = state.font.splitCodes ? state.font.splitCodes(bytes) : splitCodes(bytes, state.font.bytesPerCode);
 		for (const code of codes) advanceGlyph(code);
+		if (state.font.program && visible() && state.renderMode !== 3 && state.renderMode !== 7) {
+			let set = codesShown.get(state.font);
+			if (!set) codesShown.set(state.font, set = /* @__PURE__ */ new Set());
+			for (const code of codes) set.add(code);
+		}
 		return state.font.decode(codes);
 	};
 	const emitAt = (origin, shown, end) => {
@@ -357,6 +399,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			fontSizePt: Math.abs(state.fontSize) * scaleY,
 			spaceWidthPt: (state.font.width(32) / 1e3 * state.fontSize + state.charSpacing + state.wordSpacing) * scaleX,
 			fontKey: state.fontKey,
+			...state.font.fixedPitch === true ? { fixedPitch: true } : {},
 			...state.font.name !== void 0 ? { fontName: state.font.name } : {},
 			...state.font.type3 ? { type3: true } : {},
 			...state.renderMode === 3 || state.renderMode === 7 ? { invisible: true } : {},
@@ -519,6 +562,8 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				if (named !== void 0) {
 					state.fillGradient = shadings.get(named);
 					state.fillPattern = state.fillGradient ? void 0 : named;
+					const components = operands.filter((o) => typeof o === "number");
+					state.fillPatternPaint = components.length > 0 ? spaceColor(components, void 0) : void 0;
 					break;
 				}
 				const hex = colorOfOperands(operands, state.fillSpace);
@@ -531,7 +576,12 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			}
 			case "SCN":
 			case "SC": {
-				if (operands[operands.length - 1] instanceof PdfName) break;
+				const last = operands[operands.length - 1];
+				if (last instanceof PdfName) {
+					const sweep = shadings.get(last.value);
+					if (sweep) state.strokeColor = midGradient(sweep);
+					break;
+				}
 				const hex = colorOfOperands(operands, state.strokeSpace);
 				if (hex !== void 0) state.strokeColor = hex;
 				break;
@@ -548,6 +598,14 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			case "w":
 				state.lineWidth = num(0);
 				break;
+			case "d":
+				state.dash = dashLengths(operands[0]);
+				break;
+			case "J": {
+				const cap = num(0);
+				if (cap === 0 || cap === 1 || cap === 2) state.lineCap = cap;
+				break;
+			}
 			case "m":
 				moveTo(num(0), num(1));
 				break;
@@ -557,6 +615,26 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			case "c":
 				curveTo(num(0), num(1), num(2), num(3), num(4), num(5));
 				break;
+			case "v": {
+				const at = currentPoint();
+				if (at) {
+					const [x2, y2] = toPage(num(0), num(1));
+					const [x, y] = toPage(num(2), num(3));
+					path.push({
+						op: "cubic",
+						x1: at.x,
+						y1: at.y,
+						x2,
+						y2,
+						x,
+						y
+					});
+				}
+				break;
+			}
+			case "y":
+				curveTo(num(0), num(1), num(2), num(3), num(2), num(3));
+				break;
 			case "re":
 				rectTo(num(0), num(1), num(2), num(3));
 				break;
@@ -610,6 +688,10 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 						state.blendMode = paint.blend;
 					}
 					if (paint.masked !== void 0) state.softMask = paint.masked;
+					if (paint.lineWidth !== void 0) state.lineWidth = paint.lineWidth;
+					if (paint.dash !== void 0) state.dash = paint.dash;
+					if (paint.lineCap !== void 0) state.lineCap = paint.lineCap;
+					if (paint.strokeAlpha !== void 0) state.strokeAlpha = paint.strokeAlpha;
 				}
 				break;
 			}
@@ -670,7 +752,8 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		vectors,
 		glyphs,
 		shadings: painted,
-		outlines
+		outlines,
+		shown: codesShown
 	};
 }
 /** One path segment through a matrix — the glyph's own space onto the page. */
@@ -713,12 +796,27 @@ function strokesText(mode) {
 * ArabicCIDTrueType.pdf came out mirrored for exactly that reason: the reader
 * passed visual order through and the layout reversed it a second time.
 *
-* A run is reversed only when it is wholly right-to-left. Anything mixed — a
-* number inside an Arabic sentence runs left to right — needs the full bidi
-* algorithm, and guessing at it would be worse than leaving it alone.
+* A run wholly right-to-left is simply reversed. A MIXED one — a full stop or
+* a number inside an Arabic sentence — is put through the bidi algorithm's
+* reordering (UAX #9 L2), which for the runs a line holds undoes itself: the
+* painted order reordered is the reading order. Left alone, a note of
+* freetext_no_appearance.pdf came back with every line that held a full stop
+* reading back to front. The direction it is reordered in is the one most of
+* its letters run in — the painted order says nothing about which comes first.
 */
 function logicalOrder(text) {
-	return isRightToLeft(text) ? [...text].reverse().join("") : text;
+	if (isRightToLeft(text)) return [...text].reverse().join("");
+	if (!hasBidiCharacters(text)) return text;
+	const chars = [...text];
+	let rtl = 0;
+	let strong = 0;
+	for (const ch of chars) {
+		const type = bidiClass(ch.codePointAt(0) ?? 0);
+		if (type === "R" || type === "AL") rtl++;
+		if (type === "R" || type === "AL" || type === "L") strong++;
+	}
+	const { levels } = analyzeString(text, rtl * 2 >= strong ? "rtl" : "ltr");
+	return reorderVisual(levels).map((i) => chars[i] ?? "").join("");
 }
 /**
 * Whether a string is wholly right-to-left: at least one letter of an RTL
@@ -837,8 +935,8 @@ function readValue(lexer) {
 * The bytes are binary and may hold `EI` themselves, so the end is found by
 * MEASURING where the dictionary says how much there is — an unfiltered image
 * is exactly `ceil(W · BPC · components / 8) · H` bytes — and only searched for
-* where a filter makes the length unknowable. images_1bit_grayscale.pdf draws
-* two of them and both were skipped over.
+* where a filter makes the length unknowable (see {@link filteredEnd}).
+* images_1bit_grayscale.pdf draws two of them and both were skipped over.
 */
 function readInlineImage(lexer) {
 	const dict = /* @__PURE__ */ new Map();
@@ -848,24 +946,86 @@ function readInlineImage(lexer) {
 		if (tok.kind === "keyword" && tok.value === "ID") break;
 		if (tok.kind === "name") dict.set(tok.value, readValue(lexer));
 	}
-	const start = lexer.pos + 1;
 	const measured = inlineLength(dict);
+	const crlf = lexer.byteAt(lexer.pos) === 13 && lexer.byteAt(lexer.pos + 1) === 10;
+	const start = lexer.pos + (crlf && measured === void 0 ? 2 : 1);
 	let end = measured !== void 0 ? start + measured : -1;
 	if (end < 0 || end > lexer.length) {
-		end = lexer.indexOfAscii("EI", start);
+		end = filteredEnd(lexer, start, dict);
 		if (end < 0) {
 			lexer.pos = lexer.length;
 			return;
 		}
 	}
 	const data = lexer.slice(start, Math.min(end, lexer.length));
-	const ei = lexer.indexOfAscii("EI", end);
+	const ei = lexer.indexOfKeyword("EI", end);
 	lexer.pos = ei < 0 ? lexer.length : ei + 2;
 	return {
 		dict,
 		data
 	};
 }
+/**
+* §8.9.7 — where a FILTERED inline image's bytes end, which the dictionary
+* cannot say.
+*
+* Searched for as the first two bytes `EI`, the end fell inside the picture
+* wherever its own bytes spelled them: a JPEG is dense with them, and
+* bug1065245.pdf's three banners were each cut off a few hundred bytes in,
+* would not decode, and were dropped — a blank sheet. So the data is read to
+* where its OWN encoding ends: a JPEG at its end-of-image marker, hex text at
+* `>`, base-85 at `~>`. Anything else ends at the first `EI` standing as a
+* word of its own.
+*/
+function filteredEnd(lexer, start, dict) {
+	const f = dict.get("F") ?? dict.get("Filter");
+	const first = Array.isArray(f) ? f[0] : f;
+	const filter = first instanceof PdfName ? first.value : "";
+	if (filter === "DCT" || filter === "DCTDecode") {
+		const eoi = jpegEnd(lexer, start);
+		if (eoi !== void 0) return eoi;
+	} else if (filter === "AHx" || filter === "ASCIIHexDecode") {
+		const gt = lexer.indexOfAscii(">", start);
+		if (gt >= 0) return gt + 1;
+	} else if (filter === "A85" || filter === "ASCII85Decode") {
+		const tilde = lexer.indexOfAscii("~>", start);
+		if (tilde >= 0) return tilde + 2;
+	}
+	return lexer.indexOfKeyword("EI", start);
+}
+/**
+* Where a JPEG that starts at `start` ends: past its end-of-image marker,
+* found by walking its segments — a length-prefixed marker segment is stepped
+* over whole, and the coded data after a start-of-scan is read to the next
+* marker, where `FF` stands before anything but a stuffed `00` or a restart.
+*/
+function jpegEnd(lexer, start) {
+	if (lexer.byteAt(start) !== 255 || lexer.byteAt(start + 1) !== 216) return void 0;
+	let i = start + 2;
+	for (;;) {
+		if (lexer.byteAt(i) !== 255) return void 0;
+		let marker = lexer.byteAt(i + 1);
+		while (marker === 255) marker = lexer.byteAt(++i + 1);
+		if (marker < 0) return void 0;
+		if (marker === 217) return i + 2;
+		if (marker >= 208 && marker <= 215 || marker === 1) {
+			i += 2;
+			continue;
+		}
+		const hi = lexer.byteAt(i + 2);
+		const lo = lexer.byteAt(i + 3);
+		if (hi < 0 || lo < 0 || (hi << 8) + lo < 2) return void 0;
+		i += 2 + (hi << 8) + lo;
+		if (marker !== 218) continue;
+		for (;;) {
+			const b = lexer.byteAt(i);
+			if (b < 0) return void 0;
+			const next = lexer.byteAt(i + 1);
+			if (b === 255 && next !== 0 && !(next >= 208 && next <= 215)) break;
+			i++;
+		}
+	}
+}
 /** How many bytes an UNFILTERED inline image's samples take, if that is known. */
 function inlineLength(dict) {
 	if (dict.has("F") || dict.has("Filter")) return void 0;

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

@@ -15,6 +15,16 @@ export interface Display {
         x: number;
         y: number;
     };
+    /**
+     * §17.6.20 — present when the page is READ in a frame turned back from the
+     * sheet it is shown on: its words run DOWN the sheet, and they are read in
+     * the frame where they stand upright (see {@link textFrameOf}). `width` and
+     * `height` above are that frame's; these are the sheet's.
+     */
+    readonly sheet?: {
+        readonly width: number;
+        readonly height: number;
+    };
 }
 /**
  * The {@link Display} a page's shown box and `/Rotate` describe.
@@ -27,6 +37,32 @@ export interface Display {
  * @returns Its size, its turn, and the map onto it.
  */
 export declare function displayOf(page: PdfPage): Display;
+/**
+ * The frame a page whose words run DOWN its sheet is read in: the sheet turned
+ * back a quarter, so the words stand upright in it and every line, paragraph
+ * and margin is found the way it is on any other page.
+ *
+ * A viewer turns such a page with its words, and so does the document it is
+ * read into (§17.6.20 `tbRl`; see {@link wordsTurnOf} for when a page's words
+ * run down it): hello_world_rotated.pdf sets "Hello world"
+ * upright in a portrait box and turns the page by `/Rotate 90`, and read on
+ * the shown sheet the words were set flat across it where every viewer shows
+ * them running down.
+ *
+ * @param shown The page's shown geometry.
+ * @returns The frame, which knows the sheet it was turned back from.
+ */
+export declare function textFrameOf(shown: Display): Display;
+/**
+ * How a page's words stand on its sheet: the quarter turn, counter-clockwise,
+ * whose words outweigh every other on it together, by their letters at their
+ * size — or 0 where none does. A label set on its side beside the text does
+ * not turn a page; a page of it does.
+ *
+ * @param runs The page's runs, placed on the shown sheet.
+ * @returns 0, 90, 180 or 270; 270 is a page whose words run DOWN it.
+ */
+export declare function wordsTurnOf(runs: ReadonlyArray<TextRun>): 0 | 90 | 180 | 270;
 /**
  * The same runs, placed on the shown page.
  *

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

@@ -46,6 +46,71 @@ function displayOf(page) {
 	};
 }
 /**
+* The frame a page whose words run DOWN its sheet is read in: the sheet turned
+* back a quarter, so the words stand upright in it and every line, paragraph
+* and margin is found the way it is on any other page.
+*
+* A viewer turns such a page with its words, and so does the document it is
+* read into (§17.6.20 `tbRl`; see {@link wordsTurnOf} for when a page's words
+* run down it): hello_world_rotated.pdf sets "Hello world"
+* upright in a portrait box and turns the page by `/Rotate 90`, and read on
+* the shown sheet the words were set flat across it where every viewer shows
+* them running down.
+*
+* @param shown The page's shown geometry.
+* @returns The frame, which knows the sheet it was turned back from.
+*/
+function textFrameOf(shown) {
+	return {
+		width: shown.height,
+		height: shown.width,
+		turnDeg: shown.turnDeg === 270 || shown.turnDeg === -90 ? 0 : shown.turnDeg + 90,
+		place: (x, y) => {
+			const p = shown.place(x, y);
+			return {
+				x: shown.height - p.y,
+				y: p.x
+			};
+		},
+		sheet: {
+			width: shown.width,
+			height: shown.height
+		}
+	};
+}
+/**
+* How a page's words stand on its sheet: the quarter turn, counter-clockwise,
+* whose words outweigh every other on it together, by their letters at their
+* size — or 0 where none does. A label set on its side beside the text does
+* not turn a page; a page of it does.
+*
+* @param runs The page's runs, placed on the shown sheet.
+* @returns 0, 90, 180 or 270; 270 is a page whose words run DOWN it.
+*/
+function wordsTurnOf(runs) {
+	const by = [
+		0,
+		0,
+		0,
+		0
+	];
+	let all = 0;
+	for (const r of runs) {
+		const letters = r.text.trim().length;
+		if (letters === 0) continue;
+		const weight = letters * (r.fontSizePt || 10);
+		all += weight;
+		const angle = (Math.round(r.angleDeg ?? 0) % 360 + 360) % 360;
+		if (angle % 90 === 0) by[angle / 90] += weight;
+	}
+	const most = by.findIndex((w) => w * 2 > all);
+	return most > 0 ? [
+		90,
+		180,
+		270
+	][most - 1] : 0;
+}
+/**
 * The same runs, placed on the shown page.
 *
 * @param runs The runs as the content stream drew them.
@@ -199,12 +264,28 @@ function placeVectors(vectors, d) {
 			ys.push(s.y);
 			if (s.op === "cubic") xs.push(s.x1, s.x2), ys.push(s.y1, s.y2);
 		}
+		const g = v.gradient;
+		const moved = g?.axis !== void 0 ? { gradient: {
+			...g,
+			axis: ((a) => {
+				const p0 = d.place(a.x0, a.y0);
+				const p1 = d.place(a.x1, a.y1);
+				return {
+					x0: p0.x,
+					y0: p0.y,
+					x1: p1.x,
+					y1: p1.y
+				};
+			})(g.axis)
+		} } : {};
 		if (xs.length === 0) return {
 			...v,
+			...moved,
 			segs
 		};
 		return {
 			...v,
+			...moved,
 			segs,
 			minX: Math.min(...xs),
 			minY: Math.min(...ys),
@@ -214,4 +295,4 @@ function placeVectors(vectors, d) {
 	}).filter((v) => shows(d, v.minX, v.minY, v.maxX, v.maxY));
 }
 //#endregion
-export { displayOf, placeImages, placeRuns, placeVectors };
+export { displayOf, placeImages, placeRuns, placeVectors, textFrameOf, wordsTurnOf };

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

@@ -183,7 +183,7 @@ var PdfFile = class PdfFile {
 			}
 			return;
 		}
-		const media = mediaBox ?? DEFAULT_MEDIA_BOX;
+		const media = mediaBox !== void 0 && hasArea(mediaBox) ? mediaBox : DEFAULT_MEDIA_BOX;
 		out.push({
 			dict: node,
 			mediaBox: media,
@@ -556,6 +556,10 @@ function lastIndexOfAscii(buf, needle) {
 * bug1844576.pdf is 612×792 of paper cropped to 181×53.75, and read as its
 * media box the form on it arrived a fifth of the way down a letter page.
 */
+/** Whether a rectangle bounds anything: a point or a line is no page. */
+function hasArea([x0, y0, x1, y1]) {
+	return Math.abs(x1 - x0) > 1 && Math.abs(y1 - y0) > 1;
+}
 function shownBox(media, crop) {
 	if (!crop) return media;
 	const [mx0, my0, mx1, my1] = media;

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

@@ -29,6 +29,16 @@ import { FontRegistry } from '../core/font/index.js';
  * @returns Name → a one-face registry holding that program.
  */
 export declare function collectEmbeddedFonts(file: PdfFile, pages: ReadonlyArray<PdfPage>, losses?: Array<Loss>): Map<string, FontRegistry>;
+/**
+ * Every `/Font` dictionary the pages draw with, each once: the page's own
+ * resources and those of every form it paints (§8.8 — a drawing keeps most of
+ * its lettering inside them).
+ *
+ * @param file  The owning file.
+ * @param pages The pages whose fonts are wanted.
+ * @param visit Called once per font dictionary.
+ */
+export declare function eachPageFont(file: PdfFile, pages: ReadonlyArray<PdfPage>, visit: (fontDict: PdfDict) => void): void;
 /**
  * The name a run set in `fontDict` will ask for: its `/BaseFont` without the
  * six-capital subset prefix (§9.6.4), lowercased.
@@ -49,3 +59,18 @@ export declare function embeddedFontName(file: PdfFile, fontDict: PdfDict): stri
  * @param fontDict The font dictionary.
  */
 export declare function hasLiftableProgram(file: PdfFile, fontDict: PdfDict): boolean;
+/**
+ * The style a font's embedded program states for itself — the `head` table's
+ * macStyle, bit 0 bold and bit 1 italic — where the file carries a TrueType
+ * program to read it from, and the weight a Type 1 program names (see
+ * {@link typeOneStyle}).
+ *
+ * @param file     The document.
+ * @param fontDict The font dictionary.
+ * @returns The program's own style, or `undefined` where there is no program
+ *          or it has no header.
+ */
+export declare function programStyle(file: PdfFile, fontDict: PdfDict): {
+    bold: boolean;
+    italic: boolean;
+} | undefined;

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

@@ -32,11 +32,7 @@ var MAX_FORM_DEPTH = 8;
 */
 function collectEmbeddedFonts(file, pages, losses) {
 	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);
+	eachPageFont(file, pages, (fontDict) => {
 		const name = embeddedFontName(file, fontDict);
 		if (name === void 0 || out.has(name)) return;
 		const program = fontProgram(file, fontDict);
@@ -53,13 +49,29 @@ function collectEmbeddedFonts(file, pages, losses) {
 			}
 			out.set(name, FontRegistry.fromBytes({ regular: program }));
 		} catch {}
-	};
+	});
+	return out;
+}
+/**
+* Every `/Font` dictionary the pages draw with, each once: the page's own
+* resources and those of every form it paints (§8.8 — a drawing keeps most of
+* its lettering inside them).
+*
+* @param file  The owning file.
+* @param pages The pages whose fonts are wanted.
+* @param visit Called once per font dictionary.
+*/
+function eachPageFont(file, pages, visit) {
+	const seen = /* @__PURE__ */ new Set();
+	const visiting = /* @__PURE__ */ new Set();
 	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 (!(dict instanceof Map) || seen.has(dict)) continue;
+			seen.add(dict);
+			visit(dict);
 		}
 		if (depth >= MAX_FORM_DEPTH) return;
 		const xobjects = file.get(resources, "XObject");
@@ -76,7 +88,6 @@ function collectEmbeddedFonts(file, pages, losses) {
 		}
 	};
 	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
@@ -105,6 +116,64 @@ function embeddedFontName(file, fontDict) {
 function hasLiftableProgram(file, fontDict) {
 	return fontProgram(file, fontDict) !== void 0;
 }
+/**
+* The style a font's embedded program states for itself — the `head` table's
+* macStyle, bit 0 bold and bit 1 italic — where the file carries a TrueType
+* program to read it from, and the weight a Type 1 program names (see
+* {@link typeOneStyle}).
+*
+* @param file     The document.
+* @param fontDict The font dictionary.
+* @returns The program's own style, or `undefined` where there is no program
+*          or it has no header.
+*/
+function programStyle(file, fontDict) {
+	const program = fontProgram(file, fontDict);
+	if (!program) return typeOneStyle(file, fontDict);
+	if (program.length < 12) return void 0;
+	const view = new DataView(program.buffer, program.byteOffset, program.byteLength);
+	const tables = view.getUint16(4);
+	for (let i = 0; i < tables; i++) {
+		const at = 12 + i * 16;
+		if (at + 16 > program.length) return void 0;
+		if (String.fromCharCode(...program.subarray(at, at + 4)) !== "head") continue;
+		const offset = view.getUint32(at + 8);
+		if (offset + 46 > program.length) return void 0;
+		const macStyle = view.getUint16(offset + 44);
+		return {
+			bold: (macStyle & 1) !== 0,
+			italic: (macStyle & 2) !== 0
+		};
+	}
+}
+/**
+* §9.9 `/FontFile` — the weight a Type 1 program names in its `FontInfo`
+* (`/Weight (Bold)`), read off the cleartext that opens it. pdfTeX states no
+* weight in the descriptor, and names URW's bold Times "NimbusRomNo9L-Medi",
+* which no rule of names reads as bold: comments.pdf's headings and captions
+* came back in the body's weight. Its program says "Bold"; Computer Modern's
+* say "Medium", which is their book weight.
+*
+* @param file     The document.
+* @param fontDict The font dictionary.
+* @returns The style, or `undefined` where no program names a weight.
+*/
+function typeOneStyle(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("FontFile") ?? PDF_NULL);
+	if (!(program instanceof PdfStream)) return void 0;
+	const bytes = file.streamData(program);
+	const clear = new TextDecoder("latin1").decode(bytes.subarray(0, TYPE_ONE_HEAD));
+	const weight = /\/Weight\s*\(([^)]*)\)/u.exec(clear)?.[1];
+	return weight === void 0 ? void 0 : {
+		bold: /bold|black|heavy|semib|demi/iu.test(weight),
+		italic: false
+	};
+}
+/** How far into a Type 1 program its `FontInfo` stands, at the most. */
+var TYPE_ONE_HEAD = 8192;
 /** §9.9 `/FontFile2` — the TrueType program, off the font or its descendant. */
 function fontProgram(file, fontDict) {
 	const owner = descendant(file, fontDict) ?? fontDict;
@@ -123,4 +192,4 @@ function descendant(file, fontDict) {
 	return first instanceof Map ? first : void 0;
 }
 //#endregion
-export { collectEmbeddedFonts, embeddedFontName, hasLiftableProgram };
+export { collectEmbeddedFonts, eachPageFont, embeddedFontName, hasLiftableProgram, programStyle };

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

@@ -1,5 +1,13 @@
 /** One of the base encodings this reader has a table for (Annex D.2). */
 export type BaseEncodingName = 'StandardEncoding' | 'WinAnsiEncoding' | 'MacRomanEncoding';
+/**
+ * The glyph a code of WinAnsiEncoding's Latin-1 half selects, by name (see
+ * `WIN_ANSI_LATIN`).
+ *
+ * @param code A one-byte code.
+ * @returns The Annex D.2 glyph name, or `undefined` outside 0xA0–0xFF.
+ */
+export declare function winAnsiLatinName(code: number): string | undefined;
 /**
  * The glyph names of a base encoding, or `undefined` for a name this has no
  * table for — `/MacExpertEncoding`, whose repertory no reader here can set.