pdf-codec 1.4.2 → 1.6.0

package/dist/font-registry.js

@@ -0,0 +1,150 @@
+import { parseSfnt } from "./sfnt.js";
+import { base64ToBytes } from "./util/base64.js";
+import { normalizeFamilyName, resolveStandardFont } from "./fonts.js";
+import { loadEmbeddedFace } from "./embedded-font.js";
+import { CALADEA_BOLD_FONT_DEFLATED_BASE64 } from "./assets/caladea-bold.js";
+import { CALADEA_BOLDITALIC_FONT_DEFLATED_BASE64 } from "./assets/caladea-bolditalic.js";
+import { CALADEA_ITALIC_FONT_DEFLATED_BASE64 } from "./assets/caladea-italic.js";
+import { CALADEA_REGULAR_FONT_DEFLATED_BASE64 } from "./assets/caladea-regular.js";
+import { CARLITO_BOLD_FONT_DEFLATED_BASE64 } from "./assets/carlito-bold.js";
+import { CARLITO_BOLDITALIC_FONT_DEFLATED_BASE64 } from "./assets/carlito-bolditalic.js";
+import { CARLITO_ITALIC_FONT_DEFLATED_BASE64 } from "./assets/carlito-italic.js";
+import { CARLITO_REGULAR_FONT_DEFLATED_BASE64 } from "./assets/carlito-regular.js";
+import { resolveVendoredSubstituteFamily } from "./font-substitutes.js";
+import { inflateSync } from "fflate";
+//#region src/font-registry.ts
+function faceCacheKey(family, bold, italic) {
+	return `${normalizeFamilyName(family)}|${bold ? 1 : 0}|${italic ? 1 : 0}`;
+}
+function embedFace(bytes) {
+	const sfnt = parseSfnt(bytes);
+	if (sfnt === void 0) return;
+	return loadEmbeddedFace(sfnt);
+}
+function findExactFace(list, family, bold, italic) {
+	const normalized = normalizeFamilyName(family);
+	return list.find((candidate) => normalizeFamilyName(candidate.family) === normalized && candidate.bold === bold && candidate.italic === italic);
+}
+function findFamilyRegular(list, family) {
+	const normalized = normalizeFamilyName(family);
+	const familyFaces = list.filter((candidate) => normalizeFamilyName(candidate.family) === normalized);
+	if (familyFaces.length === 0) return;
+	return familyFaces.find((candidate) => !candidate.bold && !candidate.italic) ?? familyFaces[0];
+}
+const vendoredFaceBytesCache = /* @__PURE__ */ new Map();
+const VENDORED_FACE_BASE64 = {
+	carlito: {
+		regular: CARLITO_REGULAR_FONT_DEFLATED_BASE64,
+		bold: CARLITO_BOLD_FONT_DEFLATED_BASE64,
+		italic: CARLITO_ITALIC_FONT_DEFLATED_BASE64,
+		boldItalic: CARLITO_BOLDITALIC_FONT_DEFLATED_BASE64
+	},
+	caladea: {
+		regular: CALADEA_REGULAR_FONT_DEFLATED_BASE64,
+		bold: CALADEA_BOLD_FONT_DEFLATED_BASE64,
+		italic: CALADEA_ITALIC_FONT_DEFLATED_BASE64,
+		boldItalic: CALADEA_BOLDITALIC_FONT_DEFLATED_BASE64
+	}
+};
+function loadVendoredFaceBytes(family, bold, italic) {
+	const faceKey = bold && italic ? "boldItalic" : bold ? "bold" : italic ? "italic" : "regular";
+	const cacheKey = `${family}-${faceKey}`;
+	const cached = vendoredFaceBytesCache.get(cacheKey);
+	if (cached !== void 0) return cached;
+	const deflatedBase64 = VENDORED_FACE_BASE64[family][faceKey];
+	const inflated = inflateSync(base64ToBytes(deflatedBase64));
+	const bytes = new Uint8Array(inflated.length);
+	bytes.set(inflated);
+	vendoredFaceBytesCache.set(cacheKey, bytes);
+	return bytes;
+}
+function createFontRegistry(options = {}) {
+	const sourceFonts = options.sourceFonts ?? [];
+	const fonts = options.fonts ?? [];
+	const substitutesEnabled = (options.substitutes ?? "vendored") === "vendored";
+	const onSubstitution = options.onSubstitution;
+	const cache = /* @__PURE__ */ new Map();
+	function resolveUncached(family, bold, italic) {
+		const sourceExact = findExactFace(sourceFonts, family, bold, italic);
+		if (sourceExact !== void 0) {
+			const face = embedFace(sourceExact.bytes);
+			if (face !== void 0) return {
+				kind: "embedded",
+				face
+			};
+		}
+		const callerExact = findExactFace(fonts, family, bold, italic);
+		if (callerExact !== void 0) {
+			const face = embedFace(callerExact.bytes);
+			if (face !== void 0) return {
+				kind: "embedded",
+				face
+			};
+		}
+		const sourceFamilyRegular = findFamilyRegular(sourceFonts, family);
+		const callerFamilyRegular = sourceFamilyRegular === void 0 ? findFamilyRegular(fonts, family) : void 0;
+		const familyRegular = sourceFamilyRegular ?? callerFamilyRegular;
+		if (familyRegular !== void 0) {
+			const face = embedFace(familyRegular.bytes);
+			if (face !== void 0) {
+				onSubstitution?.({
+					requestedFamily: family,
+					requestedBold: bold,
+					requestedItalic: italic,
+					reason: "missing-face",
+					resolvedFamily: family
+				});
+				return {
+					kind: "embedded",
+					face
+				};
+			}
+		}
+		if (substitutesEnabled) {
+			const vendoredFamily = resolveVendoredSubstituteFamily(family);
+			if (vendoredFamily !== void 0) {
+				const face = embedFace(loadVendoredFaceBytes(vendoredFamily, bold, italic));
+				if (face !== void 0) {
+					onSubstitution?.({
+						requestedFamily: family,
+						requestedBold: bold,
+						requestedItalic: italic,
+						reason: "vendored-substitute",
+						resolvedFamily: vendoredFamily
+					});
+					return {
+						kind: "embedded",
+						face
+					};
+				}
+			}
+		}
+		const standard = resolveStandardFont(family, bold, italic);
+		return {
+			kind: "standard",
+			standardName: standard.standardName,
+			matched: standard.matched
+		};
+	}
+	return { resolve(font) {
+		const bold = font.weight === "bold";
+		const italic = font.style === "italic";
+		const key = faceCacheKey(font.family, bold, italic);
+		const cached = cache.get(key);
+		if (cached !== void 0) return cached;
+		const resolved = resolveUncached(font.family, bold, italic);
+		cache.set(key, resolved);
+		return resolved;
+	} };
+}
+function resolveFaceWithRegistry(registry, font) {
+	if (registry !== void 0) return registry.resolve(font);
+	const standard = resolveStandardFont(font.family, font.weight === "bold", font.style === "italic");
+	return {
+		kind: "standard",
+		standardName: standard.standardName,
+		matched: standard.matched
+	};
+}
+//#endregion
+export { createFontRegistry, resolveFaceWithRegistry };

