reamkit 1.29.0 → 1.30.0

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

@@ -1,4 +1,4 @@
-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";
@@ -7,10 +7,10 @@ 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 { baseEncodingTable, isStandardLatinFace, macGlyphName, 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";
+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,27 @@ 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 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,7 +79,7 @@ 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 ? 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 simple = simpleWidths(file, fontDict, decodeOne);
 	const width = isType0 ? cidWidths(file, fontDict) : type3 ? (code) => simple(code) * type3.matrix[0] * 1e3 : simple;
 	return {
@@ -76,7 +89,7 @@ function buildContentFont(file, fontDict) {
 		...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,
 		...style
 	};
@@ -114,6 +127,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 +172,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,15 +313,7 @@ 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.
@@ -278,6 +429,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));
@@ -295,7 +447,7 @@ function simpleGlyphs(file, fontDict) {
 		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;
 			};
 			return {
@@ -316,7 +468,7 @@ 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;
 		};
 		return {
@@ -340,9 +492,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 +506,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 +602,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 +715,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 +725,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 +854,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 +879,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. */
@@ -661,4 +945,4 @@ function asNumber(v, dflt) {
 	return typeof v === "number" ? v : dflt;
 }
 //#endregion
-export { buildContentFont };
+export { buildContentFont, collectFaceFamilies };

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

@@ -29,8 +29,19 @@ function outlineSource(program) {
 		if (at + stride * 2 > loca.offset + loca.length) return void 0;
 		const read = (o) => longLoca ? safeUint32(view, o) : safeUint16(view, o) * 2;
 		const start = read(at);
-		const end = read(at + stride);
-		if (end <= start) return void 0;
+		let end = read(at + stride);
+		if (end === start) return void 0;
+		if (end < start) {
+			end = glyf.length;
+			for (let o = at + stride * 2; o + stride <= loca.offset + loca.length; o += stride) {
+				const next = read(o);
+				if (next > start) {
+					end = Math.min(next, glyf.length);
+					break;
+				}
+			}
+			if (end <= start) return void 0;
+		}
 		if (glyf.offset + end > program.length) return void 0;
 		return {
 			start: glyf.offset + start,

package/dist/esm/pdf-reader/glyph-shapes.d.ts

@@ -0,0 +1,18 @@
+import { PathSeg } from './content.js';
+/** A glyph's contours, and the box they fill, in the page's y-up space. */
+export interface GlyphShape {
+    readonly segs: ReadonlyArray<PathSeg>;
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+}
+/**
+ * The punctuation mark a glyph's shape is, where it can be only one.
+ *
+ * @param glyph    The glyph as the page draws it.
+ * @param baseline The y of the line it stands on.
+ * @param size     The size the line is set at, which the shape is measured in.
+ * @returns The character, or `undefined` where the shape does not say.
+ */
+export declare function punctuationOf(glyph: GlyphShape, baseline: number, size: number): string | undefined;

package/dist/esm/pdf-reader/glyph-shapes.js

@@ -0,0 +1,57 @@
+//#region src/pdf-reader/glyph-shapes.ts
+/**
+* The punctuation mark a glyph's shape is, where it can be only one.
+*
+* @param glyph    The glyph as the page draws it.
+* @param baseline The y of the line it stands on.
+* @param size     The size the line is set at, which the shape is measured in.
+* @returns The character, or `undefined` where the shape does not say.
+*/
+function punctuationOf(glyph, baseline, size) {
+	if (!(size > 0)) return void 0;
+	const width = (glyph.maxX - glyph.minX) / size;
+	const height = (glyph.maxY - glyph.minY) / size;
+	const bottom = (glyph.minY - baseline) / size;
+	const top = (glyph.maxY - baseline) / size;
+	const contours = glyph.segs.filter((s) => s.op === "move").length;
+	if (contours === 1 && height <= FLAT_EM && width >= height * 2.5) {
+		if (bottom < .15 || top > .6) return void 0;
+		if (width < HYPHEN_LONGEST_EM) return "-";
+		return width < EN_DASH_LONGEST_EM ? "–" : "—";
+	}
+	if (contours === 2 && width <= DOT_WIDEST_EM && height >= .3 && height <= .8) {
+		if (bottom > .15) return void 0;
+		return bottom < -.05 ? ";" : ":";
+	}
+	if (contours === 1 && width <= DOT_WIDEST_EM && height <= .4 && top <= .3) {
+		if (bottom >= -.05 && bottom <= .05 && height <= DOT_WIDEST_EM) return ".";
+		return bottom < -.05 ? "," : void 0;
+	}
+	if (contours === 1 && width <= .45 && height >= .75 && bottom <= -.05 && top >= .6) {
+		const peak = highestPoint(glyph.segs);
+		if (peak === void 0) return void 0;
+		return peak > (glyph.minX + glyph.maxX) / 2 ? "(" : ")";
+	}
+}
+/** The x of the highest point a glyph's contours pass through. */
+function highestPoint(segs) {
+	let best;
+	for (const s of segs) {
+		if (s.op === "close") continue;
+		if (best === void 0 || s.y > best.y) best = {
+			x: s.x,
+			y: s.y
+		};
+	}
+	return best?.x;
+}
+/** The tallest a bar may be, in ems, and still be a dash rather than a block. */
+var FLAT_EM = .15;
+/** The longest a hyphen is, in ems; past it the bar is a dash. */
+var HYPHEN_LONGEST_EM = .42;
+/** The longest an en dash is, in ems; past it, an em dash. */
+var EN_DASH_LONGEST_EM = .7;
+/** The widest a dot is, in ems. */
+var DOT_WIDEST_EM = .22;
+//#endregion
+export { punctuationOf };