reamkit 1.30.0 → 1.31.0

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

@@ -5,10 +5,10 @@ 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, macGlyphName, 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 { eachPageFont, embeddedFontName, hasLiftableProgram, programStyle } from "./embedded-fonts.js";
 //#region src/pdf-reader/font.ts
@@ -69,6 +69,7 @@ function buildContentFont(file, fontDict) {
 	const dingbats = !isType0 && isZapfDingbats(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL)));
 	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 ?? []) {
@@ -79,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) ?? (glyphNames.get(code) === NOTDEF ? "" : void 0) ?? (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) => lettersOf(readable(decodeOne(c)))).join(""),
 		width,
+		...spaceWidth !== void 0 ? { spaceWidth } : {},
+		...fixedPitch ? { fixedPitch: true } : {},
 		...style
 	};
 }
@@ -316,46 +323,77 @@ function programCharacters(file, owner) {
 	return byGlyph.size > 0 ? byGlyph : 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.
+* §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.
 *
-* @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,
@@ -367,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.
 *
@@ -388,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: [
@@ -403,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);
@@ -437,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, 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);
@@ -460,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;
@@ -471,7 +546,14 @@ function simpleGlyphs(file, fontDict) {
 			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);
@@ -485,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.
 *
@@ -894,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);
@@ -901,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) {

package/dist/esm/pdf-reader/glyf-outline.d.ts

@@ -41,3 +41,36 @@ export declare function outlineSource(program: Uint8Array): OutlineSource | unde
  *          states no names of its own (formats 1.0 and 3.0).
  */
 export declare function postGlyphNames(program: Uint8Array): Map<string, number> | undefined;
+/**
+ * OS/2 `fsType` — the embedding a TrueType or OpenType program's licence allows
+ * (ISO/IEC 14496-22, OS/2 table).
+ *
+ * @param program The raw sfnt bytes.
+ * @returns The field, or `undefined` where the program carries no OS/2 table —
+ *          a subsetter may drop it, and then the program states nothing.
+ */
+export declare function sfntFsType(program: Uint8Array): number | undefined;
+/**
+ * How far the pen moves after an sfnt program's space, in thousandths of an em:
+ * the glyph its `cmap` (or its `post` names) gives U+0020, measured in `hmtx`.
+ * A subset keeps the metrics of glyphs it dropped the outlines of, and the
+ * width a page's words were set apart by is the one a writer should give the
+ * space the page never showed.
+ *
+ * @param program The raw sfnt bytes.
+ * @returns The advance, or `undefined` where the program says nothing of a space.
+ */
+export declare function sfntSpaceAdvance(program: Uint8Array): number | undefined;
+/**
+ * Every `cmap` subtable an sfnt program carries, keyed `platform,encoding` —
+ * `3,1` for Windows Unicode, `3,0` for Windows symbol, `1,0` for Mac Roman.
+ *
+ * A simple TrueType font reaches its glyphs through whichever of these it has,
+ * and which one decides what a code is looked up AS (§9.6.6.4): a character, a
+ * symbol code, a Mac Roman byte.
+ *
+ * @param program The raw sfnt bytes.
+ * @returns Subtable → code-to-glyph lookup (0 where it maps nothing). Formats
+ *          0, 4, 6 and 12 are read; any other is left out.
+ */
+export declare function cmapSubtables(program: Uint8Array): Map<string, (code: number) => number>;

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

@@ -120,6 +120,140 @@ function postGlyphNames(program) {
 	}
 	return out.size > 0 ? out : void 0;
 }
