reamkit 1.27.0 → 1.28.0

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

@@ -1,10 +1,19 @@
+import { resolveFamilyStyle } from "../core/fonts/remote-fonts.js";
 import { parseTtf } from "../core/font/ttf-parser.js";
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
 import { parseToUnicodeCMap } from "./cmap.js";
+import { decodePredefined, predefinedCMap, splitPredefined } from "./predefined-cmap.js";
+import { isZapfDingbats, zapfDingbatsChar } from "./dingbats.js";
 import { textForGlyphName } from "./glyph-names.js";
+import { cffCidToGid, cffNameToGid, cffOutlineSource, openTypeCff } from "./cff-outline.js";
+import { type1Font } from "./type1-outline.js";
+import { baseEncodingTable, isStandardLatinFace, standardEncodingTable } from "./encodings.js";
+import { outlineSource, postGlyphNames } from "./glyf-outline.js";
 import { standardFace, standardWidth } from "./standard-widths.js";
-import { embeddedFontName } from "./embedded-fonts.js";
+import { embeddedFontName, hasLiftableProgram } from "./embedded-fonts.js";
 //#region src/pdf-reader/font.ts
+/** §9.10.2 — what a composite code nothing can answer for comes to. */
+var UNANSWERABLE = "�";
 /**
 * Build a {@link ContentFont} (the interpreter's decode + advance hooks) from a
 * `/Font` dictionary (E-PDF EP2). Unicode comes from the `/ToUnicode` CMap;
@@ -21,25 +30,50 @@ function buildContentFont(file, fontDict) {
 	const isType0 = asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) === "Type0";
 	let toUnicode = /* @__PURE__ */ new Map();
 	let codeBytes = isType0 ? 2 : 1;
+	const encodingName = asName(file.resolve(fontDict.get("Encoding") ?? PDF_NULL));
+	const encodingNamed = isType0 && encodingName.length > 0;
+	const named = isType0 ? predefinedCMap(encodingName) : void 0;
 	const tu = file.resolve(fontDict.get("ToUnicode") ?? PDF_NULL);
 	if (tu instanceof PdfStream) {
 		const parsed = parseToUnicodeCMap(file.streamData(tu));
 		toUnicode = parsed.map;
-		if (isType0) codeBytes = parsed.codeBytes;
+		if (isType0 && !encodingNamed) codeBytes = parsed.codeBytes;
 	}
 	const fromProgram = isType0 && toUnicode.size === 0 ? embeddedCmap(file, fontDict) : void 0;
-	const fromNames = !isType0 ? namedGlyphs(file, fontDict) : void 0;
+	let programFallback = null;
+	const fromProgramFor = (code) => {
+		if (!isType0 || toUnicode.size === 0) return void 0;
+		programFallback ??= embeddedCmap(file, fontDict);
+		return programFallback?.get(code);
+	};
+	const glyphs = isType0 ? void 0 : simpleGlyphs(file, fontDict);
+	const fromNames = !isType0 ? namedGlyphs(file, fontDict, toUnicode.size > 0, {
+		draws: (name) => glyphs?.byName(name) !== void 0,
+		blank: (name) => glyphs?.blank(name) === true
+	}) : void 0;
+	const glyphNames = isType0 ? /* @__PURE__ */ new Map() : differences(file, fontDict);
 	const unicode = fromProgram ?? (toUnicode.size > 0 ? toUnicode : fromNames ?? toUnicode);
 	const bytesPerCode = codeBytes;
+	const indices = !isType0 && glyphs?.indexed === true && fromNames === void 0 && toUnicode.size === 0 && glyphNames.size === 0;
+	const dingbats = !isType0 && isZapfDingbats(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL)));
+	const baseNames = isType0 ? void 0 : baseEncoding(file, fontDict);
+	const fromBase = /* @__PURE__ */ new Map();
+	for (const [code, glyph] of baseNames ?? []) {
+		const text = textForGlyphName(glyph);
+		if (text !== void 0) fromBase.set(code, text);
+	}
+	const namesOf = new Map([...baseNames ?? [], ...glyphNames]);
 	const style = faceStyle(file, fontDict, isType0);
