pdf-codec 1.5.0 → 1.6.0

package/dist/embedded-font.js

@@ -0,0 +1,138 @@
+import { hasBytes, i16, sfntTableBytes, u16 } from "./sfnt.js";
+import { buildCmapLookup } from "./cmap-table.js";
+import { parseHead, parseMaxp, parseName, parseOs2, parsePost } from "./font-tables.js";
+import { parseGlyf } from "./glyf.js";
+import { parseHmtx } from "./hmtx-table.js";
+//#region src/embedded-font.ts
+const GLYPH_SPACE_UNITS_PER_EM = 1e3;
+const NOTDEF_GLYPH_ID = 0;
+const CAP_HEIGHT_REFERENCE_CODE_POINT = 72;
+const PANOSE_FAMILY_KIND_OFFSET = 0;
+const PANOSE_SERIF_STYLE_OFFSET = 1;
+const PANOSE_FAMILY_KIND_LATIN_TEXT = 2;
+const PANOSE_FIRST_SERIF_STYLE = 2;
+const PANOSE_LAST_SERIF_STYLE = 10;
+const cache = /* @__PURE__ */ new WeakMap();
+function scaleToGlyphSpace(designUnits, unitsPerEm) {
+	return designUnits * GLYPH_SPACE_UNITS_PER_EM / unitsPerEm;
+}
+function resolveCapHeight(font, cmap, declared, ascent) {
+	if (declared !== void 0) return declared;
+	const head = parseHead(font);
+	const maxp = parseMaxp(font);
+	const glyphId = cmap(CAP_HEIGHT_REFERENCE_CODE_POINT);
+	if (head === void 0 || maxp === void 0 || glyphId === void 0) return ascent;
+	return parseGlyf(font, {
+		numGlyphs: maxp.numGlyphs,
+		indexToLocFormat: head.indexToLocFormat
+	})?.glyphHeader(glyphId)?.yMax ?? ascent;
+}
+function isSerifByPanose(panose) {
+	if (panose?.[PANOSE_FAMILY_KIND_OFFSET] !== PANOSE_FAMILY_KIND_LATIN_TEXT) return false;
+	const serifStyle = panose[PANOSE_SERIF_STYLE_OFFSET];
+	return serifStyle !== void 0 && serifStyle >= PANOSE_FIRST_SERIF_STYLE && serifStyle <= PANOSE_LAST_SERIF_STYLE;
+}
+function loadEmbeddedFace(font) {
+	const cached = cache.get(font.bytes);
+	if (cached !== void 0 || cache.has(font.bytes)) return cached;
+	const face = readEmbeddedFace(font);
+	cache.set(font.bytes, face);
+	return face;
+}
+function readEmbeddedFace(font) {
+	const head = parseHead(font);
+	const maxp = parseMaxp(font);
+	const name = parseName(font);
+	const cmap = buildCmapLookup(font);
+	if (head === void 0 || maxp === void 0 || cmap === void 0 || name?.postScriptName === void 0) return;
+	const hhea = parseHhea(font);
+	const hmtxBytes = sfntTableBytes(font, "hmtx");
+	if (hhea === void 0 || hmtxBytes === void 0 || !hasBytes(hmtxBytes, 0, hhea.numberOfHMetrics * LONG_HOR_METRIC_SIZE)) return;
+	const hmtx = parseHmtx(font);
+	const os2 = parseOs2(font);
+	const post = parsePost(font);
+	const { unitsPerEm } = head;
+	const scale = (designUnits) => scaleToGlyphSpace(designUnits, unitsPerEm);
+	const capHeight = resolveCapHeight(font, cmap, os2?.sCapHeight, hhea.ascent);
+	return {
+		font,
+		postScriptName: name.postScriptName,
+		numGlyphs: maxp.numGlyphs,
+		metrics: {
+			unitsPerEm,
+			ascentGlyphSpace: scale(hhea.ascent),
+			descentGlyphSpace: scale(hhea.descent),
+			lineGapGlyphSpace: scale(hhea.lineGap),
+			typoAscentGlyphSpace: os2 === void 0 ? void 0 : scale(os2.sTypoAscender),
+			typoDescentGlyphSpace: os2 === void 0 ? void 0 : scale(os2.sTypoDescender),
+			typoLineGapGlyphSpace: os2 === void 0 ? void 0 : scale(os2.sTypoLineGap),
+			winAscentGlyphSpace: os2 === void 0 ? void 0 : scale(os2.usWinAscent),
+			winDescentGlyphSpace: os2 === void 0 ? void 0 : -scale(os2.usWinDescent),
+			capHeightGlyphSpace: scale(capHeight),
+			xHeightGlyphSpace: os2?.sxHeight === void 0 ? void 0 : scale(os2.sxHeight),
+			bboxGlyphSpace: [
+				scale(head.xMin),
+				scale(head.yMin),
+				scale(head.xMax),
+				scale(head.yMax)
+			],
+			italicAngleDegrees: post?.italicAngle ?? 0,
+			underlinePositionGlyphSpace: scale(post?.underlinePosition ?? 0),
+			underlineThicknessGlyphSpace: scale(post?.underlineThickness ?? 0),
+			serif: isSerifByPanose(os2?.panose)
+		},
+		glyphId: (codePoint) => cmap(codePoint),
+		glyphSpaceWidth: (glyphId) => scale(hmtx.advanceWidth(glyphId))
+	};
+}
+const HHEA_TABLE_SIZE = 36;
+const HHEA_ASCENDER_OFFSET = 4;
+const HHEA_DESCENDER_OFFSET = 6;
+const HHEA_LINE_GAP_OFFSET = 8;
+const HHEA_NUMBER_OF_HMETRICS_OFFSET = 34;
+const LONG_HOR_METRIC_SIZE = 4;
+function parseHhea(font) {
+	const bytes = sfntTableBytes(font, "hhea");
+	if (bytes === void 0 || !hasBytes(bytes, 0, HHEA_TABLE_SIZE)) return;
+	const numberOfHMetrics = u16(bytes, HHEA_NUMBER_OF_HMETRICS_OFFSET);
+	if (numberOfHMetrics === 0) return;
+	return {
+		ascent: i16(bytes, HHEA_ASCENDER_OFFSET),
+		descent: i16(bytes, HHEA_DESCENDER_OFFSET),
+		lineGap: i16(bytes, HHEA_LINE_GAP_OFFSET),
+		numberOfHMetrics
+	};
+}
+function encodeForShowEmbedded(text, face) {
+	const glyphIds = [];
+	const substitutions = [];
+	let width1000 = 0;
+	for (const character of text) {
+		const glyphId = face.glyphId(character.codePointAt(0));
+		if (glyphId === void 0) substitutions.push({ from: character });
+		const shown = glyphId ?? 0;
+		glyphIds.push(shown);
+		width1000 += face.glyphSpaceWidth(shown);
+	}
+	const codes = new Uint8Array(glyphIds.length * 2);
+	glyphIds.forEach((glyphId, index) => {
+		codes[index * 2] = glyphId >> 8 & 255;
+		codes[index * 2 + 1] = glyphId & 255;
+	});
+	return {
+		codes,
+		width1000,
+		substitutions
+	};
+}
+function collectEmbeddedGlyphs(texts, face) {
+	const used = /* @__PURE__ */ new Map();
+	for (const text of texts) for (const character of text) {
+		const codePoint = character.codePointAt(0);
+		const glyphId = face.glyphId(codePoint);
+		if (glyphId !== void 0 && !used.has(glyphId)) used.set(glyphId, codePoint);
+	}
+	return used;
+}
+//#endregion
+export { NOTDEF_GLYPH_ID, collectEmbeddedGlyphs, encodeForShowEmbedded, loadEmbeddedFace };

