pdf-codec 1.5.0 → 1.6.0

package/dist/content-write.js

@@ -2,8 +2,11 @@ import { o as encodeForShow } from "./afm-widths-Dxucrg7D.js";
 import { ByteWriter } from "./bytes/writer.js";
 import { pdfHexString } from "./objects.js";
 import { BEZIER_KAPPA, multiplyMatrices, rotationMatrix, scaleMatrix, translationMatrix } from "./matrix.js";
+import { encodeForShowEmbedded } from "./embedded-font.js";
 import { formatNumber, writeObject } from "./serialize.js";
 //#region src/content-write.ts
+const GLYPH_SPACE_UNITS_PER_EM = 1e3;
+const EMBEDDED_HORIZONTAL_SCALE_PERCENT = 100;
 function writeRgbOperator(writer, color, operator) {
 	writer.writeAscii(`${formatNumber(color.r)} ${formatNumber(color.g)} ${formatNumber(color.b)} ${operator}\n`);
 }
@@ -21,8 +24,7 @@ function anchorMatrix(xPt, yPt, rotationDeg) {
 		yPt
 	];
 }
-function writeUnderline(writer, item, widthPt, measurer) {
-	const underline = measurer.underlineAtSize(item.font, item.sizePt);
+function writeUnderline(writer, item, widthPt, underline) {
 	writer.writeAscii("q\n");
 	writeMatrixOperator(writer, anchorMatrix(item.xPt, item.yPt, item.rotationDeg), "cm");
 	writeRgbOperator(writer, item.color, "rg");
@@ -30,23 +32,39 @@ function writeUnderline(writer, item, widthPt, measurer) {
 	writer.writeAscii("f\n");
 	writer.writeAscii("Q\n");
 }
-function writeText(writer, item, context, substitutions) {
-	const font = context.resolveFont(item.font);
-	const encoded = encodeForShow(item.text, font.standardName);
-	substitutions.push(...encoded.substitutions);
-	const scalePercent = context.measurer.horizontalScaleFor(item.font) * 100;
+function writeShowTextBlock(writer, item, resourceName, scalePercent, codes) {
 	writer.writeAscii("BT\n");
-	writer.writeAscii(`/${font.resourceName} ${formatNumber(item.sizePt)} Tf\n`);
+	writer.writeAscii(`/${resourceName} ${formatNumber(item.sizePt)} Tf\n`);
 	writer.writeAscii(`${formatNumber(scalePercent)} Tz\n`);
 	writeRgbOperator(writer, item.color, "rg");
 	writeMatrixOperator(writer, anchorMatrix(item.xPt, item.yPt, item.rotationDeg), "Tm");
-	writeObject(writer, pdfHexString(encoded.codes));
+	writeObject(writer, pdfHexString(codes));
 	writer.writeAscii(" Tj\n");
 	writer.writeAscii("ET\n");
-	if (item.underline === true) {
-		const scale = context.measurer.horizontalScaleFor(item.font);
-		writeUnderline(writer, item, item.widthPt ?? encoded.width1000 / 1e3 * item.sizePt * scale, context.measurer);
+}
+function writeStandardText(writer, item, standardName, resourceName, measurer, substitutions) {
+	const encoded = encodeForShow(item.text, standardName);
+	substitutions.push(...encoded.substitutions);
+	const scale = measurer.horizontalScaleFor(item.font);
+	writeShowTextBlock(writer, item, resourceName, scale * 100, encoded.codes);
+	if (item.underline === true) writeUnderline(writer, item, item.widthPt ?? encoded.width1000 / GLYPH_SPACE_UNITS_PER_EM * item.sizePt * scale, measurer.underlineAtSize(item.font, item.sizePt));
+}
+function writeEmbeddedText(writer, item, face, resourceName, missingGlyphs) {
+	const encoded = encodeForShowEmbedded(item.text, face);
+	missingGlyphs.push(...encoded.substitutions);
+	writeShowTextBlock(writer, item, resourceName, EMBEDDED_HORIZONTAL_SCALE_PERCENT, encoded.codes);
+	if (item.underline === true) writeUnderline(writer, item, item.widthPt ?? encoded.width1000 / GLYPH_SPACE_UNITS_PER_EM * item.sizePt, {
+		offsetPt: face.metrics.underlinePositionGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * item.sizePt,
+		thicknessPt: face.metrics.underlineThicknessGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * item.sizePt
+	});
+}
+function writeText(writer, item, context, substitutions, missingGlyphs) {
+	const font = context.resolveFont(item.font);
+	if (font.kind === "embedded") {
+		writeEmbeddedText(writer, item, font.face, font.resourceName, missingGlyphs);
+		return;
 	}
+	writeStandardText(writer, item, font.standardName, font.resourceName, context.measurer, substitutions);
 }
 function paintOperatorFor(fill, stroke, fillRule) {
 	const evenOdd = fillRule === "evenodd";
@@ -121,7 +139,8 @@ function writeImage(writer, item, context) {
 function writeContentStream(items, context) {
 	const writer = new ByteWriter();
 	const substitutions = [];
-	for (const item of items) if (item.kind === "text") writeText(writer, item, context, substitutions);
+	const missingGlyphs = [];
+	for (const item of items) if (item.kind === "text") writeText(writer, item, context, substitutions, missingGlyphs);
 	else if (item.kind === "image") writeImage(writer, item, context);
 	else if (item.kind === "rect") writeRect(writer, item);
 	else if (item.kind === "line") writeLine(writer, item);
@@ -129,7 +148,8 @@ function writeContentStream(items, context) {
 	else if (item.kind === "path") writePath(writer, item);
 	return {
 		bytes: writer.toBytes(),
-		substitutions
+		substitutions,
+		missingGlyphs
 	};
 }
 //#endregion

package/dist/embedded-font-CLedn-mT.d.cts

@@ -0,0 +1,42 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+//#region src/embedded-font.d.ts
+declare const NOTDEF_GLYPH_ID = 0;
+interface EmbeddedFaceMetrics {
+  readonly unitsPerEm: number;
+  readonly ascentGlyphSpace: number;
+  readonly descentGlyphSpace: number;
+  readonly lineGapGlyphSpace: number;
+  readonly typoAscentGlyphSpace: number | undefined;
+  readonly typoDescentGlyphSpace: number | undefined;
+  readonly typoLineGapGlyphSpace: number | undefined;
+  readonly winAscentGlyphSpace: number | undefined;
+  readonly winDescentGlyphSpace: number | undefined;
+  readonly capHeightGlyphSpace: number;
+  readonly xHeightGlyphSpace: number | undefined;
+  readonly bboxGlyphSpace: readonly [number, number, number, number];
+  readonly italicAngleDegrees: number;
+  readonly underlinePositionGlyphSpace: number;
+  readonly underlineThicknessGlyphSpace: number;
+  readonly serif: boolean;
+}
+interface EmbeddedFace {
+  readonly font: SfntFont;
+  readonly postScriptName: string;
+  readonly numGlyphs: number;
+  readonly metrics: EmbeddedFaceMetrics;
+  glyphId(codePoint: number): number | undefined;
+  glyphSpaceWidth(glyphId: number): number;
+}
+declare function loadEmbeddedFace(font: SfntFont): EmbeddedFace | undefined;
+interface EmbeddedFaceSubstitution {
+  readonly from: string;
+}
+interface EmbeddedShow {
+  readonly codes: Uint8Array<ArrayBuffer>;
+  readonly width1000: number;
+  readonly substitutions: readonly EmbeddedFaceSubstitution[];
+}
+declare function encodeForShowEmbedded(text: string, face: EmbeddedFace): EmbeddedShow;
+declare function collectEmbeddedGlyphs(texts: Iterable<string>, face: EmbeddedFace): ReadonlyMap<number, number>;
+//#endregion
+export { NOTDEF_GLYPH_ID as a, loadEmbeddedFace as c, EmbeddedShow as i, EmbeddedFaceMetrics as n, collectEmbeddedGlyphs as o, EmbeddedFaceSubstitution as r, encodeForShowEmbedded as s, EmbeddedFace as t };

package/dist/embedded-font-CbqkKgBl.d.ts

@@ -0,0 +1,42 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+//#region src/embedded-font.d.ts
+declare const NOTDEF_GLYPH_ID = 0;
+interface EmbeddedFaceMetrics {
+  readonly unitsPerEm: number;
+  readonly ascentGlyphSpace: number;
+  readonly descentGlyphSpace: number;
+  readonly lineGapGlyphSpace: number;
+  readonly typoAscentGlyphSpace: number | undefined;
+  readonly typoDescentGlyphSpace: number | undefined;
+  readonly typoLineGapGlyphSpace: number | undefined;
+  readonly winAscentGlyphSpace: number | undefined;
+  readonly winDescentGlyphSpace: number | undefined;
+  readonly capHeightGlyphSpace: number;
+  readonly xHeightGlyphSpace: number | undefined;
+  readonly bboxGlyphSpace: readonly [number, number, number, number];
+  readonly italicAngleDegrees: number;
+  readonly underlinePositionGlyphSpace: number;
+  readonly underlineThicknessGlyphSpace: number;
+  readonly serif: boolean;
+}
+interface EmbeddedFace {
+  readonly font: SfntFont;
+  readonly postScriptName: string;
+  readonly numGlyphs: number;
+  readonly metrics: EmbeddedFaceMetrics;
+  glyphId(codePoint: number): number | undefined;
+  glyphSpaceWidth(glyphId: number): number;
+}
+declare function loadEmbeddedFace(font: SfntFont): EmbeddedFace | undefined;
+interface EmbeddedFaceSubstitution {
+  readonly from: string;
+}
+interface EmbeddedShow {
+  readonly codes: Uint8Array<ArrayBuffer>;
+  readonly width1000: number;
+  readonly substitutions: readonly EmbeddedFaceSubstitution[];
+}
+declare function encodeForShowEmbedded(text: string, face: EmbeddedFace): EmbeddedShow;
+declare function collectEmbeddedGlyphs(texts: Iterable<string>, face: EmbeddedFace): ReadonlyMap<number, number>;
+//#endregion
+export { NOTDEF_GLYPH_ID as a, loadEmbeddedFace as c, EmbeddedShow as i, EmbeddedFaceMetrics as n, collectEmbeddedGlyphs as o, EmbeddedFaceSubstitution as r, encodeForShowEmbedded as s, EmbeddedFace as t };

package/dist/embedded-font-write.cjs

@@ -0,0 +1,92 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_crc32 = require("./bytes/crc32.cjs");
+const require_objects = require("./objects.cjs");
+const require_bytes_flate = require("./bytes/flate.cjs");
+const require_tounicode = require("./tounicode.cjs");
+//#region src/embedded-font-write.ts
+const FLAG_SERIF = 2;
+const FLAG_NONSYMBOLIC = 32;
+const FLAG_ITALIC = 64;
+const NOMINAL_STEM_V = 80;
+const DEFAULT_WIDTH = 1e3;
+const SUBSET_TAG_LENGTH = 6;
+const SUBSET_TAG_ALPHABET_SIZE = 26;
+const SUBSET_TAG_CODE_SPACE = SUBSET_TAG_ALPHABET_SIZE ** SUBSET_TAG_LENGTH;
+const UPPERCASE_A_CHAR_CODE = 65;
+function embeddedSubsetTag(postScriptName, glyphIds) {
+	let value = require_bytes_crc32.crc32(new TextEncoder().encode(`${postScriptName} ${glyphIds.join(",")}`)) % SUBSET_TAG_CODE_SPACE;
+	let tag = "";
+	for (let i = 0; i < SUBSET_TAG_LENGTH; i++) {
+		tag = String.fromCharCode(UPPERCASE_A_CHAR_CODE + value % SUBSET_TAG_ALPHABET_SIZE) + tag;
+		value = Math.floor(value / SUBSET_TAG_ALPHABET_SIZE);
+	}
+	return tag;
+}
+function computeFlags(face) {
+	let flags = FLAG_NONSYMBOLIC;
+	if (face.metrics.serif) flags |= FLAG_SERIF;
+	if (face.metrics.italicAngleDegrees !== 0) flags |= FLAG_ITALIC;
+	return flags;
+}
+function buildWidthsArray(face, glyphIds) {
+	const entries = [];
+	for (const glyphId of glyphIds) entries.push(require_objects.pdfNum(glyphId), require_objects.pdfArray([require_objects.pdfNum(face.glyphSpaceWidth(glyphId))]));
+	return require_objects.pdfArray(entries);
+}
+function buildFontDescriptor(face, baseFont, fontFileRef) {
+	const m = face.metrics;
+	const entries = /* @__PURE__ */ new Map([
+		["Type", require_objects.pdfName("FontDescriptor")],
+		["FontName", require_objects.pdfName(baseFont)],
+		["Flags", require_objects.pdfNum(computeFlags(face))],
+		["FontBBox", require_objects.pdfArray(m.bboxGlyphSpace.map((n) => require_objects.pdfNum(n)))],
+		["ItalicAngle", require_objects.pdfNum(m.italicAngleDegrees)],
+		["Ascent", require_objects.pdfNum(m.ascentGlyphSpace)],
+		["Descent", require_objects.pdfNum(m.descentGlyphSpace)],
+		["CapHeight", require_objects.pdfNum(m.capHeightGlyphSpace)],
+		["StemV", require_objects.pdfNum(NOMINAL_STEM_V)]
+	]);
+	if (m.xHeightGlyphSpace !== void 0) entries.set("XHeight", require_objects.pdfNum(m.xHeightGlyphSpace));
+	entries.set("FontFile2", fontFileRef);
+	return require_objects.pdfDict(entries);
+}
+function buildFontFileStream(subsetBytes, compress) {
+	const entries = /* @__PURE__ */ new Map([["Length1", require_objects.pdfNum(subsetBytes.length)]]);
+	if (compress) entries.set("Filter", require_objects.pdfName("FlateDecode"));
+	return require_objects.pdfStream(require_objects.pdfDict(entries), compress ? require_bytes_flate.deflate(subsetBytes) : subsetBytes);
+}
+function buildEmbeddedFontObjects(face, subset, usedGlyphs, refs, compress) {
+	const baseFont = `${embeddedSubsetTag(face.postScriptName, subset.glyphIds)}+${face.postScriptName}`;
+	const cidFont = require_objects.pdfDict({
+		Type: require_objects.pdfName("Font"),
+		Subtype: require_objects.pdfName("CIDFontType2"),
+		BaseFont: require_objects.pdfName(baseFont),
+		CIDSystemInfo: require_objects.pdfDict({
+			Registry: require_objects.pdfHexString(new TextEncoder().encode("Adobe")),
+			Ordering: require_objects.pdfHexString(new TextEncoder().encode("Identity")),
+			Supplement: require_objects.pdfNum(0)
+		}),
+		FontDescriptor: refs.descriptorRef,
+		DW: require_objects.pdfNum(DEFAULT_WIDTH),
+		W: buildWidthsArray(face, subset.glyphIds),
+		CIDToGIDMap: require_objects.pdfName("Identity")
+	});
+	return {
+		baseFont,
+		type0: require_objects.pdfDict({
+			Type: require_objects.pdfName("Font"),
+			Subtype: require_objects.pdfName("Type0"),
+			BaseFont: require_objects.pdfName(baseFont),
+			Encoding: require_objects.pdfName("Identity-H"),
+			DescendantFonts: require_objects.pdfArray([refs.cidFontRef]),
+			ToUnicode: refs.toUnicodeRef
+		}),
+		cidFont,
+		descriptor: buildFontDescriptor(face, baseFont, refs.fontFileRef),
+		fontFile: buildFontFileStream(subset.bytes, compress),
+		toUnicode: require_tounicode.buildToUnicodeCMap(usedGlyphs)
+	};
+}
+//#endregion
+exports.buildEmbeddedFontObjects = buildEmbeddedFontObjects;
+exports.embeddedSubsetTag = embeddedSubsetTag;

package/dist/embedded-font-write.d.cts

@@ -0,0 +1,22 @@
+import { PdfDict, PdfObject } from "./objects.cjs";
+import { t as EmbeddedFace } from "./embedded-font-CLedn-mT.cjs";
+import { SfntSubsetResult } from "./sfnt-subset.cjs";
+//#region src/embedded-font-write.d.ts
+declare function embeddedSubsetTag(postScriptName: string, glyphIds: readonly number[]): string;
+interface EmbeddedFontObjectRefs {
+  readonly cidFontRef: PdfObject;
+  readonly descriptorRef: PdfObject;
+  readonly fontFileRef: PdfObject;
+  readonly toUnicodeRef: PdfObject;
+}
+interface EmbeddedFontObjects {
+  readonly baseFont: string;
+  readonly type0: PdfDict;
+  readonly cidFont: PdfDict;
+  readonly descriptor: PdfDict;
+  readonly fontFile: PdfObject;
+  readonly toUnicode: PdfObject;
+}
+declare function buildEmbeddedFontObjects(face: EmbeddedFace, subset: SfntSubsetResult, usedGlyphs: ReadonlyMap<number, number>, refs: EmbeddedFontObjectRefs, compress: boolean): EmbeddedFontObjects;
+//#endregion
+export { EmbeddedFontObjectRefs, EmbeddedFontObjects, buildEmbeddedFontObjects, embeddedSubsetTag };

package/dist/embedded-font-write.d.ts

@@ -0,0 +1,22 @@
+import { PdfDict, PdfObject } from "./objects.js";
+import { t as EmbeddedFace } from "./embedded-font-CbqkKgBl.js";
+import { SfntSubsetResult } from "./sfnt-subset.js";
+//#region src/embedded-font-write.d.ts
+declare function embeddedSubsetTag(postScriptName: string, glyphIds: readonly number[]): string;
+interface EmbeddedFontObjectRefs {
+  readonly cidFontRef: PdfObject;
+  readonly descriptorRef: PdfObject;
+  readonly fontFileRef: PdfObject;
+  readonly toUnicodeRef: PdfObject;
+}
+interface EmbeddedFontObjects {
+  readonly baseFont: string;
+  readonly type0: PdfDict;
+  readonly cidFont: PdfDict;
+  readonly descriptor: PdfDict;
+  readonly fontFile: PdfObject;
+  readonly toUnicode: PdfObject;
+}
+declare function buildEmbeddedFontObjects(face: EmbeddedFace, subset: SfntSubsetResult, usedGlyphs: ReadonlyMap<number, number>, refs: EmbeddedFontObjectRefs, compress: boolean): EmbeddedFontObjects;
+//#endregion
+export { EmbeddedFontObjectRefs, EmbeddedFontObjects, buildEmbeddedFontObjects, embeddedSubsetTag };

package/dist/embedded-font-write.js

@@ -0,0 +1,90 @@
+import { crc32 } from "./bytes/crc32.js";
+import { pdfArray, pdfDict, pdfHexString, pdfName, pdfNum, pdfStream } from "./objects.js";
+import { deflate } from "./bytes/flate.js";
+import { buildToUnicodeCMap } from "./tounicode.js";
+//#region src/embedded-font-write.ts
+const FLAG_SERIF = 2;
+const FLAG_NONSYMBOLIC = 32;
+const FLAG_ITALIC = 64;
+const NOMINAL_STEM_V = 80;
+const DEFAULT_WIDTH = 1e3;
+const SUBSET_TAG_LENGTH = 6;
+const SUBSET_TAG_ALPHABET_SIZE = 26;
+const SUBSET_TAG_CODE_SPACE = SUBSET_TAG_ALPHABET_SIZE ** SUBSET_TAG_LENGTH;
+const UPPERCASE_A_CHAR_CODE = 65;
+function embeddedSubsetTag(postScriptName, glyphIds) {
+	let value = crc32(new TextEncoder().encode(`${postScriptName} ${glyphIds.join(",")}`)) % SUBSET_TAG_CODE_SPACE;
+	let tag = "";
+	for (let i = 0; i < SUBSET_TAG_LENGTH; i++) {
+		tag = String.fromCharCode(UPPERCASE_A_CHAR_CODE + value % SUBSET_TAG_ALPHABET_SIZE) + tag;
+		value = Math.floor(value / SUBSET_TAG_ALPHABET_SIZE);
+	}
+	return tag;
+}
+function computeFlags(face) {
+	let flags = FLAG_NONSYMBOLIC;
+	if (face.metrics.serif) flags |= FLAG_SERIF;
+	if (face.metrics.italicAngleDegrees !== 0) flags |= FLAG_ITALIC;
+	return flags;
+}
+function buildWidthsArray(face, glyphIds) {
+	const entries = [];
+	for (const glyphId of glyphIds) entries.push(pdfNum(glyphId), pdfArray([pdfNum(face.glyphSpaceWidth(glyphId))]));
+	return pdfArray(entries);
+}
+function buildFontDescriptor(face, baseFont, fontFileRef) {
+	const m = face.metrics;
+	const entries = /* @__PURE__ */ new Map([
+		["Type", pdfName("FontDescriptor")],
+		["FontName", pdfName(baseFont)],
+		["Flags", pdfNum(computeFlags(face))],
+		["FontBBox", pdfArray(m.bboxGlyphSpace.map((n) => pdfNum(n)))],
+		["ItalicAngle", pdfNum(m.italicAngleDegrees)],
+		["Ascent", pdfNum(m.ascentGlyphSpace)],
+		["Descent", pdfNum(m.descentGlyphSpace)],
+		["CapHeight", pdfNum(m.capHeightGlyphSpace)],
+		["StemV", pdfNum(NOMINAL_STEM_V)]
+	]);
+	if (m.xHeightGlyphSpace !== void 0) entries.set("XHeight", pdfNum(m.xHeightGlyphSpace));
+	entries.set("FontFile2", fontFileRef);
+	return pdfDict(entries);
+}
+function buildFontFileStream(subsetBytes, compress) {
+	const entries = /* @__PURE__ */ new Map([["Length1", pdfNum(subsetBytes.length)]]);
+	if (compress) entries.set("Filter", pdfName("FlateDecode"));
+	return pdfStream(pdfDict(entries), compress ? deflate(subsetBytes) : subsetBytes);
+}
+function buildEmbeddedFontObjects(face, subset, usedGlyphs, refs, compress) {
+	const baseFont = `${embeddedSubsetTag(face.postScriptName, subset.glyphIds)}+${face.postScriptName}`;
+	const cidFont = pdfDict({
+		Type: pdfName("Font"),
+		Subtype: pdfName("CIDFontType2"),
+		BaseFont: pdfName(baseFont),
+		CIDSystemInfo: pdfDict({
+			Registry: pdfHexString(new TextEncoder().encode("Adobe")),
+			Ordering: pdfHexString(new TextEncoder().encode("Identity")),
+			Supplement: pdfNum(0)
+		}),
+		FontDescriptor: refs.descriptorRef,
+		DW: pdfNum(DEFAULT_WIDTH),
+		W: buildWidthsArray(face, subset.glyphIds),
+		CIDToGIDMap: pdfName("Identity")
+	});
+	return {
+		baseFont,
+		type0: pdfDict({
+			Type: pdfName("Font"),
+			Subtype: pdfName("Type0"),
+			BaseFont: pdfName(baseFont),
+			Encoding: pdfName("Identity-H"),
+			DescendantFonts: pdfArray([refs.cidFontRef]),
+			ToUnicode: refs.toUnicodeRef
+		}),
+		cidFont,
+		descriptor: buildFontDescriptor(face, baseFont, refs.fontFileRef),
+		fontFile: buildFontFileStream(subset.bytes, compress),
+		toUnicode: buildToUnicodeCMap(usedGlyphs)
+	};
+}
+//#endregion
+export { buildEmbeddedFontObjects, embeddedSubsetTag };

package/dist/embedded-font.cjs

@@ -0,0 +1,142 @@
+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");
+const require_hmtx_table = require("./hmtx-table.cjs");
+//#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 = require_font_tables.parseHead(font);
+	const maxp = require_font_tables.parseMaxp(font);
+	const glyphId = cmap(CAP_HEIGHT_REFERENCE_CODE_POINT);
+	if (head === void 0 || maxp === void 0 || glyphId === void 0) return ascent;
+	return require_glyf.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 = require_font_tables.parseHead(font);
+	const maxp = require_font_tables.parseMaxp(font);
+	const name = require_font_tables.parseName(font);
+	const cmap = require_cmap_table.buildCmapLookup(font);
+	if (head === void 0 || maxp === void 0 || cmap === void 0 || name?.postScriptName === void 0) return;
+	const hhea = parseHhea(font);
+	const hmtxBytes = require_sfnt.sfntTableBytes(font, "hmtx");
+	if (hhea === void 0 || hmtxBytes === void 0 || !require_sfnt.hasBytes(hmtxBytes, 0, hhea.numberOfHMetrics * LONG_HOR_METRIC_SIZE)) return;
+	const hmtx = require_hmtx_table.parseHmtx(font);
+	const os2 = require_font_tables.parseOs2(font);
+	const post = require_font_tables.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 = require_sfnt.sfntTableBytes(font, "hhea");
+	if (bytes === void 0 || !require_sfnt.hasBytes(bytes, 0, HHEA_TABLE_SIZE)) return;
+	const numberOfHMetrics = require_sfnt.u16(bytes, HHEA_NUMBER_OF_HMETRICS_OFFSET);
+	if (numberOfHMetrics === 0) return;
+	return {
+		ascent: require_sfnt.i16(bytes, HHEA_ASCENDER_OFFSET),
+		descent: require_sfnt.i16(bytes, HHEA_DESCENDER_OFFSET),
+		lineGap: require_sfnt.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
+exports.NOTDEF_GLYPH_ID = NOTDEF_GLYPH_ID;
+exports.collectEmbeddedGlyphs = collectEmbeddedGlyphs;
+exports.encodeForShowEmbedded = encodeForShowEmbedded;
+exports.loadEmbeddedFace = loadEmbeddedFace;

package/dist/embedded-font.d.cts

@@ -0,0 +1,2 @@
+import { a as NOTDEF_GLYPH_ID, c as loadEmbeddedFace, i as EmbeddedShow, n as EmbeddedFaceMetrics, o as collectEmbeddedGlyphs, r as EmbeddedFaceSubstitution, s as encodeForShowEmbedded, t as EmbeddedFace } from "./embedded-font-CLedn-mT.cjs";
+export { EmbeddedFace, EmbeddedFaceMetrics, EmbeddedFaceSubstitution, EmbeddedShow, NOTDEF_GLYPH_ID, collectEmbeddedGlyphs, encodeForShowEmbedded, loadEmbeddedFace };

package/dist/embedded-font.d.ts

@@ -0,0 +1,2 @@
+import { a as NOTDEF_GLYPH_ID, c as loadEmbeddedFace, i as EmbeddedShow, n as EmbeddedFaceMetrics, o as collectEmbeddedGlyphs, r as EmbeddedFaceSubstitution, s as encodeForShowEmbedded, t as EmbeddedFace } from "./embedded-font-CbqkKgBl.js";
+export { EmbeddedFace, EmbeddedFaceMetrics, EmbeddedFaceSubstitution, EmbeddedShow, NOTDEF_GLYPH_ID, collectEmbeddedGlyphs, encodeForShowEmbedded, loadEmbeddedFace };