pdf-codec 5.8.2 → 5.8.3

package/README.md

@@ -336,6 +336,8 @@ A `/ToUnicode` CMap that a producer writes for the Symbol or Wingdings font (Wor
 
 Two ways a producer names a core face other than the PostScript name the face's own tables carry are read through the same carried glyph order. A TrueType program Windows-era producers embed under the face's Windows name (`TimesNewRoman`, `Arial,Bold`) is the face `TimesNewRomanPSMT` or `Arial-BoldMT`, still accepted glyph by glyph against the program's own advance widths. And Adobe Acrobat's optimiser rewrites a TrueType face as a CFF subset that names each glyph `G` followed by its glyph id in the face (`G36` is the capital A of Times New Roman) under a font name carrying a size suffix (`Times.New.Roman092`, `Arial.Bold0133`): `coreFaceTextsOfNumberedGlyphs` reads those names through the face's order, but only for a font whose dictionary widths agree with the face's advances over at least five numbered glyphs and nine in ten of them, so a subset of another face, or one too small to tell, is read as before. The Symbol face and the Type 3 fonts such producers also write are not covered: the first has no carried order, and a Type 3 glyph is a drawing procedure with no character.
 
+Some producers write the font dictionary's own tables wrong for a symbol subset: a typesetter's Type 1C math fonts give each glyph an arbitrary name, assign the names to codes with `/Differences`, and have a `/ToUnicode` CMap read each name as the character it spells, so an equals sign is read as `¼` and an omega as `!`, from tables that are valid and wrong. `verified-glyph-tables.ts` holds tables for the exact subsets whose glyphs were rendered from the embedded program and checked one by one (`docs/verified-glyph-tables/`), each keyed by the SHA-256 of the decoded font program; a glyph of such a subset is read as what it draws, before the font dictionary's tables, and every other subset, family and code is read as before.
+
 **Where nothing states an answer, the answer is the replacement character plus a `text/unmapped-encoding` diagnostic, never a guess.** Cases that reach it in practice: a symbolic font with no embedded program and no `/ToUnicode`; a subsetted font that both strips its glyph names and maps its glyphs only from private-use code points; a nameless, `cmap`-less subset of a face whose glyph order this package does not carry, or of a carried face at a glyph its recorded releases do not number; and a composite font whose `/Encoding` is a CMap other than Identity-H or Identity-V, whose codes reach CIDs this reader does not map. A private-use code point identifies a glyph inside one font and says nothing about the character it draws, so it is treated as no answer rather than a wrong one.
 
 ## Grouping text runs into lines and words

package/dist/font-read.cjs

@@ -11,6 +11,7 @@ const require_cmap = require("./cmap.cjs");
 const require_encoding_symbol_tables = require("./encoding-symbol-tables.cjs");
 const require_fonts = require("./fonts.cjs");
 const require_symbol_font_private_use = require("./symbol-font-private-use.cjs");
+const require_verified_glyph_tables = require("./verified-glyph-tables.cjs");
 //#region src/font-read.ts
 const BITS_PER_BYTE = 8;
 const SYMBOLIC_FLAG_BIT = 4;
@@ -51,6 +52,33 @@ function lazyFontProgram(descriptor, baseFont, context) {
 		return read.encoding;
 	};
 }
