pdf-codec 1.5.0 → 1.7.0

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

package/dist/embedded-font.js

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

package/dist/filters.cjs

@@ -3,9 +3,10 @@ const require_bytes_reader = require("./bytes/reader.cjs");
 const require_objects = require("./objects.cjs");
 const require_bytes_flate = require("./bytes/flate.cjs");
 const require_image_ccitt = require("./image/ccitt.cjs");
+const require_image_jbig2 = require("./image/jbig2.cjs");
 const require_predictors = require("./predictors.cjs");
 //#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;
@@ -20,10 +21,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",
@@ -57,6 +69,37 @@ function ccittFaxDecode(data, parm, dict, sink) {
 		})
 	}).bytes;
 }
+function jbig2Decode(data, parm, dict, sink, resolve) {
+	const globalsObj = parm !== void 0 ? require_objects.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 = require_image_jbig2.decodeJbig2Embedded(data, {
+			globals,
+			width: require_objects.asNumber(require_objects.dictGet(dict, "Width") ?? require_objects.dictGet(dict, "W")),
+			height: require_objects.asNumber(require_objects.dictGet(dict, "Height") ?? require_objects.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 = require_objects.dictGet(dict, "Filter") ?? require_objects.dictGet(dict, "F");
 	if (filterObj === void 0) return [];