-	const name = embeddedFontName(file, fontDict);
+	const name = runFontName(file, fontDict, isType0);
 	const type3 = asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) === "Type3" ? type3Face(file, fontDict) : void 0;
-	const speechless = isType0 && unicode.size === 0;
-	const decodeOne = (code) => unicode.get(code) ?? (bytesPerCode === 1 ? latin1(code) : speechless ? "�" : "");
+	const decodeOne = (code) => (indices ? UNANSWERABLE : void 0) ?? unicode.get(code) ?? fromProgramFor(code) ?? (named ? decodePredefined(named, code) : void 0) ?? fromNames?.get(code) ?? (dingbats ? zapfDingbatsChar(code) : void 0) ?? fromBase.get(code) ?? (bytesPerCode === 1 ? latin1(code) : UNANSWERABLE);
 	const simple = simpleWidths(file, fontDict, decodeOne);
 	const width = isType0 ? cidWidths(file, fontDict) : type3 ? (code) => simple(code) * type3.matrix[0] * 1e3 : simple;
 	return {
 		bytesPerCode,
+		...named ? { splitCodes: (b) => splitPredefined(named, b) } : {},
+		...isType0 ? outlineOf(file, fontDict, decodeOne) : simpleOutlineOf(decodeOne, namesOf, glyphs),
+		...named?.vertical ? { verticalAdvance: cidVerticalAdvance(file, fontDict) } : {},
 		...type3 ? { type3 } : {},
 		...name !== void 0 ? { name } : {},
 		decode: (codes) => codes.map((c) => readable(decodeOne(c))).join(""),
@@ -130,6 +164,192 @@ function embeddedCmap(file, fontDict) {
 	});
 	return out.size > 0 ? out : void 0;
 }