package/dist/font-substitutes.cjs

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_fonts = require("./fonts.cjs");
+//#region src/font-substitutes.ts
+const SUBSTITUTE_FAMILY_BY_NORMALIZED_NAME = /* @__PURE__ */ new Map([
+	["calibri", "carlito"],
+	["calibrilight", "carlito"],
+	["cambria", "caladea"]
+]);
+function resolveVendoredSubstituteFamily(rawFamily) {
+	return SUBSTITUTE_FAMILY_BY_NORMALIZED_NAME.get(require_fonts.normalizeFamilyName(rawFamily));
+}
+//#endregion
+exports.resolveVendoredSubstituteFamily = resolveVendoredSubstituteFamily;

package/dist/font-substitutes.d.cts

@@ -0,0 +1,5 @@
+//#region src/font-substitutes.d.ts
+type VendoredFamily = 'carlito' | 'caladea';
+declare function resolveVendoredSubstituteFamily(rawFamily: string): VendoredFamily | undefined;
+//#endregion
+export { VendoredFamily, resolveVendoredSubstituteFamily };

package/dist/font-substitutes.d.ts

@@ -0,0 +1,5 @@
+//#region src/font-substitutes.d.ts
+type VendoredFamily = 'carlito' | 'caladea';
+declare function resolveVendoredSubstituteFamily(rawFamily: string): VendoredFamily | undefined;
+//#endregion
+export { VendoredFamily, resolveVendoredSubstituteFamily };

