pdf-codec 1.5.0 → 1.7.0

package/dist/measure.d.ts

@@ -1,3 +1,4 @@
+import { t as FontRegistry } from "./font-registry-Cn7P9lAh.js";
 import { LayoutFont } from "document-schema.js";
 //#region src/measure.d.ts
 interface UnderlineMetrics {
@@ -12,9 +13,15 @@ interface TextMeasurer {
   underlineAtSize(font: LayoutFont, sizePt: number): UnderlineMetrics;
   horizontalScaleFor(font: LayoutFont): number;
 }
+type VerticalMetricPolicy = 'hhea' | 'os2Typo' | 'os2Win';
+declare const DEFAULT_VERTICAL_METRIC_POLICY: VerticalMetricPolicy;
 interface StandardFontMeasurerOptions {
   readonly widthCorrectionByFamily?: Readonly<Record<string, number>>;
 }
+interface FontMeasurerOptions extends StandardFontMeasurerOptions {
+  readonly verticalMetrics?: VerticalMetricPolicy;
+}
+declare function createFontMeasurer(registry?: FontRegistry, options?: FontMeasurerOptions): TextMeasurer;
 declare function createStandardFontMeasurer(options?: StandardFontMeasurerOptions): TextMeasurer;
 //#endregion
-export { StandardFontMeasurerOptions, TextMeasurer, UnderlineMetrics, createStandardFontMeasurer };
+export { DEFAULT_VERTICAL_METRIC_POLICY, FontMeasurerOptions, StandardFontMeasurerOptions, TextMeasurer, UnderlineMetrics, VerticalMetricPolicy, createFontMeasurer, createStandardFontMeasurer };

package/dist/measure.js

@@ -1,6 +1,8 @@
 import { o as encodeForShow, t as STANDARD_METRICS } from "./afm-widths-Dxucrg7D.js";
-import { resolveStandardFont } from "./fonts.js";
+import { encodeForShowEmbedded } from "./embedded-font.js";
+import { resolveFaceWithRegistry } from "./font-registry.js";
 //#region src/measure.ts
+const GLYPH_SPACE_UNITS_PER_EM = 1e3;
 const DEFAULT_WIDTH_CORRECTIONS = {
 	calibri: .92,
 	aptos: .93,
@@ -12,42 +14,89 @@ const DEFAULT_WIDTH_CORRECTIONS = {
 function normalizeFamilyKey(family) {
 	return family.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function createStandardFontMeasurer(options = {}) {
+const EMBEDDED_HORIZONTAL_SCALE = 1;
+const DEFAULT_VERTICAL_METRIC_POLICY = "hhea";
+function verticalMetricsFor(face, policy) {
+	const m = face.metrics;
+	const hhea = {
+		ascentGlyphSpace: m.ascentGlyphSpace,
+		descentGlyphSpace: m.descentGlyphSpace,
+		lineGapGlyphSpace: m.lineGapGlyphSpace
+	};
+	if (policy === "os2Typo") {
+		if (m.typoAscentGlyphSpace === void 0 || m.typoDescentGlyphSpace === void 0 || m.typoLineGapGlyphSpace === void 0) return hhea;
+		return {
+			ascentGlyphSpace: m.typoAscentGlyphSpace,
+			descentGlyphSpace: m.typoDescentGlyphSpace,
+			lineGapGlyphSpace: m.typoLineGapGlyphSpace
+		};
+	}
+	if (policy === "os2Win") {
+		if (m.winAscentGlyphSpace === void 0 || m.winDescentGlyphSpace === void 0) return hhea;
+		return {
+			ascentGlyphSpace: m.winAscentGlyphSpace,
+			descentGlyphSpace: m.winDescentGlyphSpace,
+			lineGapGlyphSpace: 0
+		};
+	}
+	return hhea;
+}
+function createFontMeasurer(registry, options = {}) {
 	const corrections = {
 		...DEFAULT_WIDTH_CORRECTIONS,
 		...options.widthCorrectionByFamily
 	};
-	function correctionFor(family) {
+	const verticalPolicy = options.verticalMetrics ?? "hhea";
+	function standardWidthCorrectionFor(family) {
 		return corrections[normalizeFamilyKey(family)] ?? 1;
 	}
-	function standardNameFor(font) {
-		return resolveStandardFont(font.family, font.weight === "bold", font.style === "italic").standardName;
+	function resolve(font) {
+		return resolveFaceWithRegistry(registry, font);
 	}
 	return {
 		widthOfTextAtSize(text, font, sizePt) {
-			const { width1000 } = encodeForShow(text, standardNameFor(font));
-			return width1000 / 1e3 * sizePt * correctionFor(font.family);
+			const face = resolve(font);
+			if (face.kind === "embedded") return encodeForShowEmbedded(text, face.face).width1000 / GLYPH_SPACE_UNITS_PER_EM * sizePt;
+			const { width1000 } = encodeForShow(text, face.standardName);
+			return width1000 / GLYPH_SPACE_UNITS_PER_EM * sizePt * standardWidthCorrectionFor(font.family);
 		},
 		lineHeightAtSize(font, sizePt) {
-			return STANDARD_METRICS[standardNameFor(font)].lineHeightEm * sizePt;
+			const face = resolve(font);
+			if (face.kind === "embedded") {
+				const vertical = verticalMetricsFor(face.face, verticalPolicy);
+				return (vertical.ascentGlyphSpace - vertical.descentGlyphSpace + vertical.lineGapGlyphSpace) / GLYPH_SPACE_UNITS_PER_EM * sizePt;
+			}
+			return STANDARD_METRICS[face.standardName].lineHeightEm * sizePt;
 		},
 		ascenderAtSize(font, sizePt) {
-			return STANDARD_METRICS[standardNameFor(font)].ascender / 1e3 * sizePt;
+			const face = resolve(font);
+			if (face.kind === "embedded") return verticalMetricsFor(face.face, verticalPolicy).ascentGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * sizePt;
+			return STANDARD_METRICS[face.standardName].ascender / GLYPH_SPACE_UNITS_PER_EM * sizePt;
 		},
 		descenderAtSize(font, sizePt) {
-			return STANDARD_METRICS[standardNameFor(font)].descender / 1e3 * sizePt;
+			const face = resolve(font);
+			if (face.kind === "embedded") return verticalMetricsFor(face.face, verticalPolicy).descentGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * sizePt;
+			return STANDARD_METRICS[face.standardName].descender / GLYPH_SPACE_UNITS_PER_EM * sizePt;
 		},
 		underlineAtSize(font, sizePt) {
-			const metrics = STANDARD_METRICS[standardNameFor(font)];
+			const face = resolve(font);
+			if (face.kind === "embedded") return {
+				offsetPt: face.face.metrics.underlinePositionGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * sizePt,
+				thicknessPt: face.face.metrics.underlineThicknessGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * sizePt
+			};
+			const metrics = STANDARD_METRICS[face.standardName];
 			return {
-				offsetPt: metrics.underlinePosition / 1e3 * sizePt,
-				thicknessPt: metrics.underlineThickness / 1e3 * sizePt
+				offsetPt: metrics.underlinePosition / GLYPH_SPACE_UNITS_PER_EM * sizePt,
+				thicknessPt: metrics.underlineThickness / GLYPH_SPACE_UNITS_PER_EM * sizePt
 			};
 		},
 		horizontalScaleFor(font) {
-			return correctionFor(font.family);
+			return resolve(font).kind === "embedded" ? EMBEDDED_HORIZONTAL_SCALE : standardWidthCorrectionFor(font.family);
 		}
 	};
 }
+function createStandardFontMeasurer(options = {}) {
+	return createFontMeasurer(void 0, options);
+}
 //#endregion
-export { createStandardFontMeasurer };
+export { DEFAULT_VERTICAL_METRIC_POLICY, createFontMeasurer, createStandardFontMeasurer };

package/dist/sfnt-V08bb5ut.d.cts

@@ -0,0 +1,21 @@
+//#region src/sfnt.d.ts
+interface SfntTable {
+  readonly offset: number;
+  readonly length: number;
+}
+interface SfntFont {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly tables: ReadonlyMap<string, SfntTable>;
+}
+declare function hasBytes(bytes: Uint8Array<ArrayBuffer>, offset: number, length: number): boolean;
+declare function parseSfnt(bytes: Uint8Array<ArrayBuffer>): SfntFont | undefined;
+declare function sfntTableBytes(font: SfntFont, tag: string): Uint8Array<ArrayBuffer> | undefined;
+declare function u8(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function u16(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function i16(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function u24(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function u32(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function i32(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function f2dot14(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+//#endregion
+export { i16 as a, sfntTableBytes as c, u32 as d, u8 as f, hasBytes as i, u16 as l, SfntTable as n, i32 as o, f2dot14 as r, parseSfnt as s, SfntFont as t, u24 as u };

package/dist/sfnt-V08bb5ut.d.ts

@@ -0,0 +1,21 @@
+//#region src/sfnt.d.ts
+interface SfntTable {
+  readonly offset: number;
+  readonly length: number;
+}
+interface SfntFont {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly tables: ReadonlyMap<string, SfntTable>;
+}
+declare function hasBytes(bytes: Uint8Array<ArrayBuffer>, offset: number, length: number): boolean;
+declare function parseSfnt(bytes: Uint8Array<ArrayBuffer>): SfntFont | undefined;
+declare function sfntTableBytes(font: SfntFont, tag: string): Uint8Array<ArrayBuffer> | undefined;
+declare function u8(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function u16(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function i16(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function u24(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function u32(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function i32(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+declare function f2dot14(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
+//#endregion
+export { i16 as a, sfntTableBytes as c, u32 as d, u8 as f, hasBytes as i, u16 as l, SfntTable as n, i32 as o, f2dot14 as r, parseSfnt as s, SfntFont as t, u24 as u };

package/dist/sfnt-subset.cjs

@@ -0,0 +1,250 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+const require_cmap_table = require("./cmap-table.cjs");
+const require_font_tables = require("./font-tables.cjs");
+const require_glyf = require("./glyf.cjs");
+//#region src/sfnt-subset.ts
+const HEAD_TABLE_SIZE = 54;
+const HEAD_CHECKSUM_ADJUSTMENT_OFFSET = 8;
+const HEAD_INDEX_TO_LOC_FORMAT_OFFSET = 50;
+const INDEX_TO_LOC_FORMAT_LONG = 1;
+const HHEA_TABLE_SIZE = 36;
+const HHEA_NUMBER_OF_HMETRICS_OFFSET = 34;
+const MAXP_MIN_SIZE = 6;
+const MAXP_NUM_GLYPHS_OFFSET = 4;
+const POST_STUB_SIZE = 32;
+const POST_VERSION_3_0 = 196608;
+const POST_METRICS_OFFSET = 4;
+const POST_METRICS_SIZE = 12;
+const LONG_HOR_METRIC_SIZE = 4;
+const LEFT_SIDE_BEARING_SIZE = 2;
+const LOCA_LONG_ENTRY_SIZE = 4;
+const TABLE_DIRECTORY_HEADER_SIZE = 12;
+const TABLE_RECORD_SIZE = 16;
+const SFNT_VERSION_TRUETYPE = 65536;
+const CHECKSUM_ADJUSTMENT_MAGIC = 2981146554;
+const GLYPH_ALIGNMENT = 4;
+const COPIED_TAGS = [
+	"cvt ",
+	"fpgm",
+	"prep"
+];
+function alignUp(value) {
+	return Math.ceil(value / GLYPH_ALIGNMENT) * GLYPH_ALIGNMENT;
+}
+function writeU16(bytes, offset, value) {
+	bytes[offset] = value >>> 8 & 255;
+	bytes[offset + 1] = value & 255;
+}
+function writeU32(bytes, offset, value) {
+	bytes[offset] = value >>> 24 & 255;
+	bytes[offset + 1] = value >>> 16 & 255;
+	bytes[offset + 2] = value >>> 8 & 255;
+	bytes[offset + 3] = value & 255;
+}
+function checksum(bytes, offset, length) {
+	let sum = 0;
+	for (let i = 0; i < length; i += GLYPH_ALIGNMENT) sum = sum + require_sfnt.u32(bytes, offset + i) >>> 0;
+	return sum;
+}
+function readHorizontalMetrics(source, glyphId) {
+	if (glyphId < source.numberOfHMetrics) {
+		const offset = glyphId * LONG_HOR_METRIC_SIZE;
+		if (!require_sfnt.hasBytes(source.bytes, offset, LONG_HOR_METRIC_SIZE)) return;
+		return {
+			advanceWidth: require_sfnt.u16(source.bytes, offset),
+			leftSideBearing: require_sfnt.u16(source.bytes, offset + 2)
+		};
+	}
+	const lastAdvanceOffset = (source.numberOfHMetrics - 1) * LONG_HOR_METRIC_SIZE;
+	const bearingOffset = source.numberOfHMetrics * LONG_HOR_METRIC_SIZE + (glyphId - source.numberOfHMetrics) * LEFT_SIDE_BEARING_SIZE;
+	if (!require_sfnt.hasBytes(source.bytes, lastAdvanceOffset, LONG_HOR_METRIC_SIZE) || !require_sfnt.hasBytes(source.bytes, bearingOffset, LEFT_SIDE_BEARING_SIZE)) return;
+	return {
+		advanceWidth: require_sfnt.u16(source.bytes, lastAdvanceOffset),
+		leftSideBearing: require_sfnt.u16(source.bytes, bearingOffset)
+	};
+}
+function buildPostStub(font) {
+	const post = new Uint8Array(POST_STUB_SIZE);
+	writeU32(post, 0, POST_VERSION_3_0);
+	const sourcePost = require_sfnt.sfntTableBytes(font, "post");
+	if (sourcePost !== void 0 && require_sfnt.hasBytes(sourcePost, POST_METRICS_OFFSET, POST_METRICS_SIZE)) post.set(sourcePost.subarray(POST_METRICS_OFFSET, 16), POST_METRICS_OFFSET);
+	return post;
+}
+function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
+	const used = /* @__PURE__ */ new Set([0]);
+	const unmapped = /* @__PURE__ */ new Set();
+	const pending = [0];
+	for (const codePoint of codePoints) {
+		const glyphId = cmap(codePoint);
+		if (glyphId === void 0) {
+			unmapped.add(codePoint);
+			continue;
+		}
+		if (glyphId >= numGlyphs) return;
+		if (!used.has(glyphId)) {
+			used.add(glyphId);
+			pending.push(glyphId);
+		}
+	}
+	while (pending.length > 0) {
+		const glyphId = pending.pop();
+		if (glyf.glyphBytes(glyphId) === void 0) return;
+		const header = glyf.glyphHeader(glyphId);
+		if (header === void 0 || header.numberOfContours >= 0) continue;
+		const components = glyf.compositeComponents(glyphId);
+		if (components === void 0) return;
+		for (const component of components) {
+			if (component.glyphIndex >= numGlyphs) return;
+			if (!used.has(component.glyphIndex)) {
+				used.add(component.glyphIndex);
+				pending.push(component.glyphIndex);
+			}
+		}
+	}
+	return {
+		used,
+		unmapped: [...unmapped].sort((a, b) => a - b)
+	};
+}
+function subsetSfnt(font, codePoints) {
+	const head = require_font_tables.parseHead(font);
+	const maxp = require_font_tables.parseMaxp(font);
+	const sourceHead = require_sfnt.sfntTableBytes(font, "head");
+	const sourceHhea = require_sfnt.sfntTableBytes(font, "hhea");
+	const sourceMaxp = require_sfnt.sfntTableBytes(font, "maxp");
+	const sourceHmtx = require_sfnt.sfntTableBytes(font, "hmtx");
+	if (head === void 0 || maxp === void 0 || sourceHead === void 0 || sourceHhea === void 0 || sourceMaxp === void 0 || sourceHmtx === void 0) return;
+	if (!require_sfnt.hasBytes(sourceHead, 0, HEAD_TABLE_SIZE) || !require_sfnt.hasBytes(sourceHhea, 0, HHEA_TABLE_SIZE) || !require_sfnt.hasBytes(sourceMaxp, 0, MAXP_MIN_SIZE)) return;
+	const numberOfHMetrics = require_sfnt.u16(sourceHhea, HHEA_NUMBER_OF_HMETRICS_OFFSET);
+	if (numberOfHMetrics === 0) return;
+	const glyf = require_glyf.parseGlyf(font, {
+		numGlyphs: maxp.numGlyphs,
+		indexToLocFormat: head.indexToLocFormat
+	});
+	const cmap = require_cmap_table.buildCmapLookup(font);
+	if (glyf === void 0 || cmap === void 0) return;
+	const collected = collectGlyphIds(glyf, cmap, maxp.numGlyphs, codePoints);
+	if (collected === void 0) return;
+	const glyphIds = [...collected.used].sort((a, b) => a - b);
+	const numGlyphs = glyphIds[glyphIds.length - 1] + 1;
+	const outlines = /* @__PURE__ */ new Map();
+	let glyfLength = 0;
+	for (const glyphId of glyphIds) {
+		const bytes = glyf.glyphBytes(glyphId);
+		if (bytes === void 0) return;
+		outlines.set(glyphId, bytes);
+		glyfLength += alignUp(bytes.length);
+	}
+	const glyfData = new Uint8Array(glyfLength);
+	const locaData = new Uint8Array((numGlyphs + 1) * LOCA_LONG_ENTRY_SIZE);
+	let glyfOffset = 0;
+	for (let glyphId = 0; glyphId < numGlyphs; glyphId++) {
+		writeU32(locaData, glyphId * LOCA_LONG_ENTRY_SIZE, glyfOffset);
+		const bytes = outlines.get(glyphId);
+		if (bytes === void 0) continue;
+		glyfData.set(bytes, glyfOffset);
+		glyfOffset += alignUp(bytes.length);
+	}
+	writeU32(locaData, numGlyphs * LOCA_LONG_ENTRY_SIZE, glyfOffset);
+	const hmtxData = new Uint8Array(numGlyphs * LONG_HOR_METRIC_SIZE);
+	for (let glyphId = 0; glyphId < numGlyphs; glyphId++) {
+		const metrics = readHorizontalMetrics({
+			bytes: sourceHmtx,
+			numberOfHMetrics
+		}, glyphId);
+		if (metrics === void 0) return;
+		writeU16(hmtxData, glyphId * LONG_HOR_METRIC_SIZE, metrics.advanceWidth);
+		writeU16(hmtxData, glyphId * LONG_HOR_METRIC_SIZE + 2, metrics.leftSideBearing);
+	}
+	const headData = new Uint8Array(HEAD_TABLE_SIZE);
+	headData.set(sourceHead.subarray(0, HEAD_TABLE_SIZE));
+	writeU32(headData, HEAD_CHECKSUM_ADJUSTMENT_OFFSET, 0);
+	writeU16(headData, HEAD_INDEX_TO_LOC_FORMAT_OFFSET, INDEX_TO_LOC_FORMAT_LONG);
+	const hheaData = new Uint8Array(HHEA_TABLE_SIZE);
+	hheaData.set(sourceHhea.subarray(0, HHEA_TABLE_SIZE));
+	writeU16(hheaData, HHEA_NUMBER_OF_HMETRICS_OFFSET, numGlyphs);
+	const maxpData = new Uint8Array(sourceMaxp.length);
+	maxpData.set(sourceMaxp);
+	writeU16(maxpData, MAXP_NUM_GLYPHS_OFFSET, numGlyphs);
+	const tables = [
+		{
+			tag: "glyf",
+			data: glyfData
+		},
+		{
+			tag: "head",
+			data: headData
+		},
+		{
+			tag: "hhea",
+			data: hheaData
+		},
+		{
+			tag: "hmtx",
+			data: hmtxData
+		},
+		{
+			tag: "loca",
+			data: locaData
+		},
+		{
+			tag: "maxp",
+			data: maxpData
+		},
+		{
+			tag: "post",
+			data: buildPostStub(font)
+		}
+	];
+	for (const tag of COPIED_TAGS) {
+		const bytes = require_sfnt.sfntTableBytes(font, tag);
+		if (bytes !== void 0) {
+			const copy = new Uint8Array(bytes.length);
+			copy.set(bytes);
+			tables.push({
+				tag,
+				data: copy
+			});
+		}
+	}
+	tables.sort((a, b) => a.tag < b.tag ? -1 : 1);
+	const numTables = tables.length;
+	let entrySelector = 0;
+	while (1 << entrySelector + 1 <= numTables) entrySelector++;
+	const searchRange = (1 << entrySelector) * TABLE_RECORD_SIZE;
+	const rangeShift = numTables * TABLE_RECORD_SIZE - searchRange;
+	const directorySize = TABLE_DIRECTORY_HEADER_SIZE + numTables * TABLE_RECORD_SIZE;
+	const offsets = [];
+	let fileLength = alignUp(directorySize);
+	for (const table of tables) {
+		offsets.push(fileLength);
+		fileLength += alignUp(table.data.length);
+	}
+	const file = new Uint8Array(fileLength);
+	writeU32(file, 0, SFNT_VERSION_TRUETYPE);
+	writeU16(file, 4, numTables);
+	writeU16(file, 6, searchRange);
+	writeU16(file, 8, entrySelector);
+	writeU16(file, 10, rangeShift);
+	for (let i = 0; i < numTables; i++) {
+		const table = tables[i];
+		const tableOffset = offsets[i];
+		file.set(table.data, tableOffset);
+		const recordOffset = TABLE_DIRECTORY_HEADER_SIZE + i * TABLE_RECORD_SIZE;
+		for (let c = 0; c < table.tag.length; c++) file[recordOffset + c] = table.tag.charCodeAt(c);
+		writeU32(file, recordOffset + 4, checksum(file, tableOffset, alignUp(table.data.length)));
+		writeU32(file, recordOffset + 8, tableOffset);
+		writeU32(file, recordOffset + 12, table.data.length);
+	}
+	const headOffsetInFile = offsets[tables.findIndex((table) => table.tag === "head")];
+	writeU32(file, headOffsetInFile + HEAD_CHECKSUM_ADJUSTMENT_OFFSET, CHECKSUM_ADJUSTMENT_MAGIC - checksum(file, 0, fileLength) >>> 0);
+	return {
+		bytes: file,
+		numGlyphs,
+		glyphIds,
+		unmappedCodePoints: collected.unmapped
+	};
+}
+//#endregion
+exports.subsetSfnt = subsetSfnt;

package/dist/sfnt-subset.d.cts

@@ -0,0 +1,11 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+//#region src/sfnt-subset.d.ts
+interface SfntSubsetResult {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly numGlyphs: number;
+  readonly glyphIds: readonly number[];
+  readonly unmappedCodePoints: readonly number[];
+}
+declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>): SfntSubsetResult | undefined;
+//#endregion
+export { SfntSubsetResult, subsetSfnt };

package/dist/sfnt-subset.d.ts

@@ -0,0 +1,11 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+//#region src/sfnt-subset.d.ts
+interface SfntSubsetResult {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly numGlyphs: number;
+  readonly glyphIds: readonly number[];
+  readonly unmappedCodePoints: readonly number[];
+}
+declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>): SfntSubsetResult | undefined;
+//#endregion
+export { SfntSubsetResult, subsetSfnt };