reamkit 1.30.0 → 1.32.0

package/dist/esm/pdf-reader/cff-outline.js

@@ -1,3 +1,4 @@
+import { standardEncodingTable } from "./encodings.js";
 //#region src/pdf-reader/cff-outline.ts
 /**
 * Prepare an embedded CFF program for outline reading.
@@ -69,6 +70,90 @@ function cffCidToGid(program) {
 		return;
 	}
 }
+/**
+* How far the pen moves after a name-keyed CFF program's `space`, in
+* thousandths of an em — the width a writer gives the space a page never
+* showed, which is the one it was typeset with.
+*
+* @param program The raw CFF bytes.
+* @returns The advance, or `undefined` where the program has no `space` or its
+*          width cannot be read off the charstring.
+*/
+function cffSpaceAdvance(program) {
+	try {
+		const font = parseCff(program);
+		const gid = font?.nameToGid?.get("space");
+		if (!font || gid === void 0) return void 0;
+		const width = glyphWidth(font, gid);
+		return width === void 0 ? void 0 : width * font.scale * 1e3;
+	} catch {
+		return;
+	}
+}
+/**
+* TN 5177 §4.1 — a glyph's width: `nominalWidthX` plus the operand a
+* charstring puts before its first stack-clearing operator, or
+* `defaultWidthX` where it puts none. Whether one is there is a matter of
+* COUNT — one more than the operator takes.
+*/
+function glyphWidth(font, gid) {
+	const code = font.charStrings[gid];
+	if (!code) return void 0;
+	const { defaultWidth, nominalWidth } = font.widthsOf(gid);
+	const stack = [];
+	for (let i = 0; i < code.length;) {
+		const b = code[i++];
+		if (b === 28) {
+			stack.push((code[i] << 24 | code[i + 1] << 16) >> 16);
+			i += 2;
+		} else if (b >= 32 && b <= 246) stack.push(b - 139);
+		else if (b >= 247 && b <= 250) stack.push((b - 247) * 256 + code[i++] + 108);
+		else if (b >= 251 && b <= 254) stack.push(-(b - 251) * 256 - code[i++] - 108);
+		else if (b === 255) {
+			stack.push((code[i] << 24 | code[i + 1] << 16 | code[i + 2] << 8 | code[i + 3]) / 65536);
+			i += 4;
+		} else {
+			const takes = b === 21 ? 2 : b === 22 || b === 4 ? 1 : b === 14 ? stack.length >= 4 ? 4 : 0 : -1;
+			if (b === 1 || b === 3 || b === 18 || b === 23 || b === 19 || b === 20) return stack.length % 2 === 1 ? nominalWidth + stack[0] : defaultWidth;
+			if (takes < 0) return void 0;
+			return stack.length > takes ? nominalWidth + stack[0] : defaultWidth;
+		}
+	}
+}
+/**
+* The embedding a CFF program's licence allows: CFF has no OS/2 table, and
+* Adobe writes the OS/2 `fsType` into the Top DICT's `PostScript` string
+* instead (TN 5176 §9, key 12 21) as `/FSType 8 def`.
+*
+* @param program The raw CFF bytes.
+* @returns The value, or `undefined` where the program states none.
+*/
+function cffFsType(program) {
+	try {
+		const names = readIndex(program, program[2] ?? 4);
+		const tops = names ? readIndex(program, names.end) : void 0;
+		const strings = tops ? readIndex(program, tops.end) : void 0;
+		const top = tops?.items[0];
+		if (!top || !strings) return void 0;
+		const sid = parseDict(top).get(1221)?.[0];
+		if (sid === void 0 || sid < STANDARD_STRINGS.length) return void 0;
+		const own = strings.items[sid - STANDARD_STRINGS.length];
+		return own ? postScriptFsType(new TextDecoder("latin1").decode(own)) : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The `/FSType n def` a PostScript font program writes where an OpenType one
+* has its OS/2 field (Adobe TN 5176 §9; a Type 1 font's `FontInfo` alike).
+*
+* @param text The PostScript to search.
+* @returns The value, or `undefined` where the text states none.
+*/
+function postScriptFsType(text) {
+	const m = /\/FSType\s+(\d+)\s+def/u.exec(text);
+	return m ? Number(m[1]) : void 0;
+}
 /** The `CFF ` table of an OpenType wrapper, where the program is one. */
 function openTypeCff(program) {
 	if (program.length < 12) return void 0;
@@ -102,27 +187,52 @@ function parseCff(program) {
 	if (!charStrings) return void 0;
 	const matrix = top.get(1207);
 	const scale = matrix && matrix.length >= 4 ? matrix[0] ?? .001 : .001;
-	const privateSubrs = (dict) => {
+	const privateOf = (dict) => {
+		const none = {
+			subrs: [],
+			widths: {
+				defaultWidth: 0,
+				nominalWidth: 0
+			}
+		};
 		const priv = dict.get(18);
-		if (!priv || priv.length < 2) return [];
+		if (!priv || priv.length < 2) return none;
 		const size = priv[0];
 		const offset = priv[1];
-		if (offset < 0 || offset + size > program.length) return [];
-		const subrsAt = parseDict(program.subarray(offset, offset + size)).get(19)?.[0];
-		if (subrsAt === void 0) return [];
-		return readIndex(program, offset + subrsAt)?.items ?? [];
+		if (offset < 0 || offset + size > program.length) return none;
+		const inner = parseDict(program.subarray(offset, offset + size));
+		const widths = {
+			defaultWidth: inner.get(20)?.[0] ?? 0,
+			nominalWidth: inner.get(21)?.[0] ?? 0
+		};
+		const subrsAt = inner.get(19)?.[0];
+		if (subrsAt === void 0) return {
+			subrs: [],
+			widths
+		};
+		return {
+			subrs: readIndex(program, offset + subrsAt)?.items ?? [],
+			widths
+		};
 	};
 	const isCid = top.has(1230);
 	let localSubrs;
+	let widthsOf;
 	if (isCid) {
 		const fdArrayAt = top.get(1236)?.[0];
 		const fdSelectAt = top.get(1237)?.[0];
-		const subrsPerFd = (fdArrayAt !== void 0 ? readIndex(program, fdArrayAt)?.items ?? [] : []).map((fd) => privateSubrs(parseDict(fd)));
+		const privatePerFd = (fdArrayAt !== void 0 ? readIndex(program, fdArrayAt)?.items ?? [] : []).map((fd) => privateOf(parseDict(fd)));
 		const select = fdSelectAt !== void 0 ? readFdSelect(program, fdSelectAt, charStrings.items.length) : void 0;
-		localSubrs = (gid) => subrsPerFd[select ? select[gid] ?? 0 : 0] ?? [];
+		const privateFor = (gid) => privatePerFd[select ? select[gid] ?? 0 : 0];
+		localSubrs = (gid) => privateFor(gid)?.subrs ?? [];
+		widthsOf = (gid) => privateFor(gid)?.widths ?? {
+			defaultWidth: 0,
+			nominalWidth: 0
+		};
 	} else {
-		const only = privateSubrs(top);
-		localSubrs = () => only;
+		const only = privateOf(top);
+		localSubrs = () => only.subrs;
+		widthsOf = () => only.widths;
 	}
 	const charsetAt = top.get(15)?.[0];
 	const sids = charsetAt !== void 0 && charsetAt > 2 ? readCharset(program, charsetAt, charStrings.items.length) : void 0;
@@ -134,7 +244,8 @@ function parseCff(program) {
 		localSubrs,
 		scale,
 		...cidToGid ? { cidToGid } : {},
-		...nameToGid ? { nameToGid } : {}
+		...nameToGid ? { nameToGid } : {},
+		widthsOf
 	};
 }
 /**
@@ -689,9 +800,10 @@ function bias(subrs) {
 /** How deep a charstring may call, and how many operators it may run. */
 var MAX_CALL_DEPTH = 10;
 var MAX_STEPS = 65536;
-function runGlyph(font, gid) {
+function runGlyph(font, gid, part = false) {
 	const program = font.charStrings[gid];
 	if (!program) return void 0;
+	let seac;
 	const local = font.localSubrs(gid);
 	const localBias = bias(local);
 	const globalBias = bias(font.globalSubrs);
@@ -885,7 +997,16 @@ function runGlyph(font, gid) {
 				}
 				case 11: return true;
 				case 14:
-					takeWidth(stack.length > 4 ? 4 : 0);
+					takeWidth(stack.length >= 4 ? 4 : 0);
+					if (stack.length >= 4) {
+						const [adx = 0, ady = 0, bchar = 0, achar = 0] = stack;
+						seac = {
+							adx,
+							ady,
+							bchar,
+							achar
+						};
+					}
 					if (open) out.push({ op: "close" });
 					open = false;
 					return false;
@@ -919,8 +1040,35 @@ function runGlyph(font, gid) {
 	}
 	run(program, 0);
 	if (out.length > 0 && out[out.length - 1]?.op !== "close") out.push({ op: "close" });
-	if (out.length === 0) return void 0;
-	return out.map((seg) => scaleSeg(seg, font.scale));
+	const own = out.map((seg) => scaleSeg(seg, font.scale));
+	if (seac && !part) {
+		const at = seac;
+		const glyphOf = (code) => {
+			const name = standardEncodingTable().get(code);
+			const gid = name !== void 0 ? font.nameToGid?.get(name) : void 0;
+			return gid !== void 0 ? runGlyph(font, gid, true) ?? [] : [];
+		};
+		own.push(...glyphOf(at.bchar), ...glyphOf(at.achar).map((seg) => shiftSeg(seg, at.adx * font.scale, at.ady * font.scale)));
+	}
+	return own.length > 0 ? own : void 0;
+}
+/** A segment moved by `(dx, dy)`: where a `seac` puts its accent. */
+function shiftSeg(seg, dx, dy) {
+	if (seg.op === "close") return seg;
+	if (seg.op === "cubic") return {
+		op: "cubic",
+		x1: seg.x1 + dx,
+		y1: seg.y1 + dy,
+		x2: seg.x2 + dx,
+		y2: seg.y2 + dy,
+		x: seg.x + dx,
+		y: seg.y + dy
+	};
+	return {
+		op: seg.op,
+		x: seg.x + dx,
+		y: seg.y + dy
+	};
 }
 function runEscape(op, stack, trans) {
 	switch (op) {
@@ -1030,8 +1178,8 @@ function flexCurves(op, stack, x0, y0) {
 		]);
 		push([
 			n(4),
-			n(6),
-			0
+			n(5),
+			n(6)
 		], [
 			0,
 			startY - y,
@@ -1051,12 +1199,12 @@ function flexCurves(op, stack, x0, y0) {
 		]);
 		push([
 			n(5),
-			n(7),
+			n(6),
 			n(8)
 		], [
 			0,
-			n(6),
-			startY - (y + n(6))
+			n(7),
+			startY - (y + n(7))
 		]);
 		y = startY;
 	} else if (op === 37) {
@@ -1119,4 +1267,4 @@ function scaleSeg(seg, k) {
 	};
 }
 //#endregion
-export { cffCidToGid, cffNameToGid, cffOutlineSource, openTypeCff };
+export { cffCidToGid, cffFsType, cffNameToGid, cffOutlineSource, cffSpaceAdvance, openTypeCff, postScriptFsType };

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

@@ -21,6 +21,15 @@ export interface ContentFont {
     decode: (codes: ReadonlyArray<number>) => string;
     /** Glyph advance for one code, in 1000-unit text space. */
     width: (code: number) => number;
+    /**
+     * §9.6.2.1 — the advance of the face's SPACE as the file states it, in
+     * 1000-unit text space: the code its encoding names `space`. Absent where
+     * the font states none — not the fallback {@link width} gives a code with no
+     * width of its own.
+     */
+    readonly spaceWidth?: number;
+    /** §9.8.2 — every glyph of the face is as wide as the next: a typewriter's. */
+    readonly fixedPitch?: boolean;
     /**
      * §9.4.4 / §9.7.4.3 — the face sets its text DOWN the page, not across, and
      * the pen advances by the vertical displacement `w1` rather than by `w0`.
@@ -47,6 +56,43 @@ export interface ContentFont {
      * this is the last resort before a blank page.
      */
     readonly outline?: GlyphOutline;
+    /**
+     * §9.9 — the face's embedded program, for a writer that embeds the face:
+     * the outline EVERY code draws, the program's licence, the descriptor's
+     * metrics. Only a face whose program this reads has one.
+     */
+    readonly program?: FaceProgram;
+}
+/**
+ * §9.9 — what a writer that embeds a face needs from its program: the outline
+ * each code draws, what the licence allows, and the metrics the descriptor
+ * states (§9.8.1).
+ */
+export interface FaceProgram {
+    /**
+     * The contours a code draws, in a one-unit em — empty for a glyph the program
+     * holds that draws nothing, `undefined` where it holds none for the code.
+     */
+    readonly glyph: (code: number) => ReadonlyArray<PathSeg> | undefined;
+    /**
+     * OS/2 `fsType` — or the `/FSType` a CFF or Type 1 program writes in its
+     * place — where the program states one.
+     */
+    readonly fsType?: number;
+    /**
+     * How far the program's own space advances, in thousandths of an em — the
+     * width a writer gives a space the page never showed as a glyph.
+     */
+    readonly spaceAdvance?: number;
+    /** The program's PostScript name: the `/BaseFont` less its subset tag. */
+    readonly postScriptName: string;
+    /** §9.8.1 `/CapHeight` and `/XHeight`, in thousandths of an em, where stated. */
+    readonly capHeight?: number;
+    readonly xHeight?: number;
+    /** §9.8.1 `/ItalicAngle`, in degrees counterclockwise from the vertical. */
+    readonly italicAngle: number;
+    /** §9.8.2 `/Flags` bit 1 — every glyph has the same width. */
+    readonly fixedPitch: boolean;
 }
 /** §9.6.6 — the outlines of a face read by glyph index, and their glyph space. */
 export interface GlyphOutline {
@@ -106,6 +152,8 @@ export interface TextRun {
      * Absent where the face states no width for it.
      */
     readonly spaceWidthPt?: number;
+    /** §9.8.2 — the face sets every glyph as wide as the next (see `ContentFont`). */
+    readonly fixedPitch?: boolean;
     /** §9.8.1 — the face the glyphs were shown in is a bold one. */
     readonly bold?: boolean;
     /**
@@ -309,6 +357,11 @@ export interface InterpretResult {
      * there is something to draw.
      */
     readonly outlines: Array<VectorPlacement>;
+    /**
+     * §9.4.3 — the codes each font with a readable program showed where the
+     * page paints them: the glyphs a writer embedding the face has to carry.
+     */
+    readonly shown: ReadonlyMap<ContentFont, ReadonlySet<number>>;
 }
 /**
  * §9.6.5 — one showing of a Type 3 glyph: which procedure, and the matrix that

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

@@ -191,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();
@@ -373,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) => {
@@ -393,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 } : {},
@@ -745,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. */

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.
@@ -230,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

@@ -62,7 +62,8 @@ export declare function hasLiftableProgram(file: PdfFile, fontDict: PdfDict): bo
 /**
  * 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.
+ * 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.

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

@@ -119,7 +119,8 @@ function hasLiftableProgram(file, fontDict) {
 /**
 * 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.
+* 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.
@@ -128,7 +129,8 @@ function hasLiftableProgram(file, fontDict) {
 */
 function programStyle(file, fontDict) {
 	const program = fontProgram(file, fontDict);
-	if (!program || program.length < 12) return void 0;
+	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++) {
@@ -144,6 +146,34 @@ function programStyle(file, fontDict) {
 		};
 	}
 }
+/**
+* §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;

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.

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

@@ -21,10 +21,32 @@ var STANDARD = new Map([
 	...table(96, "quoteleft"),
 	...table(160, ". exclamdown cent sterling fraction yen florin section currency quotesingle quotedblleft guillemotleft guilsinglleft guilsinglright fi fl", ". endash dagger daggerdbl periodcentered . paragraph bullet quotesinglbase quotedblbase quotedblright guillemotright ellipsis perthousand . questiondown", ". grave acute circumflex tilde macron breve dotaccent dieresis . ring cedilla . hungarumlaut ogonek caron", "emdash . . . . . . . . . . . . . . .", ". AE . ordfeminine . . . . Lslash Oslash OE ordmasculine . . . .", ". ae . . . dotlessi . . lslash oslash oe germandbls . . . .")
 ]);
+/** Annex D.2 WIN — CP-1252. Only its punctuation block departs from Latin-1. */
+var WIN_ANSI = new Map([...ASCII, ...table(128, "Euro . quotesinglbase florin quotedblbase ellipsis dagger daggerdbl circumflex perthousand Scaron guilsinglleft OE . Zcaron .", ". quoteleft quoteright quotedblleft quotedblright bullet endash emdash tilde trademark scaron guilsinglright oe . zcaron Ydieresis")]);
+/** Annex D.2 MAC — Mac OS Roman, as the PDF variant states it. */
+var MAC_ROMAN = new Map([...ASCII, ...table(128, "Adieresis Aring Ccedilla Eacute Ntilde Odieresis Udieresis aacute agrave acircumflex adieresis atilde aring ccedilla eacute egrave", "ecircumflex edieresis iacute igrave icircumflex idieresis ntilde oacute ograve ocircumflex odieresis otilde uacute ugrave ucircumflex udieresis", "dagger degree cent sterling section bullet paragraph germandbls registered copyright trademark acute dieresis notequal AE Oslash", "infinity plusminus lessequal greaterequal yen mu partialdiff summation product pi integral ordfeminine ordmasculine Omega ae oslash", "questiondown exclamdown logicalnot radical florin approxequal Delta guillemotleft guillemotright ellipsis space Agrave Atilde Otilde OE oe", "endash emdash quotedblleft quotedblright quoteleft quoteright divide lozenge ydieresis Ydieresis fraction currency guilsinglleft guilsinglright fi fl", "daggerdbl periodcentered quotesinglbase quotedblbase perthousand Acircumflex Ecircumflex Aacute Edieresis Egrave Iacute Icircumflex Idieresis Igrave Oacute Ocircumflex", ". Ograve Uacute Ucircumflex Ugrave dotlessi circumflex tilde macron breve dotaccent ring cedilla hungarumlaut ogonek caron")]);
+/**
+* Annex D.2 WIN — the glyph NAMES of CP-1252's upper half, which the table
+* above leaves to Latin-1 for the TEXT. A program addressed by name still has
+* to be told which glyph 0xE9 is: `eacute`, looked up by name or through the
+* character a Unicode `cmap` keys it by. (0xA0 is `space` and 0xAD `hyphen`
+* here, as Annex D names the glyphs they draw.)
+*/
+var WIN_ANSI_LATIN = table(160, "space exclamdown cent sterling currency yen brokenbar section dieresis copyright ordfeminine guillemotleft logicalnot hyphen registered macron", "degree plusminus twosuperior threesuperior acute mu paragraph periodcentered cedilla onesuperior ordmasculine guillemotright onequarter onehalf threequarters questiondown", "Agrave Aacute Acircumflex Atilde Adieresis Aring AE Ccedilla Egrave Eacute Ecircumflex Edieresis Igrave Iacute Icircumflex Idieresis", "Eth Ntilde Ograve Oacute Ocircumflex Otilde Odieresis multiply Oslash Ugrave Uacute Ucircumflex Udieresis Yacute Thorn germandbls", "agrave aacute acircumflex atilde adieresis aring ae ccedilla egrave eacute ecircumflex edieresis igrave iacute icircumflex idieresis", "eth ntilde ograve oacute ocircumflex otilde odieresis divide oslash ugrave uacute ucircumflex udieresis yacute thorn ydieresis");
+/**
+* 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.
+*/
+function winAnsiLatinName(code) {
+	return WIN_ANSI_LATIN.get(code);
+}
 var TABLES = {
 	StandardEncoding: STANDARD,
-	WinAnsiEncoding: new Map([...ASCII, ...table(128, "Euro . quotesinglbase florin quotedblbase ellipsis dagger daggerdbl circumflex perthousand Scaron guilsinglleft OE . Zcaron .", ". quoteleft quoteright quotedblleft quotedblright bullet endash emdash tilde trademark scaron guilsinglright oe . zcaron Ydieresis")]),
-	MacRomanEncoding: new Map([...ASCII, ...table(128, "Adieresis Aring Ccedilla Eacute Ntilde Odieresis Udieresis aacute agrave acircumflex adieresis atilde aring ccedilla eacute egrave", "ecircumflex edieresis iacute igrave icircumflex idieresis ntilde oacute ograve ocircumflex odieresis otilde uacute ugrave ucircumflex udieresis", "dagger degree cent sterling section bullet paragraph germandbls registered copyright trademark acute dieresis notequal AE Oslash", "infinity plusminus lessequal greaterequal yen mu partialdiff summation product pi integral ordfeminine ordmasculine Omega ae oslash", "questiondown exclamdown logicalnot radical florin approxequal Delta guillemotleft guillemotright ellipsis space Agrave Atilde Otilde OE oe", "endash emdash quotedblleft quotedblright quoteleft quoteright divide lozenge ydieresis Ydieresis fraction currency guilsinglleft guilsinglright fi fl", "daggerdbl periodcentered quotesinglbase quotedblbase perthousand Acircumflex Ecircumflex Aacute Edieresis Egrave Iacute Icircumflex Idieresis Igrave Oacute Ocircumflex", ". Ograve Uacute Ucircumflex Ugrave dotlessi circumflex tilde macron breve dotaccent ring cedilla hungarumlaut ogonek caron")])
+	WinAnsiEncoding: WIN_ANSI,
+	MacRomanEncoding: MAC_ROMAN
 };
 /**
 * The glyph names of a base encoding, or `undefined` for a name this has no
@@ -107,4 +129,4 @@ function isStandardLatinFace(baseFont) {
 	return STANDARD_LATIN_FACES.has(baseFont.trim().replace(/^[A-Za-z]{6}\+/u, "").toLowerCase());
 }
 //#endregion
-export { baseEncodingTable, isStandardLatinFace, macGlyphName, standardEncodingTable };
+export { baseEncodingTable, isStandardLatinFace, macGlyphName, standardEncodingTable, winAnsiLatinName };