package/dist/font-substitutes.js

@@ -0,0 +1,12 @@
+import { normalizeFamilyName } from "./fonts.js";
+//#region src/font-substitutes.ts
+const SUBSTITUTE_FAMILY_BY_NORMALIZED_NAME = /* @__PURE__ */ new Map([
+	["calibri", "carlito"],
+	["calibrilight", "carlito"],
+	["cambria", "caladea"]
+]);
+function resolveVendoredSubstituteFamily(rawFamily) {
+	return SUBSTITUTE_FAMILY_BY_NORMALIZED_NAME.get(normalizeFamilyName(rawFamily));
+}
+//#endregion
+export { resolveVendoredSubstituteFamily };

package/dist/font-tables.cjs

@@ -0,0 +1,127 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/font-tables.ts
+const HEAD_TABLE_SIZE = 54;
+const HEAD_MAGIC_NUMBER = 1594834165;
+const MIN_UNITS_PER_EM = 16;
+const MAX_UNITS_PER_EM = 16384;
+function parseHead(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "head");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, HEAD_TABLE_SIZE)) return;
+	if (require_sfnt.u32(bytes, 12) !== HEAD_MAGIC_NUMBER) return;
+	const unitsPerEm = require_sfnt.u16(bytes, 18);
+	if (unitsPerEm < MIN_UNITS_PER_EM || unitsPerEm > MAX_UNITS_PER_EM) return;
+	const indexToLocFormat = require_sfnt.i16(bytes, 50);
+	if (indexToLocFormat !== 0 && indexToLocFormat !== 1) return;
+	return {
+		unitsPerEm,
+		checkSumAdjustment: require_sfnt.u32(bytes, 8),
+		xMin: require_sfnt.i16(bytes, 36),
+		yMin: require_sfnt.i16(bytes, 38),
+		xMax: require_sfnt.i16(bytes, 40),
+		yMax: require_sfnt.i16(bytes, 42),
+		indexToLocFormat
+	};
+}
+const MAXP_HEADER_SIZE = 6;
+function parseMaxp(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "maxp");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, MAXP_HEADER_SIZE)) return;
+	return { numGlyphs: require_sfnt.u16(bytes, 4) };
+}
+const OS2_VERSION_0_SIZE = 78;
+const OS2_VERSION_2_SIZE = 96;
+const OS2_VERSION_WITH_HEIGHTS = 2;
+const OS2_PANOSE_OFFSET = 32;
+function parseOs2(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "OS/2");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, OS2_VERSION_0_SIZE)) return;
+	const version = require_sfnt.u16(bytes, 0);
+	const hasHeights = version >= OS2_VERSION_WITH_HEIGHTS && require_sfnt.hasBytes(bytes, 0, OS2_VERSION_2_SIZE);
+	return {
+		version,
+		fsSelection: require_sfnt.u16(bytes, 62),
+		panose: [...bytes.subarray(OS2_PANOSE_OFFSET, 42)],
+		sTypoAscender: require_sfnt.i16(bytes, 68),
+		sTypoDescender: require_sfnt.i16(bytes, 70),
+		sTypoLineGap: require_sfnt.i16(bytes, 72),
+		usWinAscent: require_sfnt.u16(bytes, 74),
+		usWinDescent: require_sfnt.u16(bytes, 76),
+		sxHeight: hasHeights ? require_sfnt.i16(bytes, 86) : void 0,
+		sCapHeight: hasHeights ? require_sfnt.i16(bytes, 88) : void 0
+	};
+}
+const POST_HEADER_SIZE = 32;
+const FIXED_16_16_SCALE = 65536;
+function parsePost(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "post");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, POST_HEADER_SIZE)) return;
+	return {
+		version: require_sfnt.u32(bytes, 0),
+		italicAngle: require_sfnt.i32(bytes, 4) / FIXED_16_16_SCALE,
+		underlinePosition: require_sfnt.i16(bytes, 8),
+		underlineThickness: require_sfnt.i16(bytes, 10)
+	};
+}
+const NAME_HEADER_SIZE = 6;
+const NAME_RECORD_SIZE = 12;
+const NAME_ID_FAMILY = 1;
+const NAME_ID_POSTSCRIPT = 6;
+const NAME_ID_TYPOGRAPHIC_FAMILY = 16;
+const PLATFORM_UNICODE = 0;
+const PLATFORM_MACINTOSH = 1;
+const PLATFORM_WINDOWS = 3;
+const WINDOWS_ENCODING_UNICODE_BMP = 1;
+const MACINTOSH_ENCODING_ROMAN = 0;
+function decodeUtf16Be(bytes, offset, length) {
+	let text = "";
+	for (let i = 0; i + 1 < length; i += 2) text += String.fromCharCode(bytes[offset + i] << 8 | bytes[offset + i + 1]);
+	return text;
+}
+function decodeMacRoman(bytes, offset, length) {
+	let text = "";
+	for (let i = 0; i < length; i++) text += String.fromCharCode(bytes[offset + i]);
+	return text;
+}
+function platformRank(record) {
+	if (record.platformId === PLATFORM_WINDOWS && record.encodingId === WINDOWS_ENCODING_UNICODE_BMP) return 0;
+	if (record.platformId === PLATFORM_UNICODE) return 1;
+	if (record.platformId === PLATFORM_MACINTOSH && record.encodingId === MACINTOSH_ENCODING_ROMAN) return 2;
+	return 3;
+}
+function readName(bytes, records, nameId) {
+	const matches = records.filter((record) => record.nameId === nameId && platformRank(record) < 3).sort((a, b) => platformRank(a) - platformRank(b));
+	for (const record of matches) {
+		if (!require_sfnt.hasBytes(bytes, record.stringOffset, record.length)) continue;
+		const text = record.platformId === PLATFORM_MACINTOSH ? decodeMacRoman(bytes, record.stringOffset, record.length) : decodeUtf16Be(bytes, record.stringOffset, record.length);
+		if (text.length > 0) return text;
+	}
+}
+function parseName(font) {
+	const bytes = require_sfnt.sfntTableBytes(font, "name");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, NAME_HEADER_SIZE)) return;
+	const count = require_sfnt.u16(bytes, 2);
+	const storageOffset = require_sfnt.u16(bytes, 4);
+	if (!require_sfnt.hasBytes(bytes, NAME_HEADER_SIZE, count * NAME_RECORD_SIZE)) return;
+	const records = [];
+	for (let i = 0; i < count; i++) {
+		const recordOffset = NAME_HEADER_SIZE + i * NAME_RECORD_SIZE;
+		records.push({
+			platformId: require_sfnt.u16(bytes, recordOffset),
+			encodingId: require_sfnt.u16(bytes, recordOffset + 2),
+			nameId: require_sfnt.u16(bytes, recordOffset + 6),
+			length: require_sfnt.u16(bytes, recordOffset + 8),
+			stringOffset: storageOffset + require_sfnt.u16(bytes, recordOffset + 10)
+		});
+	}
+	return {
+		postScriptName: readName(bytes, records, NAME_ID_POSTSCRIPT),
+		familyName: readName(bytes, records, NAME_ID_TYPOGRAPHIC_FAMILY) ?? readName(bytes, records, NAME_ID_FAMILY)
+	};
+}
+//#endregion
+exports.parseHead = parseHead;
+exports.parseMaxp = parseMaxp;
+exports.parseName = parseName;
+exports.parseOs2 = parseOs2;
+exports.parsePost = parsePost;