+function lazyVerifiedGlyphTable(descriptor, family, context) {
+	let read;
+	return () => {
+		if (descriptor === void 0 || !require_verified_glyph_tables.VERIFIED_GLYPH_FAMILIES.has(family)) return;
+		read ??= { table: verifiedGlyphTableOfProgram(descriptor, family, context) };
+		return read.table;
+	};
+}
+const PROGRAM_DIGESTS = /* @__PURE__ */ new WeakMap();
+function digestOfFontStream(stream, context) {
+	let digest = PROGRAM_DIGESTS.get(stream);
+	if (digest === void 0) {
+		digest = require_verified_glyph_tables.programDigest(require_filters.decodeStream(stream.raw, stream.dict, context.sink).bytes);
+		PROGRAM_DIGESTS.set(stream, digest);
+	}
+	return digest;
+}
+function verifiedGlyphTableOfProgram(descriptor, family, context) {
+	for (const key of [
+		"FontFile3",
+		"FontFile2",
+		"FontFile"
+	]) {
+		const stream = context.resolver.resolve(require_objects.dictGet(descriptor, key));
+		if (stream?.kind === "stream") return require_verified_glyph_tables.verifiedGlyphTableOfDigest(family, digestOfFontStream(stream, context), context.verifiedGlyphTables);
+	}
+}
 function readDifferencesMap(differences) {
 	const map = /* @__PURE__ */ new Map();
 	if (differences === void 0) return map;
@@ -87,6 +115,7 @@ function buildSimpleFont(fontDict, context) {
 	const symbolic = styleFlags.symbolic ?? false;
 	const builtinGlyphName = builtinSymbolGlyphNameLookup(baseFamily);
 	const symbolFont = require_symbol_font_private_use.symbolFontOf(baseFamily);
+	const verifiedGlyphs = lazyVerifiedGlyphTable(descriptor, baseFamily, context);
 	const widthsArr = resolvedArray(require_objects.dictGet(fontDict, "Widths"), context);
 	const firstChar = require_objects.asNumber(require_objects.dictGet(fontDict, "FirstChar")) ?? 0;
 	const missingWidth = (descriptor !== void 0 ? require_objects.asNumber(require_objects.dictGet(descriptor, "MissingWidth")) : void 0) ?? 0;
@@ -171,6 +200,12 @@ function buildSimpleFont(fontDict, context) {
 		let out = "";
 		let unmapped = 0;
 		for (const code of codes) {
+			const glyphName = differencesMap.get(code) ?? namedBaseGlyphName?.(code);
+			const verified = glyphName === void 0 ? void 0 : verifiedGlyphs()?.glyphs.get(glyphName);
+			if (verified !== void 0) {
+				out += verified;
+				continue;
+			}
 			const viaToUnicode = toUnicode?.lookup(code);
 			if (viaToUnicode !== void 0) {
 				out += require_symbol_font_private_use.withSymbolFontCharacters(symbolFont, viaToUnicode);

package/dist/font-read.d.cts

@@ -1,6 +1,7 @@
 import { i as PdfDiagnosticSink } from "./diagnostics-BkG_Ej2x.cjs";
 import { n as PdfDict } from "./objects-e2RS3-yT.cjs";
 import { FontMetricsPort, PdfObjectResolver } from "./interpret-types.cjs";
+import { i as VerifiedGlyphTableSource } from "./verified-glyph-tables-B_ZoMhyT.cjs";
 //#region src/font-read.d.ts
 interface VerticalGlyphMetrics {
   readonly displacementY: number;
@@ -19,6 +20,8 @@ interface PdfFont {
 interface FontReadContext {
   readonly resolver: PdfObjectResolver;
   readonly sink: PdfDiagnosticSink;
+  /** The verified font subsets to read a font through, by the SHA-256 of its decoded program; the subsets `verified-glyph-tables.ts` holds when absent. Supplied by a test that builds its own. */
+  readonly verifiedGlyphTables?: ReadonlyMap<string, VerifiedGlyphTableSource>;
 }
 interface FontResolverService {
   readonly metrics: FontMetricsPort;

package/dist/font-read.d.ts

@@ -1,6 +1,7 @@
 import { i as PdfDiagnosticSink } from "./diagnostics-BkG_Ej2x.js";
 import { n as PdfDict } from "./objects-e2RS3-yT.js";
 import { FontMetricsPort, PdfObjectResolver } from "./interpret-types.js";
+import { i as VerifiedGlyphTableSource } from "./verified-glyph-tables-B_ZoMhyT.js";
 //#region src/font-read.d.ts
 interface VerticalGlyphMetrics {
   readonly displacementY: number;
@@ -19,6 +20,8 @@ interface PdfFont {
 interface FontReadContext {
   readonly resolver: PdfObjectResolver;
   readonly sink: PdfDiagnosticSink;
+  /** The verified font subsets to read a font through, by the SHA-256 of its decoded program; the subsets `verified-glyph-tables.ts` holds when absent. Supplied by a test that builds its own. */
+  readonly verifiedGlyphTables?: ReadonlyMap<string, VerifiedGlyphTableSource>;
 }
 interface FontResolverService {
   readonly metrics: FontMetricsPort;

package/dist/font-read.js

@@ -10,6 +10,7 @@ import { parseToUnicodeCMap } from "./cmap.js";
 import { symbolGlyphName, zapfDingbatsGlyphName } from "./encoding-symbol-tables.js";
 import { resolveStandardFont } from "./fonts.js";
 import { symbolFontOf, withSymbolFontCharacters } from "./symbol-font-private-use.js";
+import { VERIFIED_GLYPH_FAMILIES, programDigest, verifiedGlyphTableOfDigest } from "./verified-glyph-tables.js";
 //#region src/font-read.ts
 const BITS_PER_BYTE = 8;
 const SYMBOLIC_FLAG_BIT = 4;
@@ -50,6 +51,33 @@ function lazyFontProgram(descriptor, baseFont, context) {
 		return read.encoding;
 	};
 }
+function lazyVerifiedGlyphTable(descriptor, family, context) {
+	let read;
+	return () => {
+		if (descriptor === void 0 || !VERIFIED_GLYPH_FAMILIES.has(family)) return;
+		read ??= { table: verifiedGlyphTableOfProgram(descriptor, family, context) };
+		return read.table;
+	};
+}
+const PROGRAM_DIGESTS = /* @__PURE__ */ new WeakMap();
+function digestOfFontStream(stream, context) {
+	let digest = PROGRAM_DIGESTS.get(stream);
+	if (digest === void 0) {
+		digest = programDigest(decodeStream(stream.raw, stream.dict, context.sink).bytes);
+		PROGRAM_DIGESTS.set(stream, digest);
+	}
+	return digest;
+}
+function verifiedGlyphTableOfProgram(descriptor, family, context) {
+	for (const key of [
+		"FontFile3",
+		"FontFile2",
+		"FontFile"
+	]) {
+		const stream = context.resolver.resolve(dictGet(descriptor, key));
+		if (stream?.kind === "stream") return verifiedGlyphTableOfDigest(family, digestOfFontStream(stream, context), context.verifiedGlyphTables);
+	}
+}
 function readDifferencesMap(differences) {
 	const map = /* @__PURE__ */ new Map();
 	if (differences === void 0) return map;
@@ -86,6 +114,7 @@ function buildSimpleFont(fontDict, context) {
 	const symbolic = styleFlags.symbolic ?? false;
 	const builtinGlyphName = builtinSymbolGlyphNameLookup(baseFamily);
 	const symbolFont = symbolFontOf(baseFamily);
+	const verifiedGlyphs = lazyVerifiedGlyphTable(descriptor, baseFamily, context);
 	const widthsArr = resolvedArray(dictGet(fontDict, "Widths"), context);
 	const firstChar = asNumber(dictGet(fontDict, "FirstChar")) ?? 0;
 	const missingWidth = (descriptor !== void 0 ? asNumber(dictGet(descriptor, "MissingWidth")) : void 0) ?? 0;
@@ -170,6 +199,12 @@ function buildSimpleFont(fontDict, context) {
 		let out = "";
 		let unmapped = 0;
 		for (const code of codes) {
+			const glyphName = differencesMap.get(code) ?? namedBaseGlyphName?.(code);
+			const verified = glyphName === void 0 ? void 0 : verifiedGlyphs()?.glyphs.get(glyphName);
+			if (verified !== void 0) {
+				out += verified;
+				continue;
+			}
 			const viaToUnicode = toUnicode?.lookup(code);
 			if (viaToUnicode !== void 0) {
 				out += withSymbolFontCharacters(symbolFont, viaToUnicode);

package/dist/verified-glyph-tables-B_ZoMhyT.d.cts

@@ -0,0 +1,38 @@
+//#region src/verified-glyph-tables.d.ts
+/**
+ * The SHA-256 of a decoded font program as lower-case hex, the key the verified subsets are filed under.
+ * @param bytes - The decoded bytes of the embedded font program.
+ * @returns The digest.
+ */
+declare function programDigest(bytes: Uint8Array<ArrayBuffer>): string;
+/** One verified subset: the font family its `/BaseFont` names (the subset tag taken off) and the character each listed glyph draws, by the program's own glyph name. */
+interface VerifiedGlyphTable {
+  readonly family: string;
+  readonly glyphs: ReadonlyMap<string, string>;
+}
+interface VerifiedGlyphTableSource {
+  readonly family: string;
+  readonly glyphs: Readonly<Record<string, string>>;
+}
+/** The subsets checked so far, by the SHA-256 of the decoded font program. */
+declare const VERIFIED_SOURCES: ReadonlyMap<string, VerifiedGlyphTableSource>;
+/** The font families some verified subset belongs to: a font of any other family is not hashed. */
+declare const VERIFIED_GLYPH_FAMILIES: ReadonlySet<string>;
+/**
+ * The verified table for an embedded font program given its digest, or `undefined` for any program that is not exactly one that was checked.
+ * @param family - The font's family as `styleFromBaseFontName` reads it: the table is used only for a font whose family is the one it was checked for.
+ * @param digest - The SHA-256 of the decoded font program (`programDigest`).
+ * @param tables - The verified subsets to look in, by program SHA-256; the checked ones unless a test supplies its own.
+ * @returns The table for that subset, or `undefined`.
+ */
+declare function verifiedGlyphTableOfDigest(family: string, digest: string, tables?: ReadonlyMap<string, VerifiedGlyphTableSource>): VerifiedGlyphTable | undefined;
+/**
+ * The verified table for an embedded font program, or `undefined` for any program that is not exactly one that was checked.
+ * @param family - The font's family as `styleFromBaseFontName` reads it: the table is used only for a font whose family is the one it was checked for.
+ * @param program - The decoded bytes of the embedded font program.
+ * @param tables - The verified subsets to look in, by program SHA-256; the checked ones unless a test supplies its own.
+ * @returns The table for that subset, or `undefined`.
+ */
+declare function verifiedGlyphTableFor(family: string, program: Uint8Array<ArrayBuffer>, tables?: ReadonlyMap<string, VerifiedGlyphTableSource>): VerifiedGlyphTable | undefined;
+//#endregion
+export { programDigest as a, VerifiedGlyphTableSource as i, VERIFIED_SOURCES as n, verifiedGlyphTableFor as o, VerifiedGlyphTable as r, verifiedGlyphTableOfDigest as s, VERIFIED_GLYPH_FAMILIES as t };

package/dist/verified-glyph-tables-B_ZoMhyT.d.ts

@@ -0,0 +1,38 @@
+//#region src/verified-glyph-tables.d.ts
+/**
+ * The SHA-256 of a decoded font program as lower-case hex, the key the verified subsets are filed under.
+ * @param bytes - The decoded bytes of the embedded font program.
+ * @returns The digest.
+ */
+declare function programDigest(bytes: Uint8Array<ArrayBuffer>): string;
+/** One verified subset: the font family its `/BaseFont` names (the subset tag taken off) and the character each listed glyph draws, by the program's own glyph name. */
+interface VerifiedGlyphTable {
+  readonly family: string;
+  readonly glyphs: ReadonlyMap<string, string>;
+}
+interface VerifiedGlyphTableSource {
+  readonly family: string;
+  readonly glyphs: Readonly<Record<string, string>>;
+}
+/** The subsets checked so far, by the SHA-256 of the decoded font program. */
+declare const VERIFIED_SOURCES: ReadonlyMap<string, VerifiedGlyphTableSource>;
+/** The font families some verified subset belongs to: a font of any other family is not hashed. */
+declare const VERIFIED_GLYPH_FAMILIES: ReadonlySet<string>;
+/**
+ * The verified table for an embedded font program given its digest, or `undefined` for any program that is not exactly one that was checked.
+ * @param family - The font's family as `styleFromBaseFontName` reads it: the table is used only for a font whose family is the one it was checked for.
+ * @param digest - The SHA-256 of the decoded font program (`programDigest`).
+ * @param tables - The verified subsets to look in, by program SHA-256; the checked ones unless a test supplies its own.
+ * @returns The table for that subset, or `undefined`.
+ */
+declare function verifiedGlyphTableOfDigest(family: string, digest: string, tables?: ReadonlyMap<string, VerifiedGlyphTableSource>): VerifiedGlyphTable | undefined;
+/**
+ * The verified table for an embedded font program, or `undefined` for any program that is not exactly one that was checked.
+ * @param family - The font's family as `styleFromBaseFontName` reads it: the table is used only for a font whose family is the one it was checked for.
+ * @param program - The decoded bytes of the embedded font program.
+ * @param tables - The verified subsets to look in, by program SHA-256; the checked ones unless a test supplies its own.
+ * @returns The table for that subset, or `undefined`.
+ */
+declare function verifiedGlyphTableFor(family: string, program: Uint8Array<ArrayBuffer>, tables?: ReadonlyMap<string, VerifiedGlyphTableSource>): VerifiedGlyphTable | undefined;
+//#endregion
+export { programDigest as a, VerifiedGlyphTableSource as i, VERIFIED_SOURCES as n, verifiedGlyphTableFor as o, VerifiedGlyphTable as r, verifiedGlyphTableOfDigest as s, VERIFIED_GLYPH_FAMILIES as t };

package/dist/verified-glyph-tables.cjs

@@ -0,0 +1,398 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_crypto_sha2 = require("./crypto/sha2.cjs");
+//#region src/verified-glyph-tables.ts
+const HEX_RADIX = 16;
+const HEX_DIGITS_PER_BYTE = 2;
+/**
+* The SHA-256 of a decoded font program as lower-case hex, the key the verified subsets are filed under.
+* @param bytes - The decoded bytes of the embedded font program.
+* @returns The digest.
+*/
+function programDigest(bytes) {
+	return Array.from(require_crypto_sha2.sha256(bytes), (byte) => byte.toString(HEX_RADIX).padStart(HEX_DIGITS_PER_BYTE, "0")).join("");
+}
+/** The subsets checked so far, by the SHA-256 of the decoded font program. */
+const VERIFIED_SOURCES = /* @__PURE__ */ new Map([
+	["f483d278b1ade68af30ba62e57752933bccea6ee61d388fbf73ed2047feb620c", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			onequarter: "=",
+			thorn: "+"
+		}
+	}],
+	["40b088a33057f42fdb763f1eb9e849574a925ce59e413a0e94617b3333b40056", {
+		family: "AdvMT_MI",
+		glyphs: {
+			C11: "α",
+			C12: "β",
+			C13: "γ",
+			C14: "δ",
+			C15: "ϵ",
+			C17: "η",
+			C18: "θ",
+			C20: "κ",
+			C21: "λ",
+			C22: "μ",
+			C23: "ν",
+			C25: "π",
+			C26: "ρ",
+			C27: "σ",
+			C28: "τ",
+			C30: "ϕ",
+			C31: "χ",
+			at: "∂",
+			colon: ".",
+			equal: "/",
+			exclam: "ω",
+			greater: ">",
+			less: "<",
+			quotedbl: "ε",
+			semicolon: ","
+		}
+	}],
+	["99212d4f61280dcc8ca4377fca8259451eb05e0867a0017c0c41a521cd9fffac", {
+		family: "AdvMT_SY",
+		glyphs: {
+			C0: "−",
+			C1: "⋅",
+			C138: "]",
+			C14: "○",
+			C17: "≡",
+			C18: "⊆",
+			C2: "×",
+			C20: "≤",
+			C21: "≥",
+			C22: "≼",
+			C25: "≈",
+			C26: "⊂",
+			C27: "⊃",
+			C28: "≪",
+			C29: "≫",
+			C3: "∗",
+			C30: "≺",
+			C6: "±",
+			R: "ℛ",
+			Thorn: ")",
+			b: "⌊",
+			backslash: "∩",
+			bracketleft: "∪",
+			c: "⌋",
+			dollar: "↔",
+			eth: "(",
+			exclam: "→",
+			f: "{",
+			ff: "∠",
+			ffi: "≅",
+			g: "}",
+			j: "|",
+			k: "‖",
+			numbersign: "↓",
+			one: "∞",
+			onehalf: "[",
+			onequarter: "=",
+			p: "√",
+			parenright: "⇒",
+			quoteright: "≃",
+			r: "∇",
+			six: "/",
+			thorn: "+",
+			two: "∈",
+			zero: "′"
+		}
+	}],
+	["53ea45831e6c9133d4bb030d84cc8888bfa065dc98a66b9229b2b578f7a2f615", {
+		family: "AdvP4C4E46",
+		glyphs: {
+			C0: "(",
+			C1: ")",
+			C16: "(",
+			C17: ")",
+			C18: "(",
+			C19: ")",
+			p: "√",
+			q: "√",
+			r: "√",
+			s: "√"
+		}
+	}],
+	["6071bcddbb9aa9d41a695f93ec76b9aacd2fee29325cc5a75e05ec39cbe419ac", {
+		family: "AdvP4C4E46",
+		glyphs: {
+			C0: "(",
+			C1: ")",
+			C16: "(",
+			C17: ")",
+			C18: "(",
+			C19: ")",
+			p: "√",
+			r: "√"
+		}
+	}],
+	["60efa155cc8d0a1bbe67f3926b42c856e503074caff150fd2ff6075f0b723ef2", {
+		family: "AdvP4C4E46",
+		glyphs: {
+			C0: "(",
+			C1: ")",
+			C16: "(",
+			C17: ")",
+			C18: "(",
+			C19: ")",
+			C20: "[",
+			C21: "]",
+			C26: "{",
+			C27: "}",
+			Eth: "∫",
+			P: "∑",
+			X: "∑",
+			asciicircum: "⋀",
+			backslash: "⋂",
+			eth: "∫",
+			exclam: ")",
+			five: "⎦",
+			four: "⎣",
+			h: "[",
+			i: "]",
+			numbersign: "]",
+			p: "√",
+			parenleft: "{",
+			q: "√",
+			quotedbl: "[",
+			r: "√",
+			s: "√",
+			space: "(",
+			three: "⎤",
+			two: "⎡"
+		}
+	}],
+	["a8442ad73af43eb9abec5cb790fe053953caf2cba069038689c1091a8bf1da57", {
+		family: "AdvP4C4E46",
+		glyphs: {
+			C0: "(",
+			C1: ")",
+			C16: "(",
+			C17: ")",
+			C18: "(",
+			C19: ")",
+			C20: "[",
+			C21: "]",
+			C26: "{",
+			C27: "}",
+			Eth: "∫",
+			P: "∑",
+			eth: "∫",
+			five: "⎦",
+			four: "⎣",
+			h: "[",
+			i: "]",
+			p: "√",
+			q: "√",
+			r: "√",
+			three: "⎤",
+			two: "⎡"
+		}
+	}],
+	["f2c12f17afd97014ccf6002befb9a7fa5c9156788bb9a616a5f9d31f8b5aaedd", {
+		family: "AdvP4C4E46",
+		glyphs: {
+			C16: "(",
+			C17: ")",
+			C18: "(",
+			C19: ")",
+			C20: "[",
+			C21: "]",
+			exclam: ")",
+			five: "⎦",
+			four: "⎣",
+			h: "[",
+			i: "]",
+			p: "√",
+			q: "√",
+			r: "√",
+			space: "(",
+			three: "⎤",
+			two: "⎡"
+		}
+	}],
+	["93463c42e9491b79f82f761b522ae2de72b6217efccd186930df7237ef8002ef", {
+		family: "AdvP4C4E51",
+		glyphs: {
+			colon: ".",
+			equal: "/",
+			greater: ">",
+			less: "<",
+			semicolon: ","
+		}
+	}],
+	["967c167a737966cddc29a62e6f0601efc797d1f9453d0f3df558306b2d8b91e2", {
+		family: "AdvP4C4E59",
+		glyphs: {
+			C1: "Δ",
+			C10: "Ω"
+		}
+	}],
+	["38c8aa8ccee56512b9816a6c93c2e2b166166b672560b5f827eef19c43626bd3", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			C0: "−",
+			C14: "○",
+			C2: "×",
+			C20: "≤",
+			C21: "≥",
+			C3: "∗",
+			C6: "±",
+			Thorn: ")",
+			eth: "(",
+			onequarter: "=",
+			p: "√",
+			slash: "∝",
+			thorn: "+",
+			zero: "′"
+		}
+	}],
+	["4061cae07e31ac6441fef12114942a58d0bae5f64a0789932ee703654990a769", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			C0: "−",
+			C1: "⋅",
+			C138: "]",
+			C14: "○",
+			C2: "×",
+			C20: "≤",
+			C21: "≥",
+			C6: "±",
+			C8: "⊕",
+			Thorn: ")",
+			eth: "(",
+			f: "{",
+			ff: "∠",
+			g: "}",
+			j: "|",
+			onehalf: "[",
+			onequarter: "=",
+			p: "√",
+			parenright: "⇒",
+			slash: "∝",
+			thorn: "+",
+			zero: "′"
+		}
+	}],
+	["4983c0bc19d073482c226511409622f6009444f10660bd4d6fd146e876af1eb0", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			C0: "−",
+			C1: "⋅",
+			C138: "]",
+			C14: "○",
+			C2: "×",
+			C20: "≤",
+			C3: "∗",
+			C6: "±",
+			Thorn: ")",
+			eth: "(",
+			f: "{",
+			ff: "∠",
+			g: "}",
+			numbersign: "↓",
+			onehalf: "[",
+			onequarter: "=",
+			p: "√",
+			slash: "∝",
+			thorn: "+"
+		}
+	}],
+	["ccf77c4a71142b8025af5b751a4cc473204521ea2eddcf1d91f1713182c5aecf", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			C0: "−",
+			C1: "⋅",
+			C138: "]",
+			C14: "○",
+			C15: "●",
+			C2: "×",
+			C20: "≤",
+			C21: "≥",
+			C24: "∼",
+			C25: "≈",
+			C29: "≫",
+			C3: "∗",
+			C6: "±",
+			Thorn: ")",
+			b: "⌊",
+			c: "⌋",
+			eth: "(",
+			exclam: "→",
+			f: "{",
+			ff: "∠",
+			ffi: "≅",
+			g: "}",
+			j: "|",
+			one: "∞",
+			onehalf: "[",
+			onequarter: "=",
+			p: "√",
+			parenright: "⇒",
+			r: "∇",
+			six: "/",
+			slash: "∝",
+			space: "←",
+			thorn: "+",
+			two: "∈",
+			zero: "′"
+		}
+	}],
+	["dc3008dbca19a91b63116bcfed491a45776faffadc2c8063b5367c71bf1657d1", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			C0: "−",
+			C138: "]",
+			C14: "○",
+			C2: "×",
+			C20: "≤",
+			C21: "≥",
+			C4: "÷",
+			C6: "±",
+			Thorn: ")",
+			eth: "(",
+			onehalf: "[",
+			onequarter: "=",
+			p: "√",
+			slash: "∝",
+			thorn: "+"
+		}
+	}]
+]);
+function tableOf(source) {
+	return {
+		family: source.family,
+		glyphs: new Map(Object.entries(source.glyphs))
+	};
+}
+/** The font families some verified subset belongs to: a font of any other family is not hashed. */
+const VERIFIED_GLYPH_FAMILIES = new Set([...VERIFIED_SOURCES.values()].map((source) => source.family));
+/**
+* The verified table for an embedded font program given its digest, or `undefined` for any program that is not exactly one that was checked.
+* @param family - The font's family as `styleFromBaseFontName` reads it: the table is used only for a font whose family is the one it was checked for.
+* @param digest - The SHA-256 of the decoded font program (`programDigest`).
+* @param tables - The verified subsets to look in, by program SHA-256; the checked ones unless a test supplies its own.
+* @returns The table for that subset, or `undefined`.
+*/
+function verifiedGlyphTableOfDigest(family, digest, tables = VERIFIED_SOURCES) {
+	const source = tables.get(digest);
+	return source?.family === family ? tableOf(source) : void 0;
+}
+/**
+* The verified table for an embedded font program, or `undefined` for any program that is not exactly one that was checked.
+* @param family - The font's family as `styleFromBaseFontName` reads it: the table is used only for a font whose family is the one it was checked for.
+* @param program - The decoded bytes of the embedded font program.
+* @param tables - The verified subsets to look in, by program SHA-256; the checked ones unless a test supplies its own.
+* @returns The table for that subset, or `undefined`.
+*/
+function verifiedGlyphTableFor(family, program, tables = VERIFIED_SOURCES) {
+	return verifiedGlyphTableOfDigest(family, programDigest(program), tables);
+}
+//#endregion
+exports.VERIFIED_GLYPH_FAMILIES = VERIFIED_GLYPH_FAMILIES;
+exports.VERIFIED_SOURCES = VERIFIED_SOURCES;
+exports.programDigest = programDigest;
+exports.verifiedGlyphTableFor = verifiedGlyphTableFor;
+exports.verifiedGlyphTableOfDigest = verifiedGlyphTableOfDigest;

package/dist/verified-glyph-tables.d.cts

@@ -0,0 +1,2 @@
+import { a as programDigest, i as VerifiedGlyphTableSource, n as VERIFIED_SOURCES, o as verifiedGlyphTableFor, r as VerifiedGlyphTable, s as verifiedGlyphTableOfDigest, t as VERIFIED_GLYPH_FAMILIES } from "./verified-glyph-tables-B_ZoMhyT.cjs";
+export { VERIFIED_GLYPH_FAMILIES, VERIFIED_SOURCES, VerifiedGlyphTable, VerifiedGlyphTableSource, programDigest, verifiedGlyphTableFor, verifiedGlyphTableOfDigest };

package/dist/verified-glyph-tables.d.ts

@@ -0,0 +1,2 @@
+import { a as programDigest, i as VerifiedGlyphTableSource, n as VERIFIED_SOURCES, o as verifiedGlyphTableFor, r as VerifiedGlyphTable, s as verifiedGlyphTableOfDigest, t as VERIFIED_GLYPH_FAMILIES } from "./verified-glyph-tables-B_ZoMhyT.js";
+export { VERIFIED_GLYPH_FAMILIES, VERIFIED_SOURCES, VerifiedGlyphTable, VerifiedGlyphTableSource, programDigest, verifiedGlyphTableFor, verifiedGlyphTableOfDigest };

package/dist/verified-glyph-tables.js

@@ -0,0 +1,393 @@
+import { sha256 } from "./crypto/sha2.js";
+//#region src/verified-glyph-tables.ts
+const HEX_RADIX = 16;
+const HEX_DIGITS_PER_BYTE = 2;
+/**
+* The SHA-256 of a decoded font program as lower-case hex, the key the verified subsets are filed under.
+* @param bytes - The decoded bytes of the embedded font program.
+* @returns The digest.
+*/
+function programDigest(bytes) {
+	return Array.from(sha256(bytes), (byte) => byte.toString(HEX_RADIX).padStart(HEX_DIGITS_PER_BYTE, "0")).join("");
+}
+/** The subsets checked so far, by the SHA-256 of the decoded font program. */
+const VERIFIED_SOURCES = /* @__PURE__ */ new Map([
+	["f483d278b1ade68af30ba62e57752933bccea6ee61d388fbf73ed2047feb620c", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			onequarter: "=",
+			thorn: "+"
+		}
+	}],
+	["40b088a33057f42fdb763f1eb9e849574a925ce59e413a0e94617b3333b40056", {
+		family: "AdvMT_MI",
+		glyphs: {
+			C11: "α",
+			C12: "β",
+			C13: "γ",
+			C14: "δ",
+			C15: "ϵ",
+			C17: "η",
+			C18: "θ",
+			C20: "κ",
+			C21: "λ",
+			C22: "μ",
+			C23: "ν",
+			C25: "π",
+			C26: "ρ",
+			C27: "σ",
+			C28: "τ",
+			C30: "ϕ",
+			C31: "χ",
+			at: "∂",
+			colon: ".",
+			equal: "/",
+			exclam: "ω",
+			greater: ">",
+			less: "<",
+			quotedbl: "ε",
+			semicolon: ","
+		}
+	}],
+	["99212d4f61280dcc8ca4377fca8259451eb05e0867a0017c0c41a521cd9fffac", {
+		family: "AdvMT_SY",
+		glyphs: {
+			C0: "−",
+			C1: "⋅",
+			C138: "]",
+			C14: "○",
+			C17: "≡",
+			C18: "⊆",
+			C2: "×",
+			C20: "≤",
+			C21: "≥",
+			C22: "≼",
+			C25: "≈",
+			C26: "⊂",
+			C27: "⊃",
+			C28: "≪",
+			C29: "≫",
+			C3: "∗",
+			C30: "≺",
+			C6: "±",
+			R: "ℛ",
+			Thorn: ")",
+			b: "⌊",
+			backslash: "∩",
+			bracketleft: "∪",
+			c: "⌋",
+			dollar: "↔",
+			eth: "(",
+			exclam: "→",
+			f: "{",
+			ff: "∠",
+			ffi: "≅",
+			g: "}",
+			j: "|",
+			k: "‖",
+			numbersign: "↓",
+			one: "∞",
+			onehalf: "[",
+			onequarter: "=",
+			p: "√",
+			parenright: "⇒",
+			quoteright: "≃",
+			r: "∇",
+			six: "/",
+			thorn: "+",
+			two: "∈",
+			zero: "′"
+		}
+	}],
+	["53ea45831e6c9133d4bb030d84cc8888bfa065dc98a66b9229b2b578f7a2f615", {
+		family: "AdvP4C4E46",
+		glyphs: {
+			C0: "(",
+			C1: ")",
+			C16: "(",
+			C17: ")",
+			C18: "(",
+			C19: ")",
+			p: "√",
+			q: "√",
+			r: "√",
+			s: "√"
+		}
+	}],
+	["6071bcddbb9aa9d41a695f93ec76b9aacd2fee29325cc5a75e05ec39cbe419ac", {
+		family: "AdvP4C4E46",
+		glyphs: {
+			C0: "(",
+			C1: ")",
+			C16: "(",
+			C17: ")",
+			C18: "(",
+			C19: ")",
+			p: "√",
+			r: "√"
+		}
+	}],
+	["60efa155cc8d0a1bbe67f3926b42c856e503074caff150fd2ff6075f0b723ef2", {
+		family: "AdvP4C4E46",
+		glyphs: {
+			C0: "(",
+			C1: ")",
+			C16: "(",
+			C17: ")",
+			C18: "(",
+			C19: ")",
+			C20: "[",
+			C21: "]",
+			C26: "{",
+			C27: "}",
+			Eth: "∫",
+			P: "∑",
+			X: "∑",
+			asciicircum: "⋀",
+			backslash: "⋂",
+			eth: "∫",
+			exclam: ")",
+			five: "⎦",
+			four: "⎣",
+			h: "[",
+			i: "]",
+			numbersign: "]",
+			p: "√",
+			parenleft: "{",
+			q: "√",
+			quotedbl: "[",
+			r: "√",
+			s: "√",
+			space: "(",
+			three: "⎤",
+			two: "⎡"
+		}
+	}],
+	["a8442ad73af43eb9abec5cb790fe053953caf2cba069038689c1091a8bf1da57", {
+		family: "AdvP4C4E46",
+		glyphs: {
+			C0: "(",
+			C1: ")",
+			C16: "(",
+			C17: ")",
+			C18: "(",
+			C19: ")",
+			C20: "[",
+			C21: "]",
+			C26: "{",
+			C27: "}",
+			Eth: "∫",
+			P: "∑",
+			eth: "∫",
+			five: "⎦",
+			four: "⎣",
+			h: "[",
+			i: "]",
+			p: "√",
+			q: "√",
+			r: "√",
+			three: "⎤",
+			two: "⎡"
+		}
+	}],
+	["f2c12f17afd97014ccf6002befb9a7fa5c9156788bb9a616a5f9d31f8b5aaedd", {
+		family: "AdvP4C4E46",
+		glyphs: {
+			C16: "(",
+			C17: ")",
+			C18: "(",
+			C19: ")",
+			C20: "[",
+			C21: "]",
+			exclam: ")",
+			five: "⎦",
+			four: "⎣",
+			h: "[",
+			i: "]",
+			p: "√",
+			q: "√",
+			r: "√",
+			space: "(",
+			three: "⎤",
+			two: "⎡"
+		}
+	}],
+	["93463c42e9491b79f82f761b522ae2de72b6217efccd186930df7237ef8002ef", {
+		family: "AdvP4C4E51",
+		glyphs: {
+			colon: ".",
+			equal: "/",
+			greater: ">",
+			less: "<",
+			semicolon: ","
+		}
+	}],
+	["967c167a737966cddc29a62e6f0601efc797d1f9453d0f3df558306b2d8b91e2", {
+		family: "AdvP4C4E59",
+		glyphs: {
+			C1: "Δ",
+			C10: "Ω"
+		}
+	}],
+	["38c8aa8ccee56512b9816a6c93c2e2b166166b672560b5f827eef19c43626bd3", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			C0: "−",
+			C14: "○",
+			C2: "×",
+			C20: "≤",
+			C21: "≥",
+			C3: "∗",
+			C6: "±",
+			Thorn: ")",
+			eth: "(",
+			onequarter: "=",
+			p: "√",
+			slash: "∝",
+			thorn: "+",
+			zero: "′"
+		}
+	}],
+	["4061cae07e31ac6441fef12114942a58d0bae5f64a0789932ee703654990a769", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			C0: "−",
+			C1: "⋅",
+			C138: "]",
+			C14: "○",
+			C2: "×",
+			C20: "≤",
+			C21: "≥",
+			C6: "±",
+			C8: "⊕",
+			Thorn: ")",
+			eth: "(",
+			f: "{",
+			ff: "∠",
+			g: "}",
+			j: "|",
+			onehalf: "[",
+			onequarter: "=",
+			p: "√",
+			parenright: "⇒",
+			slash: "∝",
+			thorn: "+",
+			zero: "′"
+		}
+	}],
+	["4983c0bc19d073482c226511409622f6009444f10660bd4d6fd146e876af1eb0", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			C0: "−",
+			C1: "⋅",
+			C138: "]",
+			C14: "○",
+			C2: "×",
+			C20: "≤",
+			C3: "∗",
+			C6: "±",
+			Thorn: ")",
+			eth: "(",
+			f: "{",
+			ff: "∠",
+			g: "}",
+			numbersign: "↓",
+			onehalf: "[",
+			onequarter: "=",
+			p: "√",
+			slash: "∝",
+			thorn: "+"
+		}
+	}],
+	["ccf77c4a71142b8025af5b751a4cc473204521ea2eddcf1d91f1713182c5aecf", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			C0: "−",
+			C1: "⋅",
+			C138: "]",
+			C14: "○",
+			C15: "●",
+			C2: "×",
+			C20: "≤",
+			C21: "≥",
+			C24: "∼",
+			C25: "≈",
+			C29: "≫",
+			C3: "∗",
+			C6: "±",
+			Thorn: ")",
+			b: "⌊",
+			c: "⌋",
+			eth: "(",
+			exclam: "→",
+			f: "{",
+			ff: "∠",
+			ffi: "≅",
+			g: "}",
+			j: "|",
+			one: "∞",
+			onehalf: "[",
+			onequarter: "=",
+			p: "√",
+			parenright: "⇒",
+			r: "∇",
+			six: "/",
+			slash: "∝",
+			space: "←",
+			thorn: "+",
+			two: "∈",
+			zero: "′"
+		}
+	}],
+	["dc3008dbca19a91b63116bcfed491a45776faffadc2c8063b5367c71bf1657d1", {
+		family: "AdvP4C4E74",
+		glyphs: {
+			C0: "−",
+			C138: "]",
+			C14: "○",
+			C2: "×",
+			C20: "≤",
+			C21: "≥",
+			C4: "÷",
+			C6: "±",
+			Thorn: ")",
+			eth: "(",
+			onehalf: "[",
+			onequarter: "=",
+			p: "√",
+			slash: "∝",
+			thorn: "+"
+		}
+	}]
+]);
+function tableOf(source) {
+	return {
+		family: source.family,
+		glyphs: new Map(Object.entries(source.glyphs))
+	};
+}
+/** The font families some verified subset belongs to: a font of any other family is not hashed. */
+const VERIFIED_GLYPH_FAMILIES = new Set([...VERIFIED_SOURCES.values()].map((source) => source.family));
+/**
+* The verified table for an embedded font program given its digest, or `undefined` for any program that is not exactly one that was checked.
+* @param family - The font's family as `styleFromBaseFontName` reads it: the table is used only for a font whose family is the one it was checked for.
+* @param digest - The SHA-256 of the decoded font program (`programDigest`).
+* @param tables - The verified subsets to look in, by program SHA-256; the checked ones unless a test supplies its own.
+* @returns The table for that subset, or `undefined`.
+*/
+function verifiedGlyphTableOfDigest(family, digest, tables = VERIFIED_SOURCES) {
+	const source = tables.get(digest);
+	return source?.family === family ? tableOf(source) : void 0;
+}
+/**
+* The verified table for an embedded font program, or `undefined` for any program that is not exactly one that was checked.
+* @param family - The font's family as `styleFromBaseFontName` reads it: the table is used only for a font whose family is the one it was checked for.
+* @param program - The decoded bytes of the embedded font program.
+* @param tables - The verified subsets to look in, by program SHA-256; the checked ones unless a test supplies its own.
+* @returns The table for that subset, or `undefined`.
+*/
+function verifiedGlyphTableFor(family, program, tables = VERIFIED_SOURCES) {
+	return verifiedGlyphTableOfDigest(family, programDigest(program), tables);
+}
+//#endregion
+export { VERIFIED_GLYPH_FAMILIES, VERIFIED_SOURCES, programDigest, verifiedGlyphTableFor, verifiedGlyphTableOfDigest };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdf-codec",
-  "version": "5.8.2",
+  "version": "5.8.3",
   "description": "Hand-written, dependency-minimal PDF codec: parses arbitrary real-world PDFs and generates new ones, built on its own codec-owned LayoutDocument item model and Zod 4 codecs.",
   "type": "module",
   "repository": {