+/**
+* §9.6.6 — the outline a code draws, for a code that stands for no character.
+*
+* The glyph is there even when the character is not: `/Encoding /Identity-H`
+* makes the code a CID, `/CIDToGIDMap` turns that into a glyph index, and the
+* embedded program holds the contours. complex_ttf_font.pdf is eight lines of
+* Arabic in a subset with no `cmap` and no `/ToUnicode`, and every one of them
+* was dropped.
+*
+* Deliberately NOT a fallback for text: a code the font CAN answer for is set
+* as type, and only the unanswerable ones are traced.
+*
+* @param file      The owning file.
+* @param fontDict  The Type 0 font dictionary.
+* @param decodeOne What one code comes to, to tell the two cases apart.
+* @returns The `outline` field of a {@link ContentFont}, or nothing where the
+*          program carries no outlines this reads.
+*/
+function outlineOf(file, fontDict, decodeOne) {
+	const cidFont = descendantFont(file, fontDict);
+	const descriptor = file.resolve(cidFont.get("FontDescriptor") ?? PDF_NULL);
+	if (!(descriptor instanceof Map)) return {};
+	const truetype = file.resolve(descriptor.get("FontFile2") ?? PDF_NULL);
+	const compact = file.resolve(descriptor.get("FontFile3") ?? PDF_NULL);
+	const program = truetype instanceof PdfStream ? truetype : compact;
+	if (!(program instanceof PdfStream)) return {};
+	let source;
+	let charsetCids;
+	try {
+		const bytes = file.streamData(program);
+		source = outlineSource(bytes);
+		if (!source) {
+			const cff = openTypeCff(bytes) ?? bytes;
+			source = cffOutlineSource(cff);
+			charsetCids = source ? cffCidToGid(cff) : void 0;
+		}
+	} catch {
+		return {};
+	}
+	if (!source) return {};
+	const cidToGid = readCidToGid(file, cidFont);
+	return { outline: {
+		matrix: [
+			1,
+			0,
+			0,
+			1,
+			0,
+			0
+		],
+		path: (code) => {
+			if (readable(decodeOne(code)) !== UNANSWERABLE) return void 0;
+			const mapped = cidToGid ? cidToGid[code] ?? 0 : code;
+			const gid = charsetCids ? charsetCids.get(mapped) ?? mapped : mapped;
+			return source.path(gid);
+		}
+	} };
+}
+/**
+* §9.6.6 — the outline a SIMPLE font's code draws, for a code that stands for
+* no character.
+*
+* A simple font addresses its glyphs by NAME: `/Differences` (or the program's
+* own `/Encoding`) says code 2 is `g18`, and the program says what `g18` looks
+* like. Where that name is not a character there is nothing to write and there
+* is still something to draw — TAMReview.pdf sets most of its body in a Cambria
+* subset whose glyphs are named `g18`, `g152`, `g135`, and seven thousand of
+* its nine thousand characters were dropped.
+*
+* @param file      The owning file.
+* @param fontDict  The simple font's dictionary.
+* @param decodeOne What one code comes to, to tell the two cases apart.
+* @param nameOf    The glyph name a code selects, where the font states one.
+* @returns The `outline` field of a {@link ContentFont}, or nothing.
+*/
+function simpleOutlineOf(decodeOne, nameOf, source) {
+	if (!source) return {};
+	return { outline: {
+		matrix: [
+			1,
+			0,
+			0,
+			1,
+			0,
+			0
+		],
+		path: (code) => {
+			if (readable(decodeOne(code)) !== UNANSWERABLE) return void 0;
+			const name = nameOf.get(code) ?? source.builtIn?.get(code);
+			if (name === void 0) return source.byIndex?.(code);
+			return source.byName(name);
+		}
+	} };
+}
+/**
+* §9.6.6 — the program a SIMPLE font embeds, ready to draw a glyph BY NAME.
+*
+* All three formats appear here: a Type 1 program keys its charstrings by name
+* outright, a CFF says which name each glyph has in its charset, and a TrueType
+* says nothing at all — but a subsetter that renames glyphs `g24` has written
+* the glyph's index into the name, which is the only handle such a program
+* gives.
+*
+* @param file     The owning file.
+* @param fontDict The simple font's dictionary.
+* @returns How to draw one of its glyphs, or `undefined` where nothing here
+*          can read the program.
+*/
+function simpleGlyphs(file, fontDict) {
+	const descriptor = file.resolve(fontDict.get("FontDescriptor") ?? PDF_NULL);
+	if (!(descriptor instanceof Map)) return void 0;
+	const typeOne = file.resolve(descriptor.get("FontFile") ?? PDF_NULL);
+	const truetype = file.resolve(descriptor.get("FontFile2") ?? PDF_NULL);
+	const compact = file.resolve(descriptor.get("FontFile3") ?? PDF_NULL);
+	try {
+		if (typeOne instanceof PdfStream) {
+			const face = type1Font(file.streamData(typeOne));
+			if (!face) return void 0;
+			return {
+				byName: face.path,
+				blank: (name) => face.has(name) && face.path(name) === void 0,
+				...face.encoding ? { builtIn: face.encoding } : {}
+			};
+		}
+		const stream = compact instanceof PdfStream ? compact : truetype;
+		if (!(stream instanceof PdfStream)) return void 0;
+		const bytes = file.streamData(stream);
+		const glyf = outlineSource(bytes);
+		if (glyf) {
+			const named = postGlyphNames(bytes);
+			const gidOf = (name) => {
+				const gid = named?.get(name) ?? numberedGlyph(name);
+				return gid !== void 0 && gid < glyf.count ? gid : void 0;
+			};
+			return {
+				byName: (name) => {
+					const gid = gidOf(name);
+					return gid === void 0 ? void 0 : glyf.path(gid);
+				},
+				blank: (name) => {
+					const gid = gidOf(name);
+					return gid !== void 0 && glyf.path(gid) === void 0;
+				},
+				byIndex: (gid) => gid < glyf.count ? glyf.path(gid) : void 0,
+				indexed: !glyf.cmap
+			};
+		}
+		const cff = openTypeCff(bytes) ?? bytes;
+		const outlines = cffOutlineSource(cff);
+		if (!outlines) return void 0;
+		const names = cffNameToGid(cff);
+		const gidOf = (name) => {
+			const gid = names?.get(name) ?? numberedGlyph(name);
+			return gid !== void 0 && gid < outlines.count ? gid : void 0;
+		};
+		return {
+			byName: (name) => {
+				const gid = gidOf(name);
+				return gid === void 0 ? void 0 : outlines.path(gid);
+			},
+			blank: (name) => {
+				const gid = gidOf(name);
+				return gid !== void 0 && outlines.path(gid) === void 0;
+			}
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* The glyph index a name carries, for the names that carry one.
+*
+* A subsetter that drops a font's `cmap` renames its glyphs after their
+* INDEX — `g24`, `glyph24`, `index24`, `cid24` — and that name is then the only
+* way back to the outline. bug1151216.pdf names them `g24`, `g381`, `g3`, and
+* its three lines of prices are drawn from nothing else.
+*/
+function numberedGlyph(name) {
+	const hex = /^g([0-9a-f]{4})$/u.exec(name);
+	if (hex) return Number.parseInt(hex[1], 16);
+	const m = /^(?:g|glyph|index|cid|G)(\d+)$/u.exec(name);
+	const n = m ? Number(m[1]) : NaN;
+	return Number.isFinite(n) && n >= 0 && n < MAX_GLYPH_INDEX ? n : void 0;
+}
+/** No font holds more glyphs than this; a bigger number is not an index. */
+var MAX_GLYPH_INDEX = 65536;
 /** §9.7.4.2 `/CIDToGIDMap` — a stream of two-byte glyph indices, CID by CID. */
 function readCidToGid(file, cidFont) {
 	const map = file.resolve(cidFont.get("CIDToGIDMap") ?? PDF_NULL);
@@ -194,13 +414,21 @@ function fontMatrix(file, fontDict) {
 * Returns `undefined` where the font names nothing, so the caller keeps its
 * Latin-1 reading rather than replacing it with an empty map.
 */
-function namedGlyphs(file, fontDict) {
+function namedGlyphs(file, fontDict, statesUnicode, glyph) {
 	const names = differences(file, fontDict);
 	if (names.size === 0) return void 0;
 	const out = /* @__PURE__ */ new Map();
 	for (const [code, name] of names) {
 		const text = textForGlyphName(name);
-		if (text !== void 0) out.set(code, text);
+		if (text !== void 0) {
+			out.set(code, text);
+			continue;
+		}
+		if (glyph.blank(name)) {
+			out.set(code, " ");
+			continue;
+		}
+		if (!statesUnicode && glyph.draws(name)) out.set(code, UNANSWERABLE);
 	}
 	if (out.size > 0) return out;
 	if (asName(file.resolve(fontDict.get("Subtype") ?? PDF_NULL)) !== "Type3") return void 0;
@@ -208,6 +436,63 @@ function namedGlyphs(file, fontDict) {
 	for (const code of names.keys()) unreadable.set(code, "�");
 	return unreadable;
 }
+/**
+* §9.7.4.3 `/DW2` and `/W2` — how far the pen drops for one glyph, in 1000-unit
+* text space.
+*
+* `/DW2`'s default is `[880 -1000]`: the vertical origin sits 880 above the
+* horizontal one and the displacement is a full em DOWN. Only the displacement
+* is wanted here — the origin shifts where the glyph is drawn, which a reader
+* re-setting the words in another face does not reproduce anyway.
+*/
+function cidVerticalAdvance(file, fontDict) {
+	const cid = descendantFont(file, fontDict);
+	const dw2 = file.resolve(cid.get("DW2") ?? PDF_NULL);
+	const stated = Array.isArray(dw2) && typeof file.resolve(dw2[1] ?? PDF_NULL) === "number" ? file.resolve(dw2[1]) : DEFAULT_DW2_DISPLACEMENT;
+	const perCode = /* @__PURE__ */ new Map();
+	const w2 = file.resolve(cid.get("W2") ?? PDF_NULL);
+	if (Array.isArray(w2)) for (let i = 0; i < w2.length;) {
+		const first = file.resolve(w2[i] ?? PDF_NULL);
+		const next = file.resolve(w2[i + 1] ?? PDF_NULL);
+		if (typeof first !== "number") break;
+		if (Array.isArray(next)) {
+			for (let k = 0; k + 2 < next.length; k += 3) {
+				const v = file.resolve(next[k] ?? PDF_NULL);
+				if (typeof v === "number") perCode.set(first + k / 3, v);
+			}
+			i += 2;
+		} else if (typeof next === "number" && typeof file.resolve(w2[i + 2] ?? PDF_NULL) === "number") {
+			const v = file.resolve(w2[i + 2]);
+			for (let c = first; c <= next && c - first < MAX_W2_RANGE; c++) perCode.set(c, v);
+			i += 5;
+		} else break;
+	}
+	return (code) => perCode.get(code) ?? stated;
+}
+/** §9.7.4.3 — `/DW2`'s default displacement: one em down the page. */
+var DEFAULT_DW2_DISPLACEMENT = -1e3;
+/** A `/W2` range wider than this is not walked out code by code. */
+var MAX_W2_RANGE = 65536;
+/**
+* Annex D.2 — code → text for the encoding a simple font is read through, under
+* whatever `/Differences` restates.
+*
+* `/Encoding` either names one of the base encodings, or is a dictionary that
+* may name one in `/BaseEncoding`, or is absent — and absent means the encoding
+* built into the FACE. Only the standard Latin faces can be answered for there:
+* a file that names them embeds no program, and what they are is known
+* (§9.6.2.2). An embedded font's built-in encoding lives in the program and a
+* substituted face has none worth guessing at, so both keep the Latin-1
+* reading, which is what the codes of such a file nearly always are.
+*
+* @returns Code → glyph NAME, or `undefined` where nothing better than Latin-1
+*          is known.
+*/
+function baseEncoding(file, fontDict) {
+	const encoding = file.resolve(fontDict.get("Encoding") ?? PDF_NULL);
+	const named = encoding instanceof PdfName ? encoding.value : encoding instanceof Map ? asName(file.resolve(encoding.get("BaseEncoding") ?? PDF_NULL)) : "";
+	return named.length > 0 ? baseEncodingTable(named) : isStandardLatinFace(asName(file.resolve(fontDict.get("BaseFont") ?? PDF_NULL))) ? standardEncodingTable() : void 0;
+}
 /** §9.6.6.1 `/Encoding` `/Differences` — code → glyph name, as the array runs. */
 function differences(file, fontDict) {
 	const out = /* @__PURE__ */ new Map();
@@ -223,6 +508,42 @@ function differences(file, fontDict) {
 	}
 	return out;
 }
+/**
+* §9.8.2 — the family a run states: the file's own name for the face, plus what
+* the file says the face IS.
+*
+* The name is a hint for the substitution and nothing more, unless the reader
+* can lift the program itself (§9.9 `/FontFile2`) — then it is the key the face
+* is filed under and must be left exactly as it is. Everything else is
+* substituted by name, and TeX and PostScript producers embed Type 1 and CFF
+* programs under names no table knows: `NimbusRomNo9L-Regu`, `LMRoman10`,
+* `CMR10`, `stonesans`. Every one of those pages came back set in a grotesque
+* — the loudest single difference between our page and a serif document's.
+*
+* The descriptor states the class outright, so where the name says nothing the
+* flags do: bit 1 is FixedPitch and bit 2 Serif.
+*
+* @param file     The document.
+* @param fontDict The font dictionary.
+* @param isType0  Whether it is a composite font, whose descendant owns the
+*                 descriptor.
+* @returns The family name for the run, or `undefined` where the font has none.
+*/
+function runFontName(file, fontDict, isType0) {
+	const name = embeddedFontName(file, fontDict);
+	if (name === void 0 || hasLiftableProgram(file, fontDict)) return name;
+	if (resolveFamilyStyle(name).key !== "arimo") return name;
+	const owner = isType0 ? descendantFont(file, fontDict) : fontDict;
+	const descriptor = file.resolve(owner.get("FontDescriptor") ?? PDF_NULL);
+	if (!(descriptor instanceof Map)) return name;
+	const flags = asNumber(file.resolve(descriptor.get("Flags") ?? PDF_NULL), 0);
+	if ((flags & FLAG_FIXED_PITCH) !== 0) return `${name} monospace`;
+	if ((flags & FLAG_SERIF) !== 0) return `${name} serif`;
+	return name;
+}
+/** §9.8.2 `/Flags` — bit 1 is FixedPitch, bit 2 Serif (bits numbered from 1). */
+var FLAG_FIXED_PITCH = 1;
+var FLAG_SERIF = 2;
 /** §9.8.2 `/Flags` — bit 7 is Italic, bit 19 ForceBold (bits numbered from 1). */
 var FLAG_ITALIC = 64;
 var FLAG_FORCE_BOLD = 1 << 18;

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

@@ -0,0 +1,43 @@
+import { PathSeg } from './content.js';
+/** A reader for one font program's outlines, with its tables located once. */
+export interface OutlineSource {
+    /** The glyph's contours in a one-unit em, or `undefined` for an empty one. */
+    readonly path: (gid: number) => Array<PathSeg> | undefined;
+    /**
+     * How many glyphs the program holds. A glyph INSIDE that count which draws
+     * nothing is a blank one — a space — and not a glyph the program lacks.
+     */
+    readonly count: number;
+    /**
+     * Whether an sfnt program carries a `cmap` at all. Without one there is no
+     * way to reach a glyph by character (§9.6.6.4), which says what the file
+     * means by its codes: they are glyph INDICES. Absent for a bare CFF, which
+     * has no such table and is addressed by NAME through its charset.
+     */
+    readonly cmap?: boolean;
+}
+/**
+ * Prepare an embedded TrueType program for outline reading (§9.6.6).
+ *
+ * @param program The raw `/FontFile2` bytes.
+ * @returns A reader, or `undefined` where the program carries no `glyf`/`loca`
+ *          pair — an OpenType/CFF program under `/FontFile2` is one such, and
+ *          its outlines are charstrings this does not read.
+ */
+export declare function outlineSource(program: Uint8Array): OutlineSource | undefined;
+/**
+ * §post format 2.0 — the NAME each glyph of a TrueType program goes by.
+ *
+ * A legacy eight-bit font is reached through this table and nothing else. Its
+ * program carries no `cmap`, so a code cannot be turned into a character and
+ * then into a glyph; what it can be turned into is a glyph NAME, through the
+ * encoding the font dictionary states (Annex D.2) — and the name is looked up
+ * here. TrueType_without_cmap.pdf is an Armenian face, Masis, whose `i` draws
+ * ի: read as text its line came back "'>in", and drawn by name it is the line
+ * the page shows.
+ *
+ * @param program The raw `/FontFile2` bytes.
+ * @returns Glyph name → index, or `undefined` where the table is missing or
+ *          states no names of its own (formats 1.0 and 3.0).
+ */
+export declare function postGlyphNames(program: Uint8Array): Map<string, number> | undefined;