pdf-codec 1.4.2 → 1.6.0

package/dist/measure.d.cts

@@ -1,3 +1,4 @@
+import { t as FontRegistry } from "./font-registry-yby02snZ.cjs";
 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.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/objects.cjs

@@ -70,6 +70,9 @@ function asNumber(obj) {
 function asName(obj) {
 	return obj?.kind === "name" ? obj.name : void 0;
 }
+function asBool(obj) {
+	return obj?.kind === "bool" ? obj.value : void 0;
+}
 function asArray(obj) {
 	return obj?.kind === "array" ? obj.items : void 0;
 }
@@ -83,6 +86,7 @@ function dictGet(dict, key) {
 }
 //#endregion
 exports.asArray = asArray;
+exports.asBool = asBool;
 exports.asDict = asDict;
 exports.asName = asName;
 exports.asNumber = asNumber;

package/dist/objects.d.cts

@@ -51,8 +51,9 @@ declare function pdfRef(num: number, gen: number): PdfObject;
 declare function isName(obj: PdfObject | undefined, name: string): boolean;
 declare function asNumber(obj: PdfObject | undefined): number | undefined;
 declare function asName(obj: PdfObject | undefined): string | undefined;
+declare function asBool(obj: PdfObject | undefined): boolean | undefined;
 declare function asArray(obj: PdfObject | undefined): PdfObject[] | undefined;
 declare function asDict(obj: PdfObject | undefined): PdfDict | undefined;
 declare function dictGet(dict: PdfDict, key: string): PdfObject | undefined;
 //#endregion
-export { PdfArray, PdfDict, PdfObject, PdfStream, asArray, asDict, asName, asNumber, dictGet, isName, pdfArray, pdfBool, pdfDict, pdfHexString, pdfLiteralString, pdfName, pdfNull, pdfNum, pdfRef, pdfStream };
+export { PdfArray, PdfDict, PdfObject, PdfStream, asArray, asBool, asDict, asName, asNumber, dictGet, isName, pdfArray, pdfBool, pdfDict, pdfHexString, pdfLiteralString, pdfName, pdfNull, pdfNum, pdfRef, pdfStream };

package/dist/objects.d.ts

@@ -51,8 +51,9 @@ declare function pdfRef(num: number, gen: number): PdfObject;
 declare function isName(obj: PdfObject | undefined, name: string): boolean;
 declare function asNumber(obj: PdfObject | undefined): number | undefined;
 declare function asName(obj: PdfObject | undefined): string | undefined;
+declare function asBool(obj: PdfObject | undefined): boolean | undefined;
 declare function asArray(obj: PdfObject | undefined): PdfObject[] | undefined;
 declare function asDict(obj: PdfObject | undefined): PdfDict | undefined;
 declare function dictGet(dict: PdfDict, key: string): PdfObject | undefined;
 //#endregion
-export { PdfArray, PdfDict, PdfObject, PdfStream, asArray, asDict, asName, asNumber, dictGet, isName, pdfArray, pdfBool, pdfDict, pdfHexString, pdfLiteralString, pdfName, pdfNull, pdfNum, pdfRef, pdfStream };
+export { PdfArray, PdfDict, PdfObject, PdfStream, asArray, asBool, asDict, asName, asNumber, dictGet, isName, pdfArray, pdfBool, pdfDict, pdfHexString, pdfLiteralString, pdfName, pdfNull, pdfNum, pdfRef, pdfStream };

package/dist/objects.js

@@ -69,6 +69,9 @@ function asNumber(obj) {
 function asName(obj) {
 	return obj?.kind === "name" ? obj.name : void 0;
 }
+function asBool(obj) {
+	return obj?.kind === "bool" ? obj.value : void 0;
+}
 function asArray(obj) {
 	return obj?.kind === "array" ? obj.items : void 0;
 }
@@ -81,4 +84,4 @@ function dictGet(dict, key) {
 	return dict.entries.get(key);
 }
 //#endregion
-export { asArray, asDict, asName, asNumber, dictGet, isName, pdfArray, pdfBool, pdfDict, pdfHexString, pdfLiteralString, pdfName, pdfNull, pdfNum, pdfRef, pdfStream };
+export { asArray, asBool, asDict, asName, asNumber, dictGet, isName, pdfArray, pdfBool, pdfDict, pdfHexString, pdfLiteralString, pdfName, pdfNull, pdfNum, pdfRef, pdfStream };

package/dist/read.cjs

@@ -169,6 +169,8 @@ function readPage(page, resolver, fontResolver, images, imageIdCache, sink) {
 function convertExtractedItem(item, pageMatrix, fontResolver, images, imageIdCache, resolver, sink) {
 	if (item.kind === "text") return convertText(item, pageMatrix, fontResolver);
 	if (item.kind === "rect") return convertRect(item, pageMatrix);
+	if (item.kind === "ellipse") return convertEllipse(item, pageMatrix);
+	if (item.kind === "line") return convertLine(item, pageMatrix);
 	if (item.kind === "path") return convertPath(item, pageMatrix);
 	if (item.kind === "image") return convertImage(item, pageMatrix, images, imageIdCache, resolver, sink);
 	return convertInlineImage(item, pageMatrix, images, resolver, sink);
@@ -199,7 +201,13 @@ function convertText(item, pageMatrix, fontResolver) {
 		rotationDeg: rotationDeg !== 0 ? rotationDeg : void 0
 	};
 }
-function convertRect(item, pageMatrix) {
+function paintFields(paint) {
+	return {
+		...paint.fill !== void 0 ? { fill: paint.fill } : {},
+		...paint.stroke !== void 0 ? { stroke: paint.stroke } : {}
+	};
+}
+function transformBox(item, pageMatrix) {
 	const p1 = require_matrix.applyMatrix(pageMatrix, {
 		x: item.xPt,
 		y: item.yPt
@@ -209,12 +217,43 @@ function convertRect(item, pageMatrix) {
 		y: item.yPt + item.heightPt
 	});
 	return {
-		kind: "rect",
 		xPt: Math.min(p1.x, p2.x),
 		yPt: Math.min(p1.y, p2.y),
 		widthPt: Math.abs(p2.x - p1.x),
-		heightPt: Math.abs(p2.y - p1.y),
-		fill: item.color
+		heightPt: Math.abs(p2.y - p1.y)
+	};
+}
+function convertRect(item, pageMatrix) {
+	return {
+		kind: "rect",
+		...transformBox(item, pageMatrix),
+		...paintFields(item)
+	};
+}
+function convertEllipse(item, pageMatrix) {
+	return {
+		kind: "ellipse",
+		...transformBox(item, pageMatrix),
+		...paintFields(item)
+	};
+}
+function convertLine(item, pageMatrix) {
+	const p1 = require_matrix.applyMatrix(pageMatrix, {
+		x: item.x1Pt,
+		y: item.y1Pt
+	});
+	const p2 = require_matrix.applyMatrix(pageMatrix, {
+		x: item.x2Pt,
+		y: item.y2Pt
+	});
+	return {
+		kind: "line",
+		x1Pt: p1.x,
+		y1Pt: p1.y,
+		x2Pt: p2.x,
+		y2Pt: p2.y,
+		color: item.color,
+		widthPt: item.widthPt
 	};
 }
 function transformSubpath(subpath, pageMatrix) {

package/dist/read.d.cts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { n as Matrix } from "./matrix-B3c2_a2f.cjs";
+import { r as Matrix } from "./matrix-BHzJESll.cjs";
 import { LayoutDocument } from "document-schema.js";
 //#region src/read.d.ts
 interface ReadPdfOptions {

package/dist/read.d.ts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { n as Matrix } from "./matrix-B3c2_a2f.js";
+import { r as Matrix } from "./matrix-BHzJESll.js";
 import { LayoutDocument } from "document-schema.js";
 //#region src/read.d.ts
 interface ReadPdfOptions {

package/dist/read.js

@@ -168,6 +168,8 @@ function readPage(page, resolver, fontResolver, images, imageIdCache, sink) {
 function convertExtractedItem(item, pageMatrix, fontResolver, images, imageIdCache, resolver, sink) {
 	if (item.kind === "text") return convertText(item, pageMatrix, fontResolver);
 	if (item.kind === "rect") return convertRect(item, pageMatrix);
+	if (item.kind === "ellipse") return convertEllipse(item, pageMatrix);
+	if (item.kind === "line") return convertLine(item, pageMatrix);
 	if (item.kind === "path") return convertPath(item, pageMatrix);
 	if (item.kind === "image") return convertImage(item, pageMatrix, images, imageIdCache, resolver, sink);
 	return convertInlineImage(item, pageMatrix, images, resolver, sink);
@@ -198,7 +200,13 @@ function convertText(item, pageMatrix, fontResolver) {
 		rotationDeg: rotationDeg !== 0 ? rotationDeg : void 0
 	};
 }
-function convertRect(item, pageMatrix) {
+function paintFields(paint) {
+	return {
+		...paint.fill !== void 0 ? { fill: paint.fill } : {},
+		...paint.stroke !== void 0 ? { stroke: paint.stroke } : {}
+	};
+}
+function transformBox(item, pageMatrix) {
 	const p1 = applyMatrix(pageMatrix, {
 		x: item.xPt,
 		y: item.yPt
@@ -208,12 +216,43 @@ function convertRect(item, pageMatrix) {
 		y: item.yPt + item.heightPt
 	});
 	return {
-		kind: "rect",
 		xPt: Math.min(p1.x, p2.x),
 		yPt: Math.min(p1.y, p2.y),
 		widthPt: Math.abs(p2.x - p1.x),
-		heightPt: Math.abs(p2.y - p1.y),
-		fill: item.color
+		heightPt: Math.abs(p2.y - p1.y)
+	};
+}
+function convertRect(item, pageMatrix) {
+	return {
+		kind: "rect",
+		...transformBox(item, pageMatrix),
+		...paintFields(item)
+	};
+}
+function convertEllipse(item, pageMatrix) {
+	return {
+		kind: "ellipse",
+		...transformBox(item, pageMatrix),
+		...paintFields(item)
+	};
+}
+function convertLine(item, pageMatrix) {
+	const p1 = applyMatrix(pageMatrix, {
+		x: item.x1Pt,
+		y: item.y1Pt
+	});
+	const p2 = applyMatrix(pageMatrix, {
+		x: item.x2Pt,
+		y: item.y2Pt
+	});
+	return {
+		kind: "line",
+		x1Pt: p1.x,
+		y1Pt: p1.y,
+		x2Pt: p2.x,
+		y2Pt: p2.y,
+		color: item.color,
+		widthPt: item.widthPt
 	};
 }
 function transformSubpath(subpath, pageMatrix) {

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;