reamkit 1.26.0 → 1.28.0

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

@@ -1,9 +1,19 @@
+import { resolveFamilyStyle } from "../core/fonts/remote-fonts.js";
 import { parseTtf } from "../core/font/ttf-parser.js";
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
-import { embeddedFontName } from "./embedded-fonts.js";
 import { parseToUnicodeCMap } from "./cmap.js";
+import { decodePredefined, predefinedCMap, splitPredefined } from "./predefined-cmap.js";
+import { isZapfDingbats, zapfDingbatsChar } from "./dingbats.js";
 import { textForGlyphName } from "./glyph-names.js";
+import { cffCidToGid, cffNameToGid, cffOutlineSource, openTypeCff } from "./cff-outline.js";
+import { type1Font } from "./type1-outline.js";
+import { baseEncodingTable, isStandardLatinFace, standardEncodingTable } from "./encodings.js";
+import { outlineSource, postGlyphNames } from "./glyf-outline.js";
+import { standardFace, standardWidth } from "./standard-widths.js";
+import { embeddedFontName, hasLiftableProgram } from "./embedded-fonts.js";
 //#region src/pdf-reader/font.ts
+/** §9.10.2 — what a composite code nothing can answer for comes to. */
+var UNANSWERABLE = "�";
 /**
 * Build a {@link ContentFont} (the interpreter's decode + advance hooks) from a
 * `/Font` dictionary (E-PDF EP2). Unicode comes from the `/ToUnicode` CMap;
@@ -20,30 +30,90 @@ function buildContentFont(file, fontDict) {
 	const isType0 = asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) === "Type0";
 	let toUnicode = /* @__PURE__ */ new Map();
 	let codeBytes = isType0 ? 2 : 1;
+	const encodingName = asName(file.resolve(fontDict.get("Encoding") ?? PDF_NULL));
+	const encodingNamed = isType0 && encodingName.length > 0;
+	const named = isType0 ? predefinedCMap(encodingName) : void 0;
 	const tu = file.resolve(fontDict.get("ToUnicode") ?? PDF_NULL);
 	if (tu instanceof PdfStream) {
 		const parsed = parseToUnicodeCMap(file.streamData(tu));
 		toUnicode = parsed.map;
-		if (isType0) codeBytes = parsed.codeBytes;
+		if (isType0 && !encodingNamed) codeBytes = parsed.codeBytes;
 	}
 	const fromProgram = isType0 && toUnicode.size === 0 ? embeddedCmap(file, fontDict) : void 0;
-	const fromNames = !isType0 ? namedGlyphs(file, fontDict) : void 0;
+	let programFallback = null;
+	const fromProgramFor = (code) => {
+		if (!isType0 || toUnicode.size === 0) return void 0;
+		programFallback ??= embeddedCmap(file, fontDict);
+		return programFallback?.get(code);
+	};
+	const glyphs = isType0 ? void 0 : simpleGlyphs(file, fontDict);
+	const fromNames = !isType0 ? namedGlyphs(file, fontDict, toUnicode.size > 0, {
+		draws: (name) => glyphs?.byName(name) !== void 0,
+		blank: (name) => glyphs?.blank(name) === true
+	}) : void 0;
+	const glyphNames = isType0 ? /* @__PURE__ */ new Map() : differences(file, fontDict);
 	const unicode = fromProgram ?? (toUnicode.size > 0 ? toUnicode : fromNames ?? toUnicode);
 	const bytesPerCode = codeBytes;
+	const indices = !isType0 && glyphs?.indexed === true && fromNames === void 0 && toUnicode.size === 0 && glyphNames.size === 0;
+	const dingbats = !isType0 && isZapfDingbats(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL)));
+	const baseNames = isType0 ? void 0 : baseEncoding(file, fontDict);
+	const fromBase = /* @__PURE__ */ new Map();
+	for (const [code, glyph] of baseNames ?? []) {
+		const text = textForGlyphName(glyph);
+		if (text !== void 0) fromBase.set(code, text);
+	}
+	const namesOf = new Map([...baseNames ?? [], ...glyphNames]);
 	const style = faceStyle(file, fontDict, isType0);