package/dist/font-tables.d.cts

@@ -0,0 +1,43 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+//#region src/font-tables.d.ts
+interface HeadTable {
+  readonly unitsPerEm: number;
+  readonly checkSumAdjustment: number;
+  readonly xMin: number;
+  readonly yMin: number;
+  readonly xMax: number;
+  readonly yMax: number;
+  readonly indexToLocFormat: 0 | 1;
+}
+declare function parseHead(font: SfntFont): HeadTable | undefined;
+interface MaxpTable {
+  readonly numGlyphs: number;
+}
+declare function parseMaxp(font: SfntFont): MaxpTable | undefined;
+interface Os2Table {
+  readonly version: number;
+  readonly fsSelection: number;
+  readonly panose: readonly number[];
+  readonly sTypoAscender: number;
+  readonly sTypoDescender: number;
+  readonly sTypoLineGap: number;
+  readonly usWinAscent: number;
+  readonly usWinDescent: number;
+  readonly sxHeight: number | undefined;
+  readonly sCapHeight: number | undefined;
+}
+declare function parseOs2(font: SfntFont): Os2Table | undefined;
+interface PostTable {
+  readonly version: number;
+  readonly italicAngle: number;
+  readonly underlinePosition: number;
+  readonly underlineThickness: number;
+}
+declare function parsePost(font: SfntFont): PostTable | undefined;
+interface NameTable {
+  readonly postScriptName: string | undefined;
+  readonly familyName: string | undefined;
+}
+declare function parseName(font: SfntFont): NameTable | undefined;
+//#endregion
+export { HeadTable, MaxpTable, NameTable, Os2Table, PostTable, parseHead, parseMaxp, parseName, parseOs2, parsePost };

