reamkit 1.29.0 → 1.31.0

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

@@ -1,16 +1,16 @@
-import { resolveFamilyStyle } from "../core/fonts/remote-fonts.js";
+import { knowsFamily, 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 { 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 { baseEncodingTable, isStandardLatinFace, macGlyphName, standardEncodingTable, winAnsiLatinName } from "./encodings.js";
+import { cffCidToGid, cffFsType, cffNameToGid, cffOutlineSource, cffSpaceAdvance, 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 { cmapSubtables, outlineSource, postGlyphNames, sfntFsType, sfntSpaceAdvance } from "./glyf-outline.js";
 import { standardFace, standardWidth } from "./standard-widths.js";
-import { embeddedFontName, hasLiftableProgram } from "./embedded-fonts.js";
+import { eachPageFont, embeddedFontName, hasLiftableProgram, programStyle } 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 = "�";
@@ -40,6 +40,8 @@ function buildContentFont(file, fontDict) {
 		if (isType0 && !encodingNamed) codeBytes = parsed.codeBytes;
 	}
 	const fromProgram = isType0 && toUnicode.size === 0 ? embeddedCmap(file, fontDict) : void 0;
+	const fromCids = isType0 && toUnicode.size === 0 && fromProgram === void 0 ? unicodeCids(file, fontDict) : void 0;
+	const fromCore = isType0 && toUnicode.size === 0 && fromProgram === void 0 && fromCids === void 0 ? coreGlyphOrder(file, fontDict) : void 0;
 	let programFallback = null;
 	const fromProgramFor = (code) => {
 		if (!isType0 || toUnicode.size === 0) return void 0;
@@ -47,16 +49,28 @@ function buildContentFont(file, fontDict) {
 		return programFallback?.get(code);
 	};
 	const glyphs = isType0 ? void 0 : simpleGlyphs(file, fontDict);
+	let byIndex = null;
+	const numbering = isType0 ? void 0 : numberingOf(differences(file, fontDict).values());
+	const fromIndex = (name) => {
+		const gid = numberedGlyph(name, numbering);
+		if (gid === void 0) return void 0;
+		byIndex ??= programCharacters(file, fontDict);
+		return byIndex?.get(gid);
+	};
 	const fromNames = !isType0 ? namedGlyphs(file, fontDict, toUnicode.size > 0, {
 		draws: (name) => glyphs?.byName(name) !== void 0,
-		blank: (name) => glyphs?.blank(name) === true
+		blank: (name) => glyphs?.blank(name) === true,
+		character: fromIndex
 	}) : void 0;
 	const glyphNames = isType0 ? /* @__PURE__ */ new Map() : differences(file, fontDict);
-	const unicode = fromProgram ?? (toUnicode.size > 0 ? toUnicode : fromNames ?? toUnicode);
+	const unicode = fromProgram ?? fromCids ?? fromCore ?? (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 stated = file.resolve(fontDict.get("Encoding") ?? PDF_NULL);
+	const statesEncoding = stated instanceof Map || stated instanceof PdfName && baseEncodingTable(stated.value) !== void 0;
+	const numbered = !isType0 && toUnicode.size === 0 && glyphNames.size === 0 && stated === PDF_NULL && glyphs?.numbersGlyphs?.() === true;
+	const baseNames = isType0 ? void 0 : statesEncoding ? baseEncoding(file, fontDict) : glyphs?.builtIn ?? baseEncoding(file, fontDict);
 	const fromBase = /* @__PURE__ */ new Map();
 	for (const [code, glyph] of baseNames ?? []) {
 		const text = textForGlyphName(glyph);
@@ -66,18 +80,24 @@ function buildContentFont(file, fontDict) {
 	const style = faceStyle(file, fontDict, isType0);
 	const name = runFontName(file, fontDict, isType0);
 	const type3 = asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) === "Type3" ? type3Face(file, fontDict) : void 0;
-	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 decodeOne = (code) => (indices || numbered ? UNANSWERABLE : void 0) ?? unicode.get(code) ?? fromProgramFor(code) ?? (named ? decodePredefined(named, code) : void 0) ?? fromNames?.get(code) ?? (glyphNames.get(code) === NOTDEF ? "" : void 0) ?? (dingbats ? zapfDingbatsChar(code) : void 0) ?? fromBase.get(code) ?? (bytesPerCode === 1 ? latin1(code) : UNANSWERABLE);
+	const composite = isType0 ? compositeGlyphs(file, fontDict) : void 0;
 	const simple = simpleWidths(file, fontDict, decodeOne);
-	const width = isType0 ? cidWidths(file, fontDict) : type3 ? (code) => simple(code) * type3.matrix[0] * 1e3 : simple;
+	const width = isType0 ? cidWidths(file, fontDict) : type3 ? (code) => simple.width(code) * type3.matrix[0] * 1e3 : simple.width;
+	const spaceWidth = isType0 || type3 || namesOf.get(32) !== "space" && unicode.get(32) !== " " ? void 0 : simple.stated(32);
+	const fixedPitch = !isType0 && !type3 && fixedPitchOf(file, fontDict);
 	return {
 		bytesPerCode,
 		...named ? { splitCodes: (b) => splitPredefined(named, b) } : {},
-		...isType0 ? outlineOf(file, fontDict, decodeOne) : simpleOutlineOf(decodeOne, namesOf, glyphs),
+		...isType0 ? outlineOf(composite, decodeOne) : simpleOutlineOf(decodeOne, namesOf, glyphs, numbered),
+		...name !== void 0 && !type3 ? programOf(file, fontDict, isType0, isType0 ? compositeGlyph(composite, fontDict, file) : simpleGlyph(glyphs, namesOf, baseNames === baseEncodingTable("WinAnsiEncoding")), isType0 ? composite : glyphs) : {},
 		...named?.vertical ? { verticalAdvance: cidVerticalAdvance(file, fontDict) } : {},
 		...type3 ? { type3 } : {},
 		...name !== void 0 ? { name } : {},
-		decode: (codes) => codes.map((c) => readable(decodeOne(c))).join(""),
+		decode: (codes) => codes.map((c) => lettersOf(readable(decodeOne(c)))).join(""),
 		width,
+		...spaceWidth !== void 0 ? { spaceWidth } : {},
+		...fixedPitch ? { fixedPitch: true } : {},
 		...style
 	};
 }
@@ -114,6 +134,32 @@ function readable(text) {
 	}
 	return out;
 }
+/**
+* Unicode's presentation forms of the Latin ligatures, U+FB00–U+FB06, as the
+* letters they join.
+*
+* A producer maps a ligature glyph to its compatibility character, and carried
+* as that the word neither searches nor edits as the letters it is — and a
+* face with no such form sets it in another's, wider: copy_paste_ligatures.pdf
+* is one line in Times, and its "fffiflffifflſtst" pushed the line off its page. The long
+* s of `ſt` is kept: it is a letter of its own.
+*/
+function lettersOf(text) {
+	return LIGATURE.test(text) ? text.replace(LIGATURES, (c) => LATIN_LIGATURES.get(c) ?? c) : text;
+}
+var LIGATURE = /[\uFB00-\uFB06]/u;
+var LIGATURES = /[\uFB00-\uFB06]/gu;
+var LATIN_LIGATURES = new Map([
+	["ff", "ff"],
+	["fi", "fi"],
+	["fl", "fl"],
+	["ffi", "ffi"],
+	["ffl", "ffl"],
+	["ſt", "ſt"],
+	["st", "st"]
+]);
+/** The glyph name that selects no glyph (§9.6.6.1). */
+var NOTDEF = ".notdef";
 /** The last Unicode code point in the BMP, and the surrogate block inside it. */
 var BMP_END = 65535;
 var SURROGATE_FIRST = 55296;
@@ -133,10 +179,130 @@ var SURROGATE_LAST = 57343;
 */
 function embeddedCmap(file, fontDict) {
 	const cidFont = descendantFont(file, fontDict);
+	const byGlyph = programCharacters(file, cidFont);
+	if (byGlyph === void 0) return void 0;
+	const cidToGid = readCidToGid(file, cidFont);
+	if (!cidToGid) return byGlyph;
+	const out = /* @__PURE__ */ new Map();
+	cidToGid.forEach((gid, cid) => {
+		const text = byGlyph.get(gid);
+		if (text !== void 0) out.set(cid, text);
+	});
+	return out.size > 0 ? out : void 0;
+}
+/**
+* §9.7.4 — the characters of a composite font that embeds no program, names a
+* core face and states no `/ToUnicode`: its codes are glyph indices into the
+* face the reader's machine carries under that name, and the core faces put
+* their first 258 glyphs in the standard Macintosh order (the `post` table's
+* format 1 names).
+*
+* issue11242_reduced.pdf shows "VAT Code" in a Verdana it does not embed.
+* Nothing in the file says what its codes are but the face's own order, and
+* read as characters they are "9$7&RGH"; read as nothing, the page came back
+* blank. Only faces known to keep that order are read this way — a face's
+* order is its own, and Calibri's is not this one.
+*
+* @param file     The owning file.
+* @param fontDict The `/Type0` font dictionary.
+* @returns Code → character, or `undefined` where the font is not such a one.
+*/
+function coreGlyphOrder(file, fontDict) {
+	const encoding = asName(file.resolve(fontDict.get("Encoding") ?? PDF_NULL));
+	if (encoding !== "Identity-H" && encoding !== "Identity-V") return void 0;
+	const cidFont = descendantFont(file, fontDict);
+	if (asName(file.resolve(cidFont.get("Subtype") ?? PDF_NULL)) !== "CIDFontType2") return void 0;
+	const map = file.resolve(cidFont.get("CIDToGIDMap") ?? PDF_NULL);
+	if (map !== PDF_NULL && !(map instanceof PdfName && map.value === "Identity")) return void 0;
+	const descriptor = file.resolve(cidFont.get("FontDescriptor") ?? PDF_NULL);
+	if (descriptor instanceof Map && [
+		"FontFile",
+		"FontFile2",
+		"FontFile3"
+	].some((k) => descriptor.has(k))) return void 0;
+	const family = familyOfFace(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL)));
+	if (!CORE_FACES.has(family.toLowerCase().replace(/[^a-z]/gu, ""))) return void 0;
+	const out = /* @__PURE__ */ new Map();
+	for (let gid = 0; gid < MAC_GLYPHS; gid++) {
+		const name = macGlyphName(gid);
+		const text = name === void 0 ? void 0 : textForGlyphName(name);
+		if (text !== void 0 && text !== "") out.set(gid, text);
+	}
+	return out;
+}
+/** The core faces whose first glyphs stand in the standard Macintosh order. */
+var CORE_FACES = new Set([
+	"arial",
+	"timesnewroman",
+	"couriernew",
+	"verdana",
+	"tahoma",
+	"georgia",
+	"trebuchetms"
+]);
+/** How many glyphs the standard Macintosh order names. */
+var MAC_GLYPHS = 258;
+/**
+* §9.7.4.2 — the CIDs of a composite font that ARE characters.
+*
+* A `/CIDToGIDMap` stream says the CID is not the glyph index, and TCPDF —
+* with tFPDF and mPDF after it — makes it the character's own Unicode value,
+* mapping every character of the face to its glyph whether the subset kept
+* the glyph or not. Without a `/ToUnicode`, and with a subset that carries no
+* `cmap`, that was the only statement of what the glyphs are and it went
+* unread: bug1650302_reduced.pdf's "Výbava na přání" came back as drawings,
+* the `ř` missing from them. Read as characters, the words come back.
+*
+* Only where the map itself says so. A producer that keeps the ORIGINAL
+* glyph index as the CID routes it through a stream too, and read as Unicode
+* complex_ttf_font.pdf's Arabic would come back as `$&')`. What tells the two
+* apart is the space: a map of characters sends U+0020 to a glyph that draws
+* nothing and no control character anywhere, where a map of indices sends 3 —
+* the space in the fonts they come from — and 32 to a glyph with ink on it.
+*/
+function unicodeCids(file, fontDict) {
+	const encoding = asName(file.resolve(fontDict.get("Encoding") ?? PDF_NULL));
+	if (encoding !== "Identity-H" && encoding !== "Identity-V") return void 0;
+	const cidFont = descendantFont(file, fontDict);
+	const cidToGid = readCidToGid(file, cidFont);
+	if (!cidToGid || cidToGid.slice(0, SPACE).some((gid) => gid !== 0)) return void 0;
+	const space = cidToGid[SPACE];
+	if (space === void 0 || space === 0) return void 0;
 	const descriptor = file.resolve(cidFont.get("FontDescriptor") ?? PDF_NULL);
 	if (!(descriptor instanceof Map)) return void 0;
 	const program = file.resolve(descriptor.get("FontFile2") ?? PDF_NULL);
 	if (!(program instanceof PdfStream)) return void 0;
+	let blank;
+	try {
+		const glyf = outlineSource(file.streamData(program));
+		blank = glyf !== void 0 && space < glyf.count && glyf.path(space) === void 0;
+	} catch {
+		return;
+	}
+	if (!blank) return void 0;
+	const out = /* @__PURE__ */ new Map();
+	cidToGid.forEach((gid, cid) => {
+		if (gid !== 0 && !(cid >= SURROGATE_FIRST && cid <= SURROGATE_LAST)) out.set(cid, String.fromCharCode(cid));
+	});
+	return out;
+}
+/** U+0020, the one character whose glyph every text face leaves blank. */
+var SPACE = 32;
+/**
+* The character each glyph of a font's embedded TrueType program stands for:
+* its `cmap` read backwards.
+*
+* @param file  The document.
+* @param owner The dictionary that holds the descriptor — the font itself, or
+*              a composite font's descendant.
+* @returns Glyph index → character, or `undefined` where there is no program
+*          or it maps nothing.
+*/
+function programCharacters(file, owner) {
+	const descriptor = file.resolve(owner.get("FontDescriptor") ?? PDF_NULL);
+	if (!(descriptor instanceof Map)) return void 0;
+	const program = file.resolve(descriptor.get("FontFile2") ?? PDF_NULL);
+	if (!(program instanceof PdfStream)) return void 0;
 	let glyphOf;
 	try {
 		glyphOf = parseTtf(file.streamData(program)).glyphForCodepoint;
@@ -154,57 +320,80 @@ function embeddedCmap(file, fontDict) {
 		}
 		if (gid > 0 && !byGlyph.has(gid)) byGlyph.set(gid, String.fromCodePoint(cp));
 	}
-	if (byGlyph.size === 0) return void 0;
-	const cidToGid = readCidToGid(file, cidFont);
-	if (!cidToGid) return byGlyph;
-	const out = /* @__PURE__ */ new Map();
-	cidToGid.forEach((gid, cid) => {
-		const text = byGlyph.get(gid);
-		if (text !== void 0) out.set(cid, text);
-	});
-	return out.size > 0 ? out : void 0;
+	return byGlyph.size > 0 ? byGlyph : void 0;
 }
 /**
-* §9.6.6 — the outline a code draws, for a code that stands for no character.
+* §9.7.4 — a composite font's embedded program, read by glyph: the code is a
+* CID, `/CIDToGIDMap` (or, for a CID-keyed CFF, its charset) turns that into a
+* glyph index, and the program holds the contours.
 *
-* 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.
+* @param file     The owning file.
+* @param fontDict The Type 0 font dictionary.
+* @returns The program's outlines and how a CID reaches them, or `undefined`
+*          where the font embeds no program this reads.
 */
-function outlineOf(file, fontDict, decodeOne) {
+function compositeGlyphs(file, fontDict) {
 	const cidFont = descendantFont(file, fontDict);
 	const descriptor = file.resolve(cidFont.get("FontDescriptor") ?? PDF_NULL);
-	if (!(descriptor instanceof Map)) return {};
+	if (!(descriptor instanceof Map)) return void 0;
 	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 {};
+	if (!(program instanceof PdfStream)) return void 0;
 	let source;
 	let charsetCids;
+	let fsType;
+	let spaceAdvance;
 	try {
 		const bytes = file.streamData(program);
 		source = outlineSource(bytes);
+		fsType = sfntFsType(bytes);
+		spaceAdvance = sfntSpaceAdvance(bytes);
 		if (!source) {
 			const cff = openTypeCff(bytes) ?? bytes;
 			source = cffOutlineSource(cff);
 			charsetCids = source ? cffCidToGid(cff) : void 0;
+			fsType ??= cffFsType(cff);
 		}
 	} catch {
-		return {};
+		return;
 	}
-	if (!source) return {};
+	if (!source) return void 0;
 	const cidToGid = readCidToGid(file, cidFont);
+	return {
+		source,
+		glyphOf: (cid) => {
+			const mapped = cidToGid ? cidToGid[cid] : cid;
+			if (mapped === void 0) return void 0;
+			return charsetCids ? charsetCids.get(mapped) : mapped;
+		},
+		looseGlyphOf: (cid) => {
+			const mapped = cidToGid ? cidToGid[cid] ?? 0 : cid;
+			return charsetCids ? charsetCids.get(mapped) ?? mapped : mapped;
+		},
+		...fsType !== void 0 ? { fsType } : {},
+		...spaceAdvance !== void 0 ? { spaceAdvance } : {}
+	};
+}
+/**
+* §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 glyphs    The font's program, read by glyph (see `compositeGlyphs`).
+* @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(glyphs, decodeOne) {
+	if (!glyphs) return {};
 	return { outline: {
 		matrix: [
 			1,
@@ -216,13 +405,28 @@ function outlineOf(file, fontDict, decodeOne) {
 		],
 		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);
+			return glyphs.source.path(glyphs.looseGlyphOf(code));
 		}
 	} };
 }
 /**
+* §9.7.5.2 — the glyph ANY code of a composite font draws, for a writer that
+* embeds the face.
+*
+* Only under `Identity-H` or `Identity-V`, where the code is the CID: any other
+* CMap turns codes into CIDs by a table of its own, and a glyph looked up by
+* the code there would be some other character's.
+*/
+function compositeGlyph(glyphs, fontDict, file) {
+	const encoding = asName(file.resolve(fontDict.get("Encoding") ?? PDF_NULL));
+	if (!glyphs || encoding !== "Identity-H" && encoding !== "Identity-V") return void 0;
+	return (code) => {
+		const gid = glyphs.glyphOf(code);
+		if (gid === void 0 || gid <= 0 || gid >= glyphs.source.count) return void 0;
+		return glyphs.source.path(gid) ?? [];
+	};
+}
+/**
 * §9.6.6 — the outline a SIMPLE font's code draws, for a code that stands for
 * no character.
 *
@@ -237,9 +441,12 @@ function outlineOf(file, fontDict, decodeOne) {
 * @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.
+* @param numbered  Whether the program numbers its glyphs (see
+*                  {@link numbersGlyphs}), which its `cmap` then reaches by
+*                  the code.
 * @returns The `outline` field of a {@link ContentFont}, or nothing.
 */
-function simpleOutlineOf(decodeOne, nameOf, source) {
+function simpleOutlineOf(decodeOne, nameOf, source, numbered) {
 	if (!source) return {};
 	return { outline: {
 		matrix: [
@@ -252,6 +459,10 @@ function simpleOutlineOf(decodeOne, nameOf, source) {
 		],
 		path: (code) => {
 			if (readable(decodeOne(code)) !== UNANSWERABLE) return void 0;
+			if (numbered) {
+				const segs = source.glyph(code, void 0);
+				return segs !== void 0 && segs.length > 0 ? [...segs] : void 0;
+			}
 			const name = nameOf.get(code) ?? source.builtIn?.get(code);
 			if (name === void 0) return source.byIndex?.(code);
 			return source.byName(name);
@@ -278,6 +489,7 @@ function simpleGlyphs(file, fontDict) {
 	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);
+	const numbering = numberingOf(differences(file, fontDict).values());
 	try {
 		if (typeOne instanceof PdfStream) {
 			const face = type1Font(file.streamData(typeOne));
@@ -285,20 +497,34 @@ function simpleGlyphs(file, fontDict) {
 			return {
 				byName: face.path,
 				blank: (name) => face.has(name) && face.path(name) === void 0,
-				...face.encoding ? { builtIn: face.encoding } : {}
+				...face.encoding ? { builtIn: face.encoding } : {},
+				glyph: (_code, name) => name === void 0 || name === NOTDEF || !face.has(name) ? void 0 : face.path(name) ?? [],
+				...face.fsType !== void 0 ? { fsType: face.fsType } : {},
+				...spaceOf(face.advance("space"))
 			};
 		}
 		const stream = compact instanceof PdfStream ? compact : truetype;
 		if (!(stream instanceof PdfStream)) return void 0;
 		const bytes = file.streamData(stream);
 		const glyf = outlineSource(bytes);
+		const fsType = sfntFsType(bytes);
 		if (glyf) {
 			const named = postGlyphNames(bytes);
 			const gidOf = (name) => {
-				const gid = named?.get(name) ?? numberedGlyph(name);
+				const gid = named?.get(name) ?? numberedGlyph(name, numbering);
 				return gid !== void 0 && gid < glyf.count ? gid : void 0;
 			};
+			const flags = asNumber(file.resolve(descriptor.get("Flags") ?? PDF_NULL), 0);
+			const encoding = file.resolve(fontDict.get("Encoding") ?? PDF_NULL);
+			const byCode = trueTypeGlyphs(bytes, (flags & FLAG_SYMBOLIC) !== 0 && (flags & FLAG_NONSYMBOLIC) === 0, encoding instanceof Map || encoding instanceof PdfName, gidOf);
 			return {
+				glyph: (code, name) => {
+					const gid = byCode(code, name);
+					if (gid === void 0 || gid <= 0 || gid >= glyf.count) return void 0;
+					return glyf.path(gid) ?? [];
+				},
+				...fsType !== void 0 ? { fsType } : {},
+				...spaceOf(sfntSpaceAdvance(bytes)),
 				byName: (name) => {
 					const gid = gidOf(name);
 					return gid === void 0 ? void 0 : glyf.path(gid);
@@ -308,7 +534,8 @@ function simpleGlyphs(file, fontDict) {
 					return gid !== void 0 && glyf.path(gid) === void 0;
 				},
 				byIndex: (gid) => gid < glyf.count ? glyf.path(gid) : void 0,
-				indexed: !glyf.cmap
+				indexed: !glyf.cmap,
+				numbersGlyphs: () => numbersGlyphs(bytes, glyf, named, (code) => byCode(code, void 0))
 			};
 		}
 		const cff = openTypeCff(bytes) ?? bytes;
@@ -316,10 +543,17 @@ function simpleGlyphs(file, fontDict) {
 		if (!outlines) return void 0;
 		const names = cffNameToGid(cff);
 		const gidOf = (name) => {
-			const gid = names?.get(name) ?? numberedGlyph(name);
+			const gid = names?.get(name) ?? numberedGlyph(name, numbering);
 			return gid !== void 0 && gid < outlines.count ? gid : void 0;
 		};
+		const stated = fsType ?? cffFsType(cff);
 		return {
+			glyph: (_code, name) => {
+				const gid = name === void 0 || name === NOTDEF ? void 0 : gidOf(name);
+				return gid === void 0 || gid === 0 ? void 0 : outlines.path(gid) ?? [];
+			},
+			...stated !== void 0 ? { fsType: stated } : {},
+			...spaceOf(sfntSpaceAdvance(bytes) ?? cffSpaceAdvance(cff)),
 			byName: (name) => {
 				const gid = gidOf(name);
 				return gid === void 0 ? void 0 : outlines.path(gid);
@@ -333,6 +567,190 @@ function simpleGlyphs(file, fontDict) {
 		return;
 	}
 }
+/** The `spaceAdvance` field, where a program states a sensible one. */
+function spaceOf(advance) {
+	return advance !== void 0 && advance > 0 && advance < 1e3 ? { spaceAdvance: advance } : {};
+}
+/**
+* §9.6.6.4 — how a SIMPLE TrueType font's code reaches a glyph: through the
+* program's `cmap`, and which subtable decides what the code is looked up as.
+*
+* A face that states an encoding turns the code into its glyph NAME, and the
+* name into a character for the Unicode subtable (3,1), a Mac Roman code for
+* (1,0), or an entry of the program's own `post` names — and past ASCII, only
+* that: the same byte is another letter in Mac Roman, and a glyph found by the
+* code there is the wrong one. A symbolic face with a Windows symbol subtable
+* (3,0), and a face that states no encoding, is looked up by the CODE: in
+* (3,0), where it stands in one of four ranges (itself, or behind 0xF000,
+* 0xF100 or 0xF200), or byte for byte in (1,0) — its names the fallback, as a
+* viewer tries them. A program with no `cmap` at all is read by index: the
+* code IS the glyph.
+*
+* @param program     The raw `/FontFile2` bytes.
+* @param symbolic    Whether `/Flags` call the face symbolic (bit 3, not bit 6).
+* @param hasEncoding Whether the font dictionary states an `/Encoding`.
+* @param byName      The glyph a name selects through `post` or the
+*                    numbered-name convention (see {@link numberedGlyph}).
+* @returns Code (and the name the encoding gives it) → glyph index, or
+*          `undefined` where nothing reaches one.
+*/
+function trueTypeGlyphs(program, symbolic, hasEncoding, byName) {
+	let tables;
+	return (code, name) => {
+		tables ??= cmapSubtables(program);
+		const unicode = tables.get("3,1") ?? tables.get("0,3") ?? tables.get("0,1") ?? tables.get("0,0");
+		const symbol = tables.get("3,0");
+		const roman = tables.get("1,0");
+		const bySymbol = () => {
+			if (symbol) {
+				for (const high of SYMBOL_RANGES) {
+					const gid = symbol(high | code);
+					if (gid > 0) return gid;
+				}
+				return 0;
+			}
+			return roman ? roman(code) : 0;
+		};
+		const byGlyphName = () => {
+			if (name === void 0 || name === NOTDEF) return 0;
+			const text = textForGlyphName(name);
+			const cp = text !== void 0 && [...text].length === 1 ? text.codePointAt(0) : void 0;
+			const viaUnicode = unicode && cp !== void 0 ? unicode(cp) : 0;
+			if (viaUnicode > 0) return viaUnicode;
+			const mac = macRomanCode(name);
+			const viaRoman = roman && mac !== void 0 ? roman(mac) : 0;
+			if (viaRoman > 0) return viaRoman;
+			return byName(name) ?? 0;
+		};
+		const gid = symbolic && symbol !== void 0 ? bySymbol() || byGlyphName() : hasEncoding ? byGlyphName() || (code < ASCII_END ? bySymbol() : 0) : bySymbol() || byGlyphName() || (unicode ? unicode(code) : 0);
+		if (gid > 0) return gid;
+		return tables.size === 0 ? code : void 0;
+	};
+}
+/** Below this, a byte is the same character in every encoding a simple font uses. */
+var ASCII_END = 128;
+/**
+* §9.6.6.4 — whether a TrueType program NUMBERS its glyphs, where a font would
+* code characters with them: its codes are the order some producer came to
+* each glyph in, and read as Latin-1 they spell nothing.
+*
+* Nothing in such a program says what its codes are — no Unicode subtable, no
+* glyph names — and its SPACE says what they are not. A text face's blank
+* glyph is its space, and Latin-1 puts the space at 32. A program that reaches
+* no glyph at 32, and a blank one where Latin-1 reads a mark, is not coded in
+* Latin-1: comments.pdf's chart faces put their spaces at 35 and 34, "#" and
+* `"`.
+*
+* @param program The raw `/FontFile2` bytes.
+* @param glyf    Its outlines.
+* @param named   The glyphs its `post` table names.
+* @param gidOf   The glyph a code reaches, looked up as the text is.
+*/
+function numbersGlyphs(program, glyf, named, gidOf) {
+	if (named !== void 0 && named.size > 0) return false;
+	const tables = cmapSubtables(program);
+	if (UNICODE_SUBTABLES.some((key) => tables.has(key))) return false;
+	if (!tables.has("1,0") && !tables.has("3,0")) return false;
+	const reached = (code) => {
+		const gid = gidOf(code);
+		return gid !== void 0 && gid > 0 && gid < glyf.count ? gid : void 0;
+	};
+	if (reached(SPACE) !== void 0) return false;
+	const blanks = [];
+	for (let code = 0; code <= 255; code++) {
+		const gid = reached(code);
+		if (gid !== void 0 && glyf.path(gid) === void 0) blanks.push(code);
+	}
+	return blanks.length > 0 && blanks.length <= MOST_BLANKS && blanks.every(inkedInLatin1);
+}
+/** The `cmap` subtables that key a program's glyphs by character. */
+var UNICODE_SUBTABLES = [
+	"3,1",
+	"0,3",
+	"0,1",
+	"0,0"
+];
+/**
+* How many blank glyphs a text face has: its space and, beside it, a no-break
+* one. A program with more has emptied the glyphs it does not use, and its
+* codes may be Latin-1 for all its blanks say.
+*/
+var MOST_BLANKS = 2;
+/** Whether Latin-1 reads a code as a mark: not a control, a space or a soft hyphen. */
+function inkedInLatin1(code) {
+	return code > 32 && code < 127 || code > 160 && code <= 255 && code !== 173;
+}
+/** §9.6.6.4 — where a symbolic face's (3,0) subtable may put a one-byte code. */
+var SYMBOL_RANGES = [
+	0,
+	61440,
+	61696,
+	61952
+];
+/** §9.8.2 `/Flags` — bit 3 is Symbolic, bit 6 Nonsymbolic (bits numbered from 1). */
+var FLAG_SYMBOLIC = 4;
+var FLAG_NONSYMBOLIC = 32;
+/** The Mac Roman code of a glyph name, which is what a (1,0) `cmap` is keyed by. */
+function macRomanCode(name) {
+	if (!macRomanCodes) {
+		macRomanCodes = /* @__PURE__ */ new Map();
+		for (const [code, glyph] of baseEncodingTable("MacRomanEncoding") ?? []) if (!macRomanCodes.has(glyph)) macRomanCodes.set(glyph, code);
+	}
+	return macRomanCodes.get(name);
+}
+var macRomanCodes;
+/**
+* §9.6.6 — the glyph ANY code of a simple font draws, for a writer that embeds
+* the face: the name the encoding gives the code, as the outline path reads it.
+*
+* WinAnsiEncoding's Latin-1 half is named too (Annex D.2), though the text
+* reads it as Latin-1 without a name: unnamed, an é in a program addressed by
+* name selected nothing — and in a TrueType one, the Mac Roman subtable's È.
+*
+* @param glyphs  The program, read by name and code.
+* @param nameOf  The name each code has: `/Differences` over the base encoding.
+* @param winAnsi Whether that base encoding is WinAnsiEncoding.
+*/
+function simpleGlyph(glyphs, nameOf, winAnsi) {
+	if (!glyphs) return void 0;
+	return (code) => glyphs.glyph(code, nameOf.get(code) ?? (winAnsi ? winAnsiLatinName(code) : void 0) ?? glyphs.builtIn?.get(code));
+}
+/**
+* §9.9 — the {@link FaceProgram} of a font whose program this reads: the glyph
+* lookup, the licence, and what the descriptor states (§9.8.1).
+*
+* @param file     The owning file.
+* @param fontDict The font dictionary.
+* @param isType0  Whether it is a composite font, whose descendant owns the
+*                 descriptor.
+* @param glyph    The glyph each code draws, where the program can be read.
+* @param facts    What the program states of itself: its licence and its space.
+* @returns The `program` field of a {@link ContentFont}, or nothing.
+*/
+function programOf(file, fontDict, isType0, glyph, facts) {
+	if (!glyph) return {};
+	const owner = isType0 ? descendantFont(file, fontDict) : fontDict;
+	const descriptor = file.resolve(owner.get("FontDescriptor") ?? PDF_NULL);
+	if (!(descriptor instanceof Map)) return {};
+	const stated = (key) => {
+		const v = file.resolve(descriptor.get(key) ?? PDF_NULL);
+		return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+	};
+	const flags = stated("Flags") ?? 0;
+	const capHeight = stated("CapHeight");
+	const xHeight = stated("XHeight");
+	const base = asName(file.resolve(owner.get("BaseFont") ?? fontDict.get("BaseFont") ?? PDF_NULL));
+	return { program: {
+		glyph,
+		...facts?.fsType !== void 0 ? { fsType: facts.fsType } : {},
+		...facts?.spaceAdvance !== void 0 ? { spaceAdvance: facts.spaceAdvance } : {},
+		postScriptName: base.replace(/^[A-Z]{6}\+/u, ""),
+		...capHeight !== void 0 && capHeight > 0 ? { capHeight } : {},
+		...xHeight !== void 0 && xHeight > 0 ? { xHeight } : {},
+		italicAngle: stated("ItalicAngle") ?? 0,
+		fixedPitch: (flags & FLAG_FIXED_PITCH) !== 0
+	} };
+}
 /**
 * The glyph index a name carries, for the names that carry one.
 *
@@ -340,9 +758,13 @@ function simpleGlyphs(file, fontDict) {
 * 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.
+*
+* @param name      The glyph's name.
+* @param numbering How the font writes the number, where its names say (see
+*                  {@link numberingOf}); four digits are hexadecimal otherwise.
 */
-function numberedGlyph(name) {
-	const hex = /^g([0-9a-f]{4})$/u.exec(name);
+function numberedGlyph(name, numbering) {
+	const hex = numbering !== "decimal" ? /^g([0-9a-f]{4})$/u.exec(name) : null;
 	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;
@@ -350,6 +772,33 @@ function numberedGlyph(name) {
 }
 /** No font holds more glyphs than this; a bigger number is not an index. */
 var MAX_GLYPH_INDEX = 65536;
+/**
+* How a font's index names write their numbers, where its names say.
+*
+* A subsetter that pads the number to four digits writes it in hexadecimal —
+* bug1027533.pdf's `g0024` is glyph 36 — and one that does not pad writes it
+* in decimal. One name cannot tell the two apart: bug1151216.pdf names its
+* glyphs `g24`, `g381` and `g1004`, and `g1004` is four digits either way.
+* Read as hexadecimal it is glyph 4100, which no subset of a thousand glyphs
+* holds: five of the file's codes drew nothing, fell back to Latin-1, and its
+* prices came back "$@'' for 1" set over the glyphs that were drawn. The rest
+* of the font's names say which it is — a leading zero or a letter is
+* hexadecimal, a number of any length but four is decimal.
+*
+* @param names The glyph names the font's `/Differences` gives.
+* @returns The numbering, or `undefined` where the names do not say.
+*/
+function numberingOf(names) {
+	let hex = false;
+	let decimal = false;
+	for (const name of names) {
+		const digits = /^g([0-9a-f]+)$/u.exec(name)?.[1];
+		if (digits === void 0) continue;
+		if (/[a-f]/u.test(digits) || digits.length === 4 && digits.startsWith("0")) hex = true;
+		else if (digits.length !== 4) decimal = true;
+	}
+	return hex === decimal ? void 0 : hex ? "hex" : "decimal";
+}
 /** §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);
@@ -419,7 +868,7 @@ function namedGlyphs(file, fontDict, statesUnicode, glyph) {
 	if (names.size === 0) return void 0;
 	const out = /* @__PURE__ */ new Map();
 	for (const [code, name] of names) {
-		const text = textForGlyphName(name);
+		const text = textForGlyphName(name) ?? glyph.character(name);
 		if (text !== void 0) {
 			out.set(code, text);
 			continue;
@@ -532,7 +981,8 @@ function differences(file, fontDict) {
 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 face = familyOfFace(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL)));
+	if (knowsFamily(name) || knowsFamily(face)) return name;
 	const owner = isType0 ? descendantFont(file, fontDict) : fontDict;
 	const descriptor = file.resolve(owner.get("FontDescriptor") ?? PDF_NULL);
 	if (!(descriptor instanceof Map)) return name;
@@ -541,6 +991,101 @@ function runFontName(file, fontDict, isType0) {
 	if ((flags & FLAG_SERIF) !== 0) return `${name} serif`;
 	return name;
 }
+/**
+* For every face a run may name, the family a word processor knows it by —
+* keyed by the name the run carries (see {@link FaceFamily}).
+*
+* A PDF names the FACE and a .docx names a family: written as the face,
+* `inter-semibold` was a font no reader has, and LibreOffice set the whole of
+* an invoice drawn in Inter in its default serif. The family is the one the
+* descriptor states (§9.8.1 `/FontFamily`) or, where it states none, the one
+* the PostScript name is made of.
+*
+* @param file  The document.
+* @param pages The pages whose faces are wanted.
+* @returns Run font name → its family.
+*/
+function collectFaceFamilies(file, pages) {
+	const out = /* @__PURE__ */ new Map();
+	eachPageFont(file, pages, (fontDict) => {
+		const isType0 = asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) === "Type0";
+		const key = runFontName(file, fontDict, isType0);
+		if (key === void 0 || out.has(key)) return;
+		const owner = isType0 ? descendantFont(file, fontDict) : fontDict;
+		const descriptor = file.resolve(owner.get("FontDescriptor") ?? PDF_NULL);
+		const stated = descriptor instanceof Map ? file.resolve(descriptor.get("FontFamily") ?? PDF_NULL) : PDF_NULL;
+		const family = typeof stated === "string" && /^[\x20-\x7e]+$/u.test(stated.trim()) ? stated.trim() : familyOfFace(cidFontName(file, fontDict, isType0));
+		if (family.length === 0) return;
+		const flags = descriptor instanceof Map ? asNumber(file.resolve(descriptor.get("Flags") ?? PDF_NULL), 0) : 0;
+		out.set(key, {
+			family,
+			generic: genericOf(family, flags)
+		});
+	});
+	return out;
+}
+/**
+* §9.7.6.1 — a composite font's `/BaseFont` is its CIDFont's name, a hyphen and
+* the name of the CMap it is encoded by (`HeiseiMin-W3-UniJIS-UCS2-H`); the
+* face is the part before the CMap's.
+*/
+function cidFontName(file, fontDict, isType0) {
+	const base = asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL));
+	const cmap = isType0 ? asName(file.resolve(fontDict.get("Encoding") ?? PDF_NULL)) : "";
+	return cmap !== "" && base.endsWith(`-${cmap}`) ? base.slice(0, -cmap.length - 1) : base;
+}
+/**
+* The family a PostScript face name is made of: `Inter-SemiBold` → `Inter`,
+* `ArialMT` → `Arial`, `TimesNewRomanPS-BoldMT` → `Times New Roman`.
+*
+* §9.6.2.1 names a face `Family-Style` (Word writes `Family,Style`), with the
+* family's words run together. What follows the separator is a style only if
+* it is made of style words — `MS-Mincho` is a family of its own — and the
+* words come apart where the capitals say they do.
+*/
+function familyOfFace(baseFont) {
+	const name = plainFace(baseFont);
+	const cut = /^(.+?)[-,]([^-,]+)$/u.exec(name);
+	const whole = cut && STYLE_WORDS.test(cut[2]) ? cut[1] : cut ? name.replace(/-/gu, " ") : GLUED_STYLE.exec(name)?.[1] ?? name;
+	return (whole.replace(/(?:PSMT|PS|MT)$/u, "") || whole).replace(/([a-z])([A-Z])/gu, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/gu, "$1 $2").replace(/\bDeja Vu\b/u, "DejaVu").replace(/\s+/gu, " ").trim();
+}
+/**
+* A face name with what producers write around it taken off: the subset tag
+* (§9.6.4) and, after the face, the charset Acrobat's Office export appends
+* (`Arial,Bold-WinCharSetFFFF`, `-H2`), the encoding a CIDFont was cut for
+* (`-Identity-H`, `-OneByteIdentityH`), a serial number, and the slant or
+* stretch an interpreter synthesised (`-Slant_167`, `-Extend_850`). Left on,
+* bug900822.pdf's .docx asked for "Courier New,Bold Win Char Set FFFF", which
+* no machine has, over the Courier New every machine does.
+*/
+function plainFace(baseFont) {
+	let name = baseFont.replace(/^[A-Z]{6}\+/u, "").replace(/^[!-/:-@[-`{-~]+/u, "").trim();
+	for (let next = name.replace(PRODUCER_TAIL, ""); next !== name;) {
+		name = next;
+		next = name.replace(PRODUCER_TAIL, "");
+	}
+	return name;
+}
+/** One piece of producer debris at the end of a face name (see `plainFace`). */
+var PRODUCER_TAIL = /[-_](?:WinCharSet[0-9A-F]+|Identity-[HV]|OneByteIdentity[HV]|H\d+|\d+|(?:Slant|Extend)_\d+)$/iu;
+/**
+* A style run on to a family with no separator — `CalibriBold` — which is the
+* family's name only with the style taken off. Whether the face IS bold is the
+* program's to say (see `faceStyle`): `NewBasrahBold` is a family of its own.
+*/
+var GLUED_STYLE = /^(.*?[a-z])((?:Semi|Demi|Extra|Ultra)?(?:Bold|Black|Heavy)(?:Italic|Oblique)?|Italic|Oblique)$/u;
+/** A PostScript style part, made of nothing but style words (`SemiBoldItalic`, `BoldMT`, `Regu`). */
+var STYLE_WORDS = /^(?:regular|regu|roman|book|normal|plain|medium|medi|light|thin|hairline|extra|ultra|semi|demi|bold|bd|black|heavy|italic|ital|it|oblique|obl|condensed|cond|narrow|compressed|extended|mt|ps)+$/iu;
+/** §17.8.3.10 — the kind of face a family is, from the descriptor or, failing that, its name. */
+function genericOf(family, flags) {
+	if (!knowsFamily(family)) {
+		if ((flags & FLAG_FIXED_PITCH) !== 0) return "modern";
+		if ((flags & FLAG_SERIF) !== 0) return "roman";
+	}
+	const key = resolveFamilyStyle(family).key;
+	if (key === "cousine") return "modern";
+	return key === "tinos" || key === "caladea" ? "roman" : "swiss";
+}
 /** §9.8.2 `/Flags` — bit 1 is FixedPitch, bit 2 Serif (bits numbered from 1). */
 var FLAG_FIXED_PITCH = 1;
 var FLAG_SERIF = 2;
@@ -575,8 +1120,11 @@ function faceStyle(file, fontDict, isType0) {
 		const flags = asNumber(file.resolve(descriptor.get("Flags") ?? 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 = 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;
+		const stated = typeof weightVal === "number" && weightVal >= LIGHTEST_WEIGHT;
+		const own = programStyle(file, fontDict);
+		const forced = (flags & FLAG_FORCE_BOLD) !== 0 && !named.light;
+		const bold = stated ? asNumber(weightVal, 0) >= BOLD_WEIGHT : forced || own?.bold === true || named.bold;
+		const italic = slant !== 0 || (flags & FLAG_ITALIC) !== 0 || own?.italic === true || named.italic;
 		return {
 			...bold ? { bold: true } : {},
 			...italic ? { italic: true } : {}
@@ -597,11 +1145,13 @@ function faceStyle(file, fontDict, isType0) {
 * set two lines heavy that no reader sets heavy. `Times-Bold` is.
 */
 function styleFromName(baseFont) {
-	const name = baseFont.replace(/^[A-Z]{6}\+/u, "");
+	const name = plainFace(baseFont);
 	const style = /[-,]([A-Za-z]+)$/u.exec(name)?.[1] ?? "";
+	const bold = /bold|black|heavy|semib|demi/iu.test(style);
 	return {
-		bold: /bold|black|heavy|semib|demi/iu.test(style),
-		italic: /italic|oblique/iu.test(style)
+		bold,
+		italic: /italic|oblique/iu.test(style),
+		light: !bold && /light|thin|hairline|book|regular|roman|normal|medium/iu.test(style)
 	};
 }
 /** §9.7.4 — a `/Type0` font's one descendant CIDFont, which owns the descriptor. */
@@ -610,6 +1160,23 @@ 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();
 }
+/**
+* §9.8.2 — whether every glyph of a simple font is as wide as the next: the
+* descriptor's FixedPitch flag, the standard Courier, or a /Widths array that
+* says so itself. pdfTeX sets no flag on Computer Modern's typewriter face,
+* and its widths do: all of them 525. Ten widths at the least — a face that
+* shows four digits shows four equal widths and is no typewriter's.
+*/
+function fixedPitchOf(file, fontDict) {
+	const descriptor = file.resolve(fontDict.get("FontDescriptor") ?? PDF_NULL);
+	if (((descriptor instanceof Map ? asNumber(file.resolve(descriptor.get("Flags") ?? PDF_NULL), 0) : 0) & FLAG_FIXED_PITCH) !== 0) return true;
+	if (/^courier/iu.test(plainFace(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL))))) return true;
+	const stated = file.resolve(fontDict.get("Widths") ?? PDF_NULL);
+	const widths = (Array.isArray(stated) ? stated : []).map((w) => file.resolve(w)).filter((w) => typeof w === "number" && w > 0);
+	return widths.length >= FIXED_PITCH_WIDTHS && widths.every((w) => Math.abs(w - widths[0]) < .5);
+}
+/** How many widths it takes to say every glyph is as wide as the next. */
+var FIXED_PITCH_WIDTHS = 10;
 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);
@@ -617,12 +1184,14 @@ function simpleWidths(file, fontDict, decodeOne) {
 	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 stated = (code) => {
 		const w = widths[code - first];
 		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;
+		return face === void 0 ? void 0 : standardWidth(face, code, decodeOne(code));
+	};
+	return {
+		width: (code) => stated(code) ?? (missing > 0 ? missing : 500),
+		stated
 	};
 }
 function cidWidths(file, fontDict) {
@@ -661,4 +1230,4 @@ function asNumber(v, dflt) {
 	return typeof v === "number" ? v : dflt;
 }
 //#endregion
-export { buildContentFont };
+export { buildContentFont, collectFaceFamilies };