-	const name = embeddedFontName(file, fontDict);
+	const name = runFontName(file, fontDict, isType0);
 	const type3 = asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) === "Type3" ? type3Face(file, fontDict) : void 0;
-	const simple = simpleWidths(file, fontDict);
+	const decodeOne = (code) => (indices ? UNANSWERABLE : void 0) ?? unicode.get(code) ?? fromProgramFor(code) ?? (named ? decodePredefined(named, code) : void 0) ?? fromNames?.get(code) ?? (dingbats ? zapfDingbatsChar(code) : void 0) ?? fromBase.get(code) ?? (bytesPerCode === 1 ? latin1(code) : UNANSWERABLE);
+	const simple = simpleWidths(file, fontDict, decodeOne);
 	const width = isType0 ? cidWidths(file, fontDict) : type3 ? (code) => simple(code) * type3.matrix[0] * 1e3 : simple;
 	return {
 		bytesPerCode,
+		...named ? { splitCodes: (b) => splitPredefined(named, b) } : {},
+		...isType0 ? outlineOf(file, fontDict, decodeOne) : simpleOutlineOf(decodeOne, namesOf, glyphs),
+		...named?.vertical ? { verticalAdvance: cidVerticalAdvance(file, fontDict) } : {},
 		...type3 ? { type3 } : {},
 		...name !== void 0 ? { name } : {},
-		decode: (codes) => codes.map((c) => unicode.get(c) ?? (bytesPerCode === 1 ? String.fromCharCode(c) : "")).join(""),
+		decode: (codes) => codes.map((c) => readable(decodeOne(c))).join(""),
 		width,
 		...style
 	};
 }
+/**
+* The character a code stands for when nothing in the font says.
+*
+* Latin-1 is the only guess there is, and it is a good one for a text font —
+* but a C0 control is not a glyph. §9.4.3 shows GLYPHS, and a code falling back
+* to one has landed there by accident: issue11549_reduced.pdf's one line came
+* back as U+0007 through U+0011 and was drawn as six empty boxes over a page
+* that shows nothing at all. A `/ToUnicode` that STATES a control is stating
+* something and is left alone.
+*/
+function latin1(code) {
+	return code < 32 || code === 127 ? "�" : String.fromCharCode(code);
+}
+/**
+* What a `/ToUnicode` gives, less what Unicode says is not a character.
+*
+* `U+FFFE` and `U+FFFF` are noncharacters and the `U+FDD0`–`U+FDEF` block with
+* them; a lone surrogate is half of a pair that never came. A producer that
+* maps its glyphs to any of these has said "no text here" in the only way the
+* format lets it, and carrying them on writes bytes no reader can show —
+* arial_unicode_ab_cidfont.pdf maps its four Arabic letters to `U+FFFF` and the
+* page came back holding four of them. They become `U+FFFD`, which the
+* reconstruction counts and reports rather than passing along.
+*/
+function readable(text) {
+	let out = "";
+	for (const ch of text) {
+		const cp = ch.codePointAt(0) ?? 0;
+		const noncharacter = (cp & 65534) === 65534 || cp >= 64976 && cp <= 65007 || cp === 0 || cp >= SURROGATE_FIRST && cp <= SURROGATE_LAST;
+		out += noncharacter ? "�" : ch;
+	}
+	return out;
+}
 /** The last Unicode code point in the BMP, and the surrogate block inside it. */
 var BMP_END = 65535;
 var SURROGATE_FIRST = 55296;
@@ -94,6 +164,192 @@ function embeddedCmap(file, fontDict) {
 	});
 	return out.size > 0 ? out : void 0;
 }