package/dist/font-tables.d.ts

@@ -0,0 +1,43 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+//#region src/font-tables.d.ts
+interface HeadTable {
+  readonly unitsPerEm: number;
+  readonly checkSumAdjustment: number;
+  readonly xMin: number;
+  readonly yMin: number;
+  readonly xMax: number;
+  readonly yMax: number;
+  readonly indexToLocFormat: 0 | 1;
+}
+declare function parseHead(font: SfntFont): HeadTable | undefined;
+interface MaxpTable {
+  readonly numGlyphs: number;
+}
+declare function parseMaxp(font: SfntFont): MaxpTable | undefined;
+interface Os2Table {
+  readonly version: number;
+  readonly fsSelection: number;
+  readonly panose: readonly number[];
+  readonly sTypoAscender: number;
+  readonly sTypoDescender: number;
+  readonly sTypoLineGap: number;
+  readonly usWinAscent: number;
+  readonly usWinDescent: number;
+  readonly sxHeight: number | undefined;
+  readonly sCapHeight: number | undefined;
+}
+declare function parseOs2(font: SfntFont): Os2Table | undefined;
+interface PostTable {
+  readonly version: number;
+  readonly italicAngle: number;
+  readonly underlinePosition: number;
+  readonly underlineThickness: number;
+}
+declare function parsePost(font: SfntFont): PostTable | undefined;
+interface NameTable {
+  readonly postScriptName: string | undefined;
+  readonly familyName: string | undefined;
+}
+declare function parseName(font: SfntFont): NameTable | undefined;
+//#endregion
+export { HeadTable, MaxpTable, NameTable, Os2Table, PostTable, parseHead, parseMaxp, parseName, parseOs2, parsePost };

package/dist/font-tables.js

