pdf-codec 1.5.0 → 1.7.0

package/dist/filters.d.cts

@@ -1,14 +1,15 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { PdfDict } from "./objects.cjs";
+import { PdfDict, PdfObject } from "./objects.cjs";
 //#region src/filters.d.ts
 interface DecodedStream {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly remainingFilter?: string;
 }
-declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink): DecodedStream;
+type PdfIndirectResolver = (obj: PdfObject | undefined) => PdfObject | undefined;
+declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink, resolve?: PdfIndirectResolver): DecodedStream;
 declare function lzwDecode(data: Uint8Array<ArrayBuffer>, earlyChange: boolean, sink: PdfDiagnosticSink): Uint8Array<ArrayBuffer>;
 declare function ascii85Decode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 declare function asciiHexDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 declare function runLengthDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 //#endregion
-export { DecodedStream, ascii85Decode, asciiHexDecode, decodeStream, lzwDecode, runLengthDecode };
+export { DecodedStream, PdfIndirectResolver, ascii85Decode, asciiHexDecode, decodeStream, lzwDecode, runLengthDecode };

package/dist/filters.d.ts

@@ -1,14 +1,15 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { PdfDict } from "./objects.js";
+import { PdfDict, PdfObject } from "./objects.js";
 //#region src/filters.d.ts
 interface DecodedStream {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly remainingFilter?: string;
 }
-declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink): DecodedStream;
+type PdfIndirectResolver = (obj: PdfObject | undefined) => PdfObject | undefined;
+declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink, resolve?: PdfIndirectResolver): DecodedStream;
 declare function lzwDecode(data: Uint8Array<ArrayBuffer>, earlyChange: boolean, sink: PdfDiagnosticSink): Uint8Array<ArrayBuffer>;
 declare function ascii85Decode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 declare function asciiHexDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 declare function runLengthDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 //#endregion
-export { DecodedStream, ascii85Decode, asciiHexDecode, decodeStream, lzwDecode, runLengthDecode };
+export { DecodedStream, PdfIndirectResolver, ascii85Decode, asciiHexDecode, decodeStream, lzwDecode, runLengthDecode };

package/dist/filters.js

@@ -2,9 +2,10 @@ import { isAsciiWhitespace } from "./bytes/reader.js";
 import { asArray, asBool, asDict, asName, asNumber, dictGet } from "./objects.js";
 import { inflateTolerant } from "./bytes/flate.js";
 import { decodeCcittFax } from "./image/ccitt.js";
+import { decodeJbig2Embedded } from "./image/jbig2.js";
 import { applyPredictor, readPredictorParams } from "./predictors.js";
 //#region src/filters.ts
-function decodeStream(raw, dict, sink) {
+function decodeStream(raw, dict, sink, resolve) {
 	const filters = filterNames(dict);
 	const parms = decodeParmsList(dict, filters.length);
 	let bytes = raw;
@@ -19,10 +20,21 @@ function decodeStream(raw, dict, sink) {
 		else if (filter === "ASCIIHexDecode" || filter === "AHx") bytes = asciiHexDecode(bytes);
 		else if (filter === "RunLengthDecode" || filter === "RL") bytes = runLengthDecode(bytes);
 		else if (filter === "CCITTFaxDecode" || filter === "CCF") bytes = ccittFaxDecode(bytes, parm, dict, sink);
-		else if (filter === "DCTDecode" || filter === "DCT") return {
+		else if (filter === "JBIG2Decode") {
+			const decoded = jbig2Decode(bytes, parm, dict, sink, resolve);
+			if (decoded === void 0) return {
+				bytes,
+				remainingFilter: "JBIG2Decode"
+			};
+			bytes = decoded;
+		} else if (filter === "DCTDecode" || filter === "DCT") return {
 			bytes,
 			remainingFilter: "DCTDecode"
 		};
+		else if (filter === "JPXDecode") return {
+			bytes,
+			remainingFilter: "JPXDecode"
+		};
 		else {
 			sink({
 				code: "pdf/unsupported-filter",
@@ -56,6 +68,37 @@ function ccittFaxDecode(data, parm, dict, sink) {
 		})
 	}).bytes;
 }
+function jbig2Decode(data, parm, dict, sink, resolve) {
+	const globalsObj = parm !== void 0 ? dictGet(parm, "JBIG2Globals") : void 0;
+	const resolvedGlobals = resolve !== void 0 ? resolve(globalsObj) : globalsObj;
+	let globals;
+	if (resolvedGlobals?.kind === "stream") globals = decodeStream(resolvedGlobals.raw, resolvedGlobals.dict, sink, resolve).bytes;
+	else if (globalsObj !== void 0) sink({
+		code: "pdf/jbig2-degraded",
+		severity: "warning",
+		message: "a JBIG2Decode stream declares /JBIG2Globals but it could not be resolved to a stream; decoding without it, which will fail if the page refers to a shared symbol dictionary"
+	});
+	try {
+		const image = decodeJbig2Embedded(data, {
+			globals,
+			width: asNumber(dictGet(dict, "Width") ?? dictGet(dict, "W")),
+			height: asNumber(dictGet(dict, "Height") ?? dictGet(dict, "H")),
+			onWarning: (message) => sink({
+				code: "pdf/jbig2-degraded",
+				severity: "warning",
+				message
+			})
+		});
+		return Uint8Array.from(image.bytes, (byte) => byte ^ 255);
+	} catch (error) {
+		sink({
+			code: "pdf/jbig2-undecodable",
+			severity: "warning",
+			message: `JBIG2Decode stream could not be decoded (${error instanceof Error ? error.message : String(error)}); leaving its bytes undecoded`
+		});
+		return;
+	}
+}
 function filterNames(dict) {
 	const filterObj = dictGet(dict, "Filter") ?? dictGet(dict, "F");
 	if (filterObj === void 0) return [];

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

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;