+/**
+* OS/2 `fsType` — the embedding a TrueType or OpenType program's licence allows
+* (ISO/IEC 14496-22, OS/2 table).
+*
+* @param program The raw sfnt bytes.
+* @returns The field, or `undefined` where the program carries no OS/2 table —
+*          a subsetter may drop it, and then the program states nothing.
+*/
+function sfntFsType(program) {
+	let tables;
+	try {
+		tables = sfntTables(program);
+	} catch {
+		return;
+	}
+	const os2 = tables.get("OS/2");
+	if (!os2 || os2.length < 10 || os2.offset + 10 > program.length) return void 0;
+	return new DataView(program.buffer, program.byteOffset, program.byteLength).getUint16(os2.offset + 8);
+}
+/**
+* How far the pen moves after an sfnt program's space, in thousandths of an em:
+* the glyph its `cmap` (or its `post` names) gives U+0020, measured in `hmtx`.
+* A subset keeps the metrics of glyphs it dropped the outlines of, and the
+* width a page's words were set apart by is the one a writer should give the
+* space the page never showed.
+*
+* @param program The raw sfnt bytes.
+* @returns The advance, or `undefined` where the program says nothing of a space.
+*/
+function sfntSpaceAdvance(program) {
+	let tables;
+	try {
+		tables = sfntTables(program);
+	} catch {
+		return;
+	}
+	const head = tables.get("head");
+	const hhea = tables.get("hhea");
+	const hmtx = tables.get("hmtx");
+	if (!head || !hhea || !hmtx) return void 0;
+	const view = new DataView(program.buffer, program.byteOffset, program.byteLength);
+	const cmaps = cmapSubtables(program);
+	const gid = [
+		cmaps.get("3,1")?.(32),
+		cmaps.get("0,3")?.(32),
+		cmaps.get("3,0")?.(61472),
+		cmaps.get("3,0")?.(32),
+		cmaps.get("1,0")?.(32)
+	].find((gid) => gid !== void 0 && gid > 0) ?? postGlyphNames(program)?.get("space");
+	if (gid === void 0 || gid <= 0) return void 0;
+	const unitsPerEm = safeUint16(view, head.offset + 18) || 1e3;
+	const metrics = safeUint16(view, hhea.offset + 34);
+	if (metrics === 0) return void 0;
+	const at = hmtx.offset + Math.min(gid, metrics - 1) * 4;
+	if (at + 2 > hmtx.offset + hmtx.length) return void 0;
+	const advance = safeUint16(view, at);
+	return advance > 0 ? advance / unitsPerEm * 1e3 : void 0;
+}
+/**
+* Every `cmap` subtable an sfnt program carries, keyed `platform,encoding` —
+* `3,1` for Windows Unicode, `3,0` for Windows symbol, `1,0` for Mac Roman.
+*
+* A simple TrueType font reaches its glyphs through whichever of these it has,
+* and which one decides what a code is looked up AS (§9.6.6.4): a character, a
+* symbol code, a Mac Roman byte.
+*
+* @param program The raw sfnt bytes.
+* @returns Subtable → code-to-glyph lookup (0 where it maps nothing). Formats
+*          0, 4, 6 and 12 are read; any other is left out.
+*/
+function cmapSubtables(program) {
+	const out = /* @__PURE__ */ new Map();
+	let tables;
+	try {
+		tables = sfntTables(program);
+	} catch {
+		return out;
+	}
+	const cmap = tables.get("cmap");
+	if (!cmap) return out;
+	const view = new DataView(program.buffer, program.byteOffset, program.byteLength);
+	const count = safeUint16(view, cmap.offset + 2);
+	for (let i = 0; i < count; i++) {
+		const at = cmap.offset + 4 + i * 8;
+		const key = `${safeUint16(view, at)},${safeUint16(view, at + 2)}`;
+		if (out.has(key)) continue;
+		const lookup = cmapLookup(view, cmap.offset + safeUint32(view, at + 4));
+		if (lookup) out.set(key, lookup);
+	}
+	return out;
+}
+/** One `cmap` subtable as a lookup, for the formats a simple font's program uses. */
+function cmapLookup(view, at) {
+	const format = safeUint16(view, at);
+	if (format === 0) return (code) => code >= 0 && code < 256 ? safeUint8(view, at + 6 + code) : 0;
+	if (format === 6) {
+		const first = safeUint16(view, at + 6);
+		const entries = safeUint16(view, at + 8);
+		return (code) => code >= first && code < first + entries ? safeUint16(view, at + 10 + (code - first) * 2) : 0;
+	}
+	if (format === 4) {
+		const segments = safeUint16(view, at + 6) >> 1;
+		const ends = at + 14;
+		const starts = ends + segments * 2 + 2;
+		const deltas = starts + segments * 2;
+		const ranges = deltas + segments * 2;
+		return (code) => {
+			if (code < 0 || code > 65535) return 0;
+			for (let s = 0; s < segments; s++) {
+				if (safeUint16(view, ends + s * 2) < code) continue;
+				const start = safeUint16(view, starts + s * 2);
+				if (start > code) return 0;
+				const delta = safeUint16(view, deltas + s * 2);
+				const range = safeUint16(view, ranges + s * 2);
+				if (range === 0) return code + delta & 65535;
+				const gid = safeUint16(view, ranges + s * 2 + range + (code - start) * 2);
+				return gid === 0 ? 0 : gid + delta & 65535;
+			}
+			return 0;
+		};
+	}
+	if (format === 12) {
+		const groups = safeUint32(view, at + 12);
+		return (code) => {
+			for (let g = 0; g < groups; g++) {
+				const entry = at + 16 + g * 12;
+				const start = safeUint32(view, entry);
+				const end = safeUint32(view, entry + 4);
+				if (code >= start && code <= end) return safeUint32(view, entry + 8) + (code - start);
+			}
+			return 0;
+		};
+	}
+}
 /** `post` version 2.0 — the only one that states names of its own. */
 var POST_NAMED = 131072;
 /** How many names the Macintosh standard order holds (§post). */
@@ -359,4 +493,4 @@ function safeUint32(view, at) {
 	return at >= 0 && at + 4 <= view.byteLength ? view.getUint32(at) : 0;
 }
 //#endregion
-export { outlineSource, postGlyphNames };
+export { cmapSubtables, outlineSource, postGlyphNames, sfntFsType, sfntSpaceAdvance };