@@ -0,0 +1,122 @@
+import { hasBytes, i16, i32, sfntTableBytes, u16, u32 } from "./sfnt.js";
+//#region src/font-tables.ts
+const HEAD_TABLE_SIZE = 54;
+const HEAD_MAGIC_NUMBER = 1594834165;
+const MIN_UNITS_PER_EM = 16;
+const MAX_UNITS_PER_EM = 16384;
+function parseHead(font) {
+	const bytes = sfntTableBytes(font, "head");
+	if (bytes === void 0 || !hasBytes(bytes, 0, HEAD_TABLE_SIZE)) return;
+	if (u32(bytes, 12) !== HEAD_MAGIC_NUMBER) return;
+	const unitsPerEm = u16(bytes, 18);
+	if (unitsPerEm < MIN_UNITS_PER_EM || unitsPerEm > MAX_UNITS_PER_EM) return;
+	const indexToLocFormat = i16(bytes, 50);
+	if (indexToLocFormat !== 0 && indexToLocFormat !== 1) return;
+	return {
+		unitsPerEm,
+		checkSumAdjustment: u32(bytes, 8),
+		xMin: i16(bytes, 36),
+		yMin: i16(bytes, 38),
+		xMax: i16(bytes, 40),
+		yMax: i16(bytes, 42),
+		indexToLocFormat
+	};
+}
+const MAXP_HEADER_SIZE = 6;
+function parseMaxp(font) {
+	const bytes = sfntTableBytes(font, "maxp");
+	if (bytes === void 0 || !hasBytes(bytes, 0, MAXP_HEADER_SIZE)) return;
+	return { numGlyphs: u16(bytes, 4) };
+}
+const OS2_VERSION_0_SIZE = 78;
+const OS2_VERSION_2_SIZE = 96;
+const OS2_VERSION_WITH_HEIGHTS = 2;
+const OS2_PANOSE_OFFSET = 32;
+function parseOs2(font) {
+	const bytes = sfntTableBytes(font, "OS/2");
+	if (bytes === void 0 || !hasBytes(bytes, 0, OS2_VERSION_0_SIZE)) return;
+	const version = u16(bytes, 0);
+	const hasHeights = version >= OS2_VERSION_WITH_HEIGHTS && hasBytes(bytes, 0, OS2_VERSION_2_SIZE);
+	return {
+		version,
+		fsSelection: u16(bytes, 62),
+		panose: [...bytes.subarray(OS2_PANOSE_OFFSET, 42)],
+		sTypoAscender: i16(bytes, 68),
+		sTypoDescender: i16(bytes, 70),
+		sTypoLineGap: i16(bytes, 72),
+		usWinAscent: u16(bytes, 74),
+		usWinDescent: u16(bytes, 76),
+		sxHeight: hasHeights ? i16(bytes, 86) : void 0,
+		sCapHeight: hasHeights ? i16(bytes, 88) : void 0
+	};
+}
+const POST_HEADER_SIZE = 32;
+const FIXED_16_16_SCALE = 65536;
+function parsePost(font) {
+	const bytes = sfntTableBytes(font, "post");
+	if (bytes === void 0 || !hasBytes(bytes, 0, POST_HEADER_SIZE)) return;
+	return {
+		version: u32(bytes, 0),
+		italicAngle: i32(bytes, 4) / FIXED_16_16_SCALE,
+		underlinePosition: i16(bytes, 8),
+		underlineThickness: i16(bytes, 10)
+	};
+}
+const NAME_HEADER_SIZE = 6;
+const NAME_RECORD_SIZE = 12;
+const NAME_ID_FAMILY = 1;
+const NAME_ID_POSTSCRIPT = 6;
+const NAME_ID_TYPOGRAPHIC_FAMILY = 16;
+const PLATFORM_UNICODE = 0;
+const PLATFORM_MACINTOSH = 1;
+const PLATFORM_WINDOWS = 3;
+const WINDOWS_ENCODING_UNICODE_BMP = 1;
+const MACINTOSH_ENCODING_ROMAN = 0;
+function decodeUtf16Be(bytes, offset, length) {
+	let text = "";
+	for (let i = 0; i + 1 < length; i += 2) text += String.fromCharCode(bytes[offset + i] << 8 | bytes[offset + i + 1]);
+	return text;
+}
+function decodeMacRoman(bytes, offset, length) {
+	let text = "";
+	for (let i = 0; i < length; i++) text += String.fromCharCode(bytes[offset + i]);
+	return text;
+}
+function platformRank(record) {
+	if (record.platformId === PLATFORM_WINDOWS && record.encodingId === WINDOWS_ENCODING_UNICODE_BMP) return 0;
+	if (record.platformId === PLATFORM_UNICODE) return 1;
+	if (record.platformId === PLATFORM_MACINTOSH && record.encodingId === MACINTOSH_ENCODING_ROMAN) return 2;
+	return 3;
+}
+function readName(bytes, records, nameId) {
+	const matches = records.filter((record) => record.nameId === nameId && platformRank(record) < 3).sort((a, b) => platformRank(a) - platformRank(b));
+	for (const record of matches) {
+		if (!hasBytes(bytes, record.stringOffset, record.length)) continue;
+		const text = record.platformId === PLATFORM_MACINTOSH ? decodeMacRoman(bytes, record.stringOffset, record.length) : decodeUtf16Be(bytes, record.stringOffset, record.length);
+		if (text.length > 0) return text;
+	}
+}
+function parseName(font) {
+	const bytes = sfntTableBytes(font, "name");
+	if (bytes === void 0 || !hasBytes(bytes, 0, NAME_HEADER_SIZE)) return;
+	const count = u16(bytes, 2);
+	const storageOffset = u16(bytes, 4);
+	if (!hasBytes(bytes, NAME_HEADER_SIZE, count * NAME_RECORD_SIZE)) return;
+	const records = [];
+	for (let i = 0; i < count; i++) {
+		const recordOffset = NAME_HEADER_SIZE + i * NAME_RECORD_SIZE;
+		records.push({
+			platformId: u16(bytes, recordOffset),
+			encodingId: u16(bytes, recordOffset + 2),
+			nameId: u16(bytes, recordOffset + 6),
+			length: u16(bytes, recordOffset + 8),
+			stringOffset: storageOffset + u16(bytes, recordOffset + 10)
+		});
+	}
+	return {
+		postScriptName: readName(bytes, records, NAME_ID_POSTSCRIPT),
+		familyName: readName(bytes, records, NAME_ID_TYPOGRAPHIC_FAMILY) ?? readName(bytes, records, NAME_ID_FAMILY)
+	};
+}
+//#endregion
+export { parseHead, parseMaxp, parseName, parseOs2, parsePost };