package/dist/font-registry-Cn7P9lAh.d.ts

@@ -0,0 +1,38 @@
+import { r as StandardFontName } from "./afm-widths-DyDq56Ph.js";
+import { t as EmbeddedFace } from "./embedded-font-CbqkKgBl.js";
+import { LayoutFont } from "document-schema.js";
+//#region src/font-registry.d.ts
+interface ProvidedFont {
+  readonly family: string;
+  readonly bold: boolean;
+  readonly italic: boolean;
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+type ResolvedFace = {
+  readonly kind: 'embedded';
+  readonly face: EmbeddedFace;
+} | {
+  readonly kind: 'standard';
+  readonly standardName: StandardFontName;
+  readonly matched: boolean;
+};
+interface FontSubstitution {
+  readonly requestedFamily: string;
+  readonly requestedBold: boolean;
+  readonly requestedItalic: boolean;
+  readonly reason: 'missing-face' | 'vendored-substitute';
+  readonly resolvedFamily: string;
+}
+interface FontRegistryOptions {
+  readonly sourceFonts?: readonly ProvidedFont[];
+  readonly fonts?: readonly ProvidedFont[];
+  readonly substitutes?: 'vendored' | 'none';
+  readonly onSubstitution?: (substitution: FontSubstitution) => void;
+}
+interface FontRegistry {
+  resolve(font: LayoutFont): ResolvedFace;
+}
+declare function createFontRegistry(options?: FontRegistryOptions): FontRegistry;
+declare function resolveFaceWithRegistry(registry: FontRegistry | undefined, font: LayoutFont): ResolvedFace;
+//#endregion
+export { ResolvedFace as a, ProvidedFont as i, FontRegistryOptions as n, createFontRegistry as o, FontSubstitution as r, resolveFaceWithRegistry as s, FontRegistry as t };

package/dist/font-registry-yby02snZ.d.cts

@@ -0,0 +1,38 @@
+import { r as StandardFontName } from "./afm-widths-DyDq56Ph.cjs";
+import { t as EmbeddedFace } from "./embedded-font-CLedn-mT.cjs";
+import { LayoutFont } from "document-schema.js";
+//#region src/font-registry.d.ts
+interface ProvidedFont {
+  readonly family: string;
+  readonly bold: boolean;
+  readonly italic: boolean;
+  readonly bytes: Uint8Array<ArrayBuffer>;
+}
+type ResolvedFace = {
+  readonly kind: 'embedded';
+  readonly face: EmbeddedFace;
+} | {
+  readonly kind: 'standard';
+  readonly standardName: StandardFontName;
+  readonly matched: boolean;
+};
+interface FontSubstitution {
+  readonly requestedFamily: string;
+  readonly requestedBold: boolean;
+  readonly requestedItalic: boolean;
+  readonly reason: 'missing-face' | 'vendored-substitute';
+  readonly resolvedFamily: string;
+}
+interface FontRegistryOptions {
+  readonly sourceFonts?: readonly ProvidedFont[];
+  readonly fonts?: readonly ProvidedFont[];
+  readonly substitutes?: 'vendored' | 'none';
+  readonly onSubstitution?: (substitution: FontSubstitution) => void;
+}
+interface FontRegistry {
+  resolve(font: LayoutFont): ResolvedFace;
+}
+declare function createFontRegistry(options?: FontRegistryOptions): FontRegistry;
+declare function resolveFaceWithRegistry(registry: FontRegistry | undefined, font: LayoutFont): ResolvedFace;
+//#endregion
+export { ResolvedFace as a, ProvidedFont as i, FontRegistryOptions as n, createFontRegistry as o, FontSubstitution as r, resolveFaceWithRegistry as s, FontRegistry as t };

package/dist/font-registry.cjs

@@ -0,0 +1,152 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+const require_util_base64 = require("./util/base64.cjs");
+const require_fonts = require("./fonts.cjs");
+const require_embedded_font = require("./embedded-font.cjs");
+const require_assets_caladea_bold = require("./assets/caladea-bold.cjs");
+const require_assets_caladea_bolditalic = require("./assets/caladea-bolditalic.cjs");
+const require_assets_caladea_italic = require("./assets/caladea-italic.cjs");
+const require_assets_caladea_regular = require("./assets/caladea-regular.cjs");
+const require_assets_carlito_bold = require("./assets/carlito-bold.cjs");
+const require_assets_carlito_bolditalic = require("./assets/carlito-bolditalic.cjs");
+const require_assets_carlito_italic = require("./assets/carlito-italic.cjs");
+const require_assets_carlito_regular = require("./assets/carlito-regular.cjs");
+const require_font_substitutes = require("./font-substitutes.cjs");
+let fflate = require("fflate");
+//#region src/font-registry.ts
+function faceCacheKey(family, bold, italic) {
+	return `${require_fonts.normalizeFamilyName(family)}|${bold ? 1 : 0}|${italic ? 1 : 0}`;
+}
+function embedFace(bytes) {
+	const sfnt = require_sfnt.parseSfnt(bytes);
+	if (sfnt === void 0) return;
+	return require_embedded_font.loadEmbeddedFace(sfnt);
+}
+function findExactFace(list, family, bold, italic) {
+	const normalized = require_fonts.normalizeFamilyName(family);
+	return list.find((candidate) => require_fonts.normalizeFamilyName(candidate.family) === normalized && candidate.bold === bold && candidate.italic === italic);
+}
+function findFamilyRegular(list, family) {
+	const normalized = require_fonts.normalizeFamilyName(family);
+	const familyFaces = list.filter((candidate) => require_fonts.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: require_assets_carlito_regular.CARLITO_REGULAR_FONT_DEFLATED_BASE64,
+		bold: require_assets_carlito_bold.CARLITO_BOLD_FONT_DEFLATED_BASE64,
+		italic: require_assets_carlito_italic.CARLITO_ITALIC_FONT_DEFLATED_BASE64,
+		boldItalic: require_assets_carlito_bolditalic.CARLITO_BOLDITALIC_FONT_DEFLATED_BASE64
+	},
+	caladea: {
+		regular: require_assets_caladea_regular.CALADEA_REGULAR_FONT_DEFLATED_BASE64,
+		bold: require_assets_caladea_bold.CALADEA_BOLD_FONT_DEFLATED_BASE64,
+		italic: require_assets_caladea_italic.CALADEA_ITALIC_FONT_DEFLATED_BASE64,
+		boldItalic: require_assets_caladea_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 = (0, fflate.inflateSync)(require_util_base64.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 = require_font_substitutes.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 = require_fonts.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 = require_fonts.resolveStandardFont(font.family, font.weight === "bold", font.style === "italic");
+	return {
+		kind: "standard",
+		standardName: standard.standardName,
+		matched: standard.matched
+	};
+}
+//#endregion
+exports.createFontRegistry = createFontRegistry;
+exports.resolveFaceWithRegistry = resolveFaceWithRegistry;

package/dist/font-registry.d.cts

@@ -0,0 +1,2 @@
+import { a as ResolvedFace, i as ProvidedFont, n as FontRegistryOptions, o as createFontRegistry, r as FontSubstitution, s as resolveFaceWithRegistry, t as FontRegistry } from "./font-registry-yby02snZ.cjs";
+export { FontRegistry, FontRegistryOptions, FontSubstitution, ProvidedFont, ResolvedFace, createFontRegistry, resolveFaceWithRegistry };

package/dist/font-registry.d.ts

@@ -0,0 +1,2 @@
+import { a as ResolvedFace, i as ProvidedFont, n as FontRegistryOptions, o as createFontRegistry, r as FontSubstitution, s as resolveFaceWithRegistry, t as FontRegistry } from "./font-registry-Cn7P9lAh.js";
+export { FontRegistry, FontRegistryOptions, FontSubstitution, ProvidedFont, ResolvedFace, createFontRegistry, resolveFaceWithRegistry };

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 };