+/**
+* §9.6.6 — the outline a code draws, for a code that stands for no character.
+*
+* The glyph is there even when the character is not: `/Encoding /Identity-H`
+* makes the code a CID, `/CIDToGIDMap` turns that into a glyph index, and the
+* embedded program holds the contours. complex_ttf_font.pdf is eight lines of
+* Arabic in a subset with no `cmap` and no `/ToUnicode`, and every one of them
+* was dropped.
+*
+* Deliberately NOT a fallback for text: a code the font CAN answer for is set
+* as type, and only the unanswerable ones are traced.
+*
+* @param file      The owning file.
+* @param fontDict  The Type 0 font dictionary.
+* @param decodeOne What one code comes to, to tell the two cases apart.
+* @returns The `outline` field of a {@link ContentFont}, or nothing where the
+*          program carries no outlines this reads.
+*/
+function outlineOf(file, fontDict, decodeOne) {
+	const cidFont = descendantFont(file, fontDict);
+	const descriptor = file.resolve(cidFont.get("FontDescriptor") ?? PDF_NULL);
+	if (!(descriptor instanceof Map)) return {};
+	const truetype = file.resolve(descriptor.get("FontFile2") ?? PDF_NULL);
+	const compact = file.resolve(descriptor.get("FontFile3") ?? PDF_NULL);
+	const program = truetype instanceof PdfStream ? truetype : compact;
+	if (!(program instanceof PdfStream)) return {};
+	let source;
+	let charsetCids;
+	try {
+		const bytes = file.streamData(program);
+		source = outlineSource(bytes);
+		if (!source) {
+			const cff = openTypeCff(bytes) ?? bytes;
+			source = cffOutlineSource(cff);
+			charsetCids = source ? cffCidToGid(cff) : void 0;
+		}
+	} catch {
+		return {};
+	}
+	if (!source) return {};
+	const cidToGid = readCidToGid(file, cidFont);
+	return { outline: {
+		matrix: [
+			1,
+			0,
+			0,
+			1,
+			0,
+			0
+		],
+		path: (code) => {
+			if (readable(decodeOne(code)) !== UNANSWERABLE) return void 0;
+			const mapped = cidToGid ? cidToGid[code] ?? 0 : code;
+			const gid = charsetCids ? charsetCids.get(mapped) ?? mapped : mapped;
+			return source.path(gid);
+		}
+	} };
+}
+/**
+* §9.6.6 — the outline a SIMPLE font's code draws, for a code that stands for
+* no character.
+*
+* A simple font addresses its glyphs by NAME: `/Differences` (or the program's
+* own `/Encoding`) says code 2 is `g18`, and the program says what `g18` looks
+* like. Where that name is not a character there is nothing to write and there
+* is still something to draw — TAMReview.pdf sets most of its body in a Cambria
+* subset whose glyphs are named `g18`, `g152`, `g135`, and seven thousand of
+* its nine thousand characters were dropped.
+*
+* @param file      The owning file.
+* @param fontDict  The simple font's dictionary.
+* @param decodeOne What one code comes to, to tell the two cases apart.
+* @param nameOf    The glyph name a code selects, where the font states one.
+* @returns The `outline` field of a {@link ContentFont}, or nothing.
+*/
+function simpleOutlineOf(decodeOne, nameOf, source) {
+	if (!source) return {};
+	return { outline: {
+		matrix: [
+			1,
+			0,
+			0,
+			1,
+			0,
+			0
+		],
+		path: (code) => {
+			if (readable(decodeOne(code)) !== UNANSWERABLE) return void 0;
+			const name = nameOf.get(code) ?? source.builtIn?.get(code);
+			if (name === void 0) return source.byIndex?.(code);
+			return source.byName(name);
+		}
+	} };
+}
+/**
+* §9.6.6 — the program a SIMPLE font embeds, ready to draw a glyph BY NAME.
+*
+* All three formats appear here: a Type 1 program keys its charstrings by name
+* outright, a CFF says which name each glyph has in its charset, and a TrueType
+* says nothing at all — but a subsetter that renames glyphs `g24` has written
+* the glyph's index into the name, which is the only handle such a program
+* gives.
+*
+* @param file     The owning file.
+* @param fontDict The simple font's dictionary.
+* @returns How to draw one of its glyphs, or `undefined` where nothing here
+*          can read the program.
+*/
+function simpleGlyphs(file, fontDict) {
+	const descriptor = file.resolve(fontDict.get("FontDescriptor") ?? PDF_NULL);
+	if (!(descriptor instanceof Map)) return void 0;
+	const typeOne = file.resolve(descriptor.get("FontFile") ?? PDF_NULL);
+	const truetype = file.resolve(descriptor.get("FontFile2") ?? PDF_NULL);
+	const compact = file.resolve(descriptor.get("FontFile3") ?? PDF_NULL);
+	try {
+		if (typeOne instanceof PdfStream) {
+			const face = type1Font(file.streamData(typeOne));
+			if (!face) return void 0;
+			return {
+				byName: face.path,
+				blank: (name) => face.has(name) && face.path(name) === void 0,
+				...face.encoding ? { builtIn: face.encoding } : {}
+			};
+		}
+		const stream = compact instanceof PdfStream ? compact : truetype;
+		if (!(stream instanceof PdfStream)) return void 0;
+		const bytes = file.streamData(stream);
+		const glyf = outlineSource(bytes);
+		if (glyf) {
+			const named = postGlyphNames(bytes);
+			const gidOf = (name) => {
+				const gid = named?.get(name) ?? numberedGlyph(name);
+				return gid !== void 0 && gid < glyf.count ? gid : void 0;
+			};
+			return {
+				byName: (name) => {
+					const gid = gidOf(name);
+					return gid === void 0 ? void 0 : glyf.path(gid);
+				},
+				blank: (name) => {
+					const gid = gidOf(name);
+					return gid !== void 0 && glyf.path(gid) === void 0;
+				},
+				byIndex: (gid) => gid < glyf.count ? glyf.path(gid) : void 0,
+				indexed: !glyf.cmap
+			};
+		}
+		const cff = openTypeCff(bytes) ?? bytes;
+		const outlines = cffOutlineSource(cff);
+		if (!outlines) return void 0;
+		const names = cffNameToGid(cff);
+		const gidOf = (name) => {
+			const gid = names?.get(name) ?? numberedGlyph(name);
+			return gid !== void 0 && gid < outlines.count ? gid : void 0;
+		};
+		return {
+			byName: (name) => {
+				const gid = gidOf(name);
+				return gid === void 0 ? void 0 : outlines.path(gid);
+			},
+			blank: (name) => {
+				const gid = gidOf(name);
+				return gid !== void 0 && outlines.path(gid) === void 0;
+			}
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* The glyph index a name carries, for the names that carry one.
+*
+* A subsetter that drops a font's `cmap` renames its glyphs after their
+* INDEX — `g24`, `glyph24`, `index24`, `cid24` — and that name is then the only
+* way back to the outline. bug1151216.pdf names them `g24`, `g381`, `g3`, and
+* its three lines of prices are drawn from nothing else.
+*/
+function numberedGlyph(name) {
+	const hex = /^g([0-9a-f]{4})$/u.exec(name);
+	if (hex) return Number.parseInt(hex[1], 16);
+	const m = /^(?:g|glyph|index|cid|G)(\d+)$/u.exec(name);
+	const n = m ? Number(m[1]) : NaN;
+	return Number.isFinite(n) && n >= 0 && n < MAX_GLYPH_INDEX ? n : void 0;
+}
+/** No font holds more glyphs than this; a bigger number is not an index. */
+var MAX_GLYPH_INDEX = 65536;
 /** §9.7.4.2 `/CIDToGIDMap` — a stream of two-byte glyph indices, CID by CID. */
 function readCidToGid(file, cidFont) {
 	const map = file.resolve(cidFont.get("CIDToGIDMap") ?? PDF_NULL);
@@ -158,15 +414,84 @@ function fontMatrix(file, fontDict) {
 * Returns `undefined` where the font names nothing, so the caller keeps its
 * Latin-1 reading rather than replacing it with an empty map.
 */
-function namedGlyphs(file, fontDict) {
+function namedGlyphs(file, fontDict, statesUnicode, glyph) {
 	const names = differences(file, fontDict);
 	if (names.size === 0) return void 0;
 	const out = /* @__PURE__ */ new Map();
 	for (const [code, name] of names) {
 		const text = textForGlyphName(name);
-		if (text !== void 0) out.set(code, text);
+		if (text !== void 0) {
+			out.set(code, text);
+			continue;
+		}
+		if (glyph.blank(name)) {
+			out.set(code, " ");
+			continue;
+		}
+		if (!statesUnicode && glyph.draws(name)) out.set(code, UNANSWERABLE);
 	}
-	return out.size > 0 ? out : void 0;
+	if (out.size > 0) return out;
+	if (asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) !== "Type3") return void 0;
+	const unreadable = /* @__PURE__ */ new Map();
+	for (const code of names.keys()) unreadable.set(code, "�");
+	return unreadable;
+}
+/**
+* §9.7.4.3 `/DW2` and `/W2` — how far the pen drops for one glyph, in 1000-unit
+* text space.
+*
+* `/DW2`'s default is `[880 -1000]`: the vertical origin sits 880 above the
+* horizontal one and the displacement is a full em DOWN. Only the displacement
+* is wanted here — the origin shifts where the glyph is drawn, which a reader
+* re-setting the words in another face does not reproduce anyway.
+*/
+function cidVerticalAdvance(file, fontDict) {
+	const cid = descendantFont(file, fontDict);
+	const dw2 = file.resolve(cid.get("DW2") ?? PDF_NULL);
+	const stated = Array.isArray(dw2) && typeof file.resolve(dw2[1] ?? PDF_NULL) === "number" ? file.resolve(dw2[1]) : DEFAULT_DW2_DISPLACEMENT;
+	const perCode = /* @__PURE__ */ new Map();
+	const w2 = file.resolve(cid.get("W2") ?? PDF_NULL);
+	if (Array.isArray(w2)) for (let i = 0; i < w2.length;) {
+		const first = file.resolve(w2[i] ?? PDF_NULL);
+		const next = file.resolve(w2[i + 1] ?? PDF_NULL);
+		if (typeof first !== "number") break;
+		if (Array.isArray(next)) {
+			for (let k = 0; k + 2 < next.length; k += 3) {
+				const v = file.resolve(next[k] ?? PDF_NULL);
+				if (typeof v === "number") perCode.set(first + k / 3, v);
+			}
+			i += 2;
+		} else if (typeof next === "number" && typeof file.resolve(w2[i + 2] ?? PDF_NULL) === "number") {
+			const v = file.resolve(w2[i + 2]);
+			for (let c = first; c <= next && c - first < MAX_W2_RANGE; c++) perCode.set(c, v);
+			i += 5;
+		} else break;
+	}
+	return (code) => perCode.get(code) ?? stated;
+}
+/** §9.7.4.3 — `/DW2`'s default displacement: one em down the page. */
+var DEFAULT_DW2_DISPLACEMENT = -1e3;
+/** A `/W2` range wider than this is not walked out code by code. */
+var MAX_W2_RANGE = 65536;
+/**
+* Annex D.2 — code → text for the encoding a simple font is read through, under
+* whatever `/Differences` restates.
+*
+* `/Encoding` either names one of the base encodings, or is a dictionary that
+* may name one in `/BaseEncoding`, or is absent — and absent means the encoding
+* built into the FACE. Only the standard Latin faces can be answered for there:
+* a file that names them embeds no program, and what they are is known
+* (§9.6.2.2). An embedded font's built-in encoding lives in the program and a
+* substituted face has none worth guessing at, so both keep the Latin-1
+* reading, which is what the codes of such a file nearly always are.
+*
+* @returns Code → glyph NAME, or `undefined` where nothing better than Latin-1
+*          is known.
+*/
+function baseEncoding(file, fontDict) {
+	const encoding = file.resolve(fontDict.get("Encoding") ?? PDF_NULL);
+	const named = encoding instanceof PdfName ? encoding.value : encoding instanceof Map ? asName(file.resolve(encoding.get("BaseEncoding") ?? PDF_NULL)) : "";
+	return named.length > 0 ? baseEncodingTable(named) : isStandardLatinFace(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL))) ? standardEncodingTable() : void 0;
 }
 /** §9.6.6.1 `/Encoding` `/Differences` — code → glyph name, as the array runs. */
 function differences(file, fontDict) {
@@ -183,9 +508,47 @@ function differences(file, fontDict) {
 	}
 	return out;
 }
+/**
+* §9.8.2 — the family a run states: the file's own name for the face, plus what
+* the file says the face IS.
+*
+* The name is a hint for the substitution and nothing more, unless the reader
+* can lift the program itself (§9.9 `/FontFile2`) — then it is the key the face
+* is filed under and must be left exactly as it is. Everything else is
+* substituted by name, and TeX and PostScript producers embed Type 1 and CFF
+* programs under names no table knows: `NimbusRomNo9L-Regu`, `LMRoman10`,
+* `CMR10`, `stonesans`. Every one of those pages came back set in a grotesque
+* — the loudest single difference between our page and a serif document's.
+*
+* The descriptor states the class outright, so where the name says nothing the
+* flags do: bit 1 is FixedPitch and bit 2 Serif.
+*
+* @param file     The document.
+* @param fontDict The font dictionary.
+* @param isType0  Whether it is a composite font, whose descendant owns the
+*                 descriptor.
+* @returns The family name for the run, or `undefined` where the font has none.
+*/
+function runFontName(file, fontDict, isType0) {
+	const name = embeddedFontName(file, fontDict);
+	if (name === void 0 || hasLiftableProgram(file, fontDict)) return name;
+	if (resolveFamilyStyle(name).key !== "arimo") return name;
+	const owner = isType0 ? descendantFont(file, fontDict) : fontDict;
+	const descriptor = file.resolve(owner.get("FontDescriptor") ?? PDF_NULL);
+	if (!(descriptor instanceof Map)) return name;
+	const flags = asNumber(file.resolve(descriptor.get("Flags") ?? PDF_NULL), 0);
+	if ((flags & FLAG_FIXED_PITCH) !== 0) return `${name} monospace`;
+	if ((flags & FLAG_SERIF) !== 0) return `${name} serif`;
+	return name;
+}
+/** §9.8.2 `/Flags` — bit 1 is FixedPitch, bit 2 Serif (bits numbered from 1). */
+var FLAG_FIXED_PITCH = 1;
+var FLAG_SERIF = 2;
 /** §9.8.2 `/Flags` — bit 7 is Italic, bit 19 ForceBold (bits numbered from 1). */
 var FLAG_ITALIC = 64;
 var FLAG_FORCE_BOLD = 1 << 18;
+/** §9.8.1 `/FontWeight` — the lightest a face may state; below it is no weight. */
+var LIGHTEST_WEIGHT = 100;
 /** §9.8.1 `/FontWeight` — 400 is normal, 700 bold; 600 is where "bold" begins. */
 var BOLD_WEIGHT = 600;
 /**
@@ -207,23 +570,38 @@ var BOLD_WEIGHT = 600;
 function faceStyle(file, fontDict, isType0) {
 	const owner = isType0 ? descendantFont(file, fontDict) : fontDict;
 	const descriptor = file.resolve(owner.get("FontDescriptor") ?? PDF_NULL);
+	const named = styleFromName(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL)));
 	if (descriptor instanceof Map) {
 		const flags = asNumber(file.resolve(descriptor.get("Flags") ?? PDF_NULL), 0);
-		const weight = asNumber(file.resolve(descriptor.get("FontWeight") ?? PDF_NULL), 0);
+		const weightVal = file.resolve(descriptor.get("FontWeight") ?? PDF_NULL);
 		const slant = asNumber(file.resolve(descriptor.get("ItalicAngle") ?? PDF_NULL), 0);
-		const bold = weight >= BOLD_WEIGHT || (flags & FLAG_FORCE_BOLD) !== 0;
-		const italic = slant !== 0 || (flags & FLAG_ITALIC) !== 0;
+		const bold = typeof weightVal === "number" && weightVal >= LIGHTEST_WEIGHT ? asNumber(weightVal, 0) >= BOLD_WEIGHT : (flags & FLAG_FORCE_BOLD) !== 0 || named.bold;
+		const italic = slant !== 0 || (flags & FLAG_ITALIC) !== 0 || named.italic;
 		return {
-			...bold ? { bold } : {},
-			...italic ? { italic } : {}
+			...bold ? { bold: true } : {},
+			...italic ? { italic: true } : {}
 		};
 	}
-	const name = asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL)).replace(/^[A-Z]{6}\+/u, "");
-	const bold = /bold|black|heavy/iu.test(name);
-	const italic = /italic|oblique/iu.test(name);
 	return {
-		...bold ? { bold } : {},
-		...italic ? { italic } : {}
+		...named.bold ? { bold: true } : {},
+		...named.italic ? { italic: true } : {}
+	};
+}
+/**
+* §9.6.2.2 — the style a font's NAME states, by the PostScript convention:
+* `Family-Style`, or `Family,Style` as Word writes it.
+*
+* The separator is what makes this safe. A family whose name merely CONTAINS
+* the word — "New Basrah Bold", "Damascus Bold", both real faces in
+* ArabicCIDTrueType.pdf — is not a bold cut of anything, and reading it as one
+* set two lines heavy that no reader sets heavy. `Times-Bold` is.
+*/
+function styleFromName(baseFont) {
+	const name = baseFont.replace(/^[A-Z]{6}\+/u, "");
+	const style = /[-,]([A-Za-z]+)$/u.exec(name)?.[1] ?? "";
+	return {
+		bold: /bold|black|heavy|semib|demi/iu.test(style),
+		italic: /italic|oblique/iu.test(style)
 	};
 }
 /** §9.7.4 — a `/Type0` font's one descendant CIDFont, which owns the descriptor. */
@@ -232,15 +610,19 @@ function descendantFont(file, fontDict) {
 	const first = Array.isArray(descFonts) ? file.resolve(descFonts[0] ?? PDF_NULL) : PDF_NULL;
 	return first instanceof Map ? first : /* @__PURE__ */ new Map();
 }
-function simpleWidths(file, fontDict) {
+function simpleWidths(file, fontDict, decodeOne) {
 	const first = asNumber(file.resolve(fontDict.get("FirstChar") ?? PDF_NULL), 0);
 	const widthsVal = file.resolve(fontDict.get("Widths") ?? PDF_NULL);
 	const widths = Array.isArray(widthsVal) ? widthsVal : [];
 	const descriptor = file.resolve(fontDict.get("FontDescriptor") ?? PDF_NULL);
 	const missing = descriptor instanceof Map ? asNumber(file.resolve(descriptor.get("MissingWidth") ?? PDF_NULL), 0) : 0;
+	const face = standardFace(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL)));
 	return (code) => {
 		const w = widths[code - first];
-		return typeof w === "number" ? w : missing > 0 ? missing : 500;
+		if (typeof w === "number") return w;
+		const built = face === void 0 ? void 0 : standardWidth(face, code, decodeOne(code));
+		if (built !== void 0) return built;
+		return missing > 0 ? missing : 500;
 	};
 }
 function cidWidths(file, fontDict) {

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

@@ -0,0 +1,16 @@
+import { PdfValue } from '../pdf/objects.js';
+import { PdfFile } from './document.js';
+/** §7.10 — m numbers in, n numbers out. */
+export type PdfFunction = (inputs: ReadonlyArray<number>) => Array<number>;
+/**
+ * Read a `/Function` entry into something callable (§7.10).
+ *
+ * The entry may also be an ARRAY of functions, each giving one output, which is
+ * what a `/DeviceN` with a per-colorant transform states; that comes back as
+ * one function returning all of them in order.
+ *
+ * @param file  The owning file.
+ * @param value The `/Function` (or `/TintTransform`) entry, unresolved.
+ * @returns The function, or `undefined` for one this cannot run.
+ */
+export declare function readFunction(file: PdfFile, value: PdfValue | undefined): PdfFunction | undefined;