package/dist/fonts.cjs

@@ -120,5 +120,6 @@ function resolveStandardFont(family, bold, italic) {
 	};
 }
 //#endregion
+exports.normalizeFamilyName = normalizeFamilyName;
 exports.resolveFontFamily = resolveFontFamily;
 exports.resolveStandardFont = resolveStandardFont;

package/dist/fonts.d.cts

@@ -1,6 +1,7 @@
 import { r as StandardFontName } from "./afm-widths-DyDq56Ph.cjs";
 //#region src/fonts.d.ts
 type StandardFamily = 'helvetica' | 'times' | 'courier';
+declare function normalizeFamilyName(raw: string): string;
 interface FontFamilyResolution {
   readonly family: StandardFamily;
   readonly matched: boolean;
@@ -12,4 +13,4 @@ interface ResolvedFont {
 }
 declare function resolveStandardFont(family: string, bold: boolean, italic: boolean): ResolvedFont;
 //#endregion
-export { FontFamilyResolution, ResolvedFont, resolveFontFamily, resolveStandardFont };
+export { FontFamilyResolution, ResolvedFont, normalizeFamilyName, resolveFontFamily, resolveStandardFont };

package/dist/fonts.d.ts

@@ -1,6 +1,7 @@
 import { r as StandardFontName } from "./afm-widths-DyDq56Ph.js";
 //#region src/fonts.d.ts
 type StandardFamily = 'helvetica' | 'times' | 'courier';
+declare function normalizeFamilyName(raw: string): string;
 interface FontFamilyResolution {
   readonly family: StandardFamily;
   readonly matched: boolean;
@@ -12,4 +13,4 @@ interface ResolvedFont {
 }
 declare function resolveStandardFont(family: string, bold: boolean, italic: boolean): ResolvedFont;
 //#endregion
-export { FontFamilyResolution, ResolvedFont, resolveFontFamily, resolveStandardFont };
+export { FontFamilyResolution, ResolvedFont, normalizeFamilyName, resolveFontFamily, resolveStandardFont };

package/dist/fonts.js

@@ -119,4 +119,4 @@ function resolveStandardFont(family, bold, italic) {
 	};
 }
 //#endregion
-export { resolveFontFamily, resolveStandardFont };
+export { normalizeFamilyName, resolveFontFamily, resolveStandardFont };