pdf-parser.js 3.0.8 → 4.5.1

package/dist/afm-widths.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_afm_widths = require("./afm-widths-BoeTOK2r.cjs");
+const require_afm_widths = require("./afm-widths-BTu0IDp2.cjs");
 exports.STANDARD_METRICS = require_afm_widths.STANDARD_METRICS;
 exports.widthOfCode = require_afm_widths.widthOfCode;

package/dist/afm-widths.d.cts

@@ -1,2 +1,2 @@
-import { i as widthOfCode, n as STANDARD_METRICS, r as StandardFontName, t as FontMetrics } from "./afm-widths-DyDq56Ph.cjs";
+import { i as widthOfCode, n as STANDARD_METRICS, r as StandardFontName, t as FontMetrics } from "./afm-widths-CneRyu5l.cjs";
 export { FontMetrics, STANDARD_METRICS, StandardFontName, widthOfCode };

package/dist/afm-widths.d.ts

@@ -1,2 +1,2 @@
-import { i as widthOfCode, n as STANDARD_METRICS, r as StandardFontName, t as FontMetrics } from "./afm-widths-DyDq56Ph.js";
+import { i as widthOfCode, n as STANDARD_METRICS, r as StandardFontName, t as FontMetrics } from "./afm-widths-CneRyu5l.js";
 export { FontMetrics, STANDARD_METRICS, StandardFontName, widthOfCode };

package/dist/afm-widths.js

@@ -1,2 +1,2 @@
-import { n as widthOfCode, t as STANDARD_METRICS } from "./afm-widths-Dxucrg7D.js";
+import { n as widthOfCode, t as STANDARD_METRICS } from "./afm-widths-De_QMWgC.js";
 export { STANDARD_METRICS, widthOfCode };

package/dist/annotations.cjs

@@ -0,0 +1,104 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./notes-annotation-author.cjs");
+const require_objects = require("./objects.cjs");
+const require_pdf_text = require("./pdf-text.cjs");
+const require_serialize = require("./serialize.cjs");
+const require_matrix = require("./matrix.cjs");
+//#region src/annotations.ts
+const SEMANTIC_SUBTYPES = /* @__PURE__ */ new Set([
+	"Text",
+	"FreeText",
+	"Highlight",
+	"Underline",
+	"StrikeOut",
+	"Squiggly"
+]);
+const OWNED_ELSEWHERE_SUBTYPES = /* @__PURE__ */ new Set([
+	"Link",
+	"FileAttachment",
+	"Widget",
+	"Popup"
+]);
+function readPageAnnotations(page, pageMatrix, resolver, sink) {
+	const annotsArr = require_objects.asArray(require_objects.dictGet(page, "Annots"));
+	if (annotsArr === void 0) return [];
+	const annotations = [];
+	for (const annotRef of annotsArr) {
+		const annot = resolver.resolveDict(annotRef);
+		if (annot === void 0) continue;
+		const subtype = require_objects.asName(require_objects.dictGet(annot, "Subtype"));
+		if (subtype === void 0 || OWNED_ELSEWHERE_SUBTYPES.has(subtype)) continue;
+		if (subtype === "Text" && annotString(annot, "T") === "documents.js:notes") continue;
+		const rectArr = require_objects.asArray(require_objects.dictGet(annot, "Rect"));
+		if (rectArr === void 0) {
+			sink({
+				code: "pdf/annotation-missing-rect",
+				severity: "warning",
+				message: `a /${subtype} annotation carries no /Rect; skipping it`
+			});
+			continue;
+		}
+		const x1 = require_objects.asNumber(rectArr[0]) ?? 0;
+		const y1 = require_objects.asNumber(rectArr[1]) ?? 0;
+		const x2 = require_objects.asNumber(rectArr[2]) ?? 0;
+		const y2 = require_objects.asNumber(rectArr[3]) ?? 0;
+		const p1 = require_matrix.applyMatrix(pageMatrix, {
+			x: Math.min(x1, x2),
+			y: Math.min(y1, y2)
+		});
+		const p2 = require_matrix.applyMatrix(pageMatrix, {
+			x: Math.max(x1, x2),
+			y: Math.max(y1, y2)
+		});
+		const contents = annotString(annot, "Contents");
+		const author = annotString(annot, "T");
+		const modifiedIso = require_pdf_text.parsePdfDate(annotString(annot, "M"));
+		annotations.push({
+			subtype,
+			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),
+			...contents !== void 0 ? { contents } : {},
+			...author !== void 0 ? { author } : {},
+			...modifiedIso !== void 0 ? { modifiedIso } : {},
+			...SEMANTIC_SUBTYPES.has(subtype) ? markupFields(annot, pageMatrix) : { source: {
+				format: "pdf",
+				xml: require_serialize.serializeObjectToText(annot)
+			} }
+		});
+	}
+	return annotations;
+}
+function annotString(annot, key) {
+	const obj = require_objects.dictGet(annot, key);
+	return obj?.kind === "string" ? require_pdf_text.decodePdfString(obj.bytes) : void 0;
+}
+function markupFields(annot, pageMatrix) {
+	const quadPoints = require_objects.asArray(require_objects.dictGet(annot, "QuadPoints"));
+	if (quadPoints === void 0 || quadPoints.length < 8 || quadPoints.length % 8 !== 0) return {};
+	const quads = [];
+	for (let i = 0; i < quadPoints.length; i += 8) {
+		const corner = (index) => {
+			const x = require_objects.asNumber(quadPoints[i + index * 2]) ?? 0;
+			const y = require_objects.asNumber(quadPoints[i + index * 2 + 1]) ?? 0;
+			const transformed = require_matrix.applyMatrix(pageMatrix, {
+				x,
+				y
+			});
+			return {
+				xPt: transformed.x,
+				yPt: transformed.y
+			};
+		};
+		quads.push([
+			corner(0),
+			corner(1),
+			corner(2),
+			corner(3)
+		]);
+	}
+	return { quads };
+}
+//#endregion
+exports.readPageAnnotations = readPageAnnotations;

package/dist/annotations.d.cts

@@ -0,0 +1,9 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+import { r as Matrix } from "./matrix-B7_SBKQ5.cjs";
+import { n as PdfDict } from "./objects-B7HdMeWS.cjs";
+import { PdfObjectResolver } from "./interpret.cjs";
+import { LayoutAnnotation } from "./layout.cjs";
+//#region src/annotations.d.ts
+declare function readPageAnnotations(page: PdfDict, pageMatrix: Matrix, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): LayoutAnnotation[];
+//#endregion
+export { readPageAnnotations };

package/dist/annotations.d.ts

@@ -0,0 +1,9 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { r as Matrix } from "./matrix-B7_SBKQ5.js";
+import { n as PdfDict } from "./objects-B7HdMeWS.js";
+import { PdfObjectResolver } from "./interpret.js";
+import { LayoutAnnotation } from "./layout.js";
+//#region src/annotations.d.ts
+declare function readPageAnnotations(page: PdfDict, pageMatrix: Matrix, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): LayoutAnnotation[];
+//#endregion
+export { readPageAnnotations };

package/dist/annotations.js

@@ -0,0 +1,103 @@
+import "./notes-annotation-author.js";
+import { asArray, asName, asNumber, dictGet } from "./objects.js";
+import { decodePdfString, parsePdfDate } from "./pdf-text.js";
+import { serializeObjectToText } from "./serialize.js";
+import { applyMatrix } from "./matrix.js";
+//#region src/annotations.ts
+const SEMANTIC_SUBTYPES = /* @__PURE__ */ new Set([
+	"Text",
+	"FreeText",
+	"Highlight",
+	"Underline",
+	"StrikeOut",
+	"Squiggly"
+]);
+const OWNED_ELSEWHERE_SUBTYPES = /* @__PURE__ */ new Set([
+	"Link",
+	"FileAttachment",
+	"Widget",
+	"Popup"
+]);
+function readPageAnnotations(page, pageMatrix, resolver, sink) {
+	const annotsArr = asArray(dictGet(page, "Annots"));
+	if (annotsArr === void 0) return [];
+	const annotations = [];
+	for (const annotRef of annotsArr) {
+		const annot = resolver.resolveDict(annotRef);
+		if (annot === void 0) continue;
+		const subtype = asName(dictGet(annot, "Subtype"));
+		if (subtype === void 0 || OWNED_ELSEWHERE_SUBTYPES.has(subtype)) continue;
+		if (subtype === "Text" && annotString(annot, "T") === "documents.js:notes") continue;
+		const rectArr = asArray(dictGet(annot, "Rect"));
+		if (rectArr === void 0) {
+			sink({
+				code: "pdf/annotation-missing-rect",
+				severity: "warning",
+				message: `a /${subtype} annotation carries no /Rect; skipping it`
+			});
+			continue;
+		}
+		const x1 = asNumber(rectArr[0]) ?? 0;
+		const y1 = asNumber(rectArr[1]) ?? 0;
+		const x2 = asNumber(rectArr[2]) ?? 0;
+		const y2 = asNumber(rectArr[3]) ?? 0;
+		const p1 = applyMatrix(pageMatrix, {
+			x: Math.min(x1, x2),
+			y: Math.min(y1, y2)
+		});
+		const p2 = applyMatrix(pageMatrix, {
+			x: Math.max(x1, x2),
+			y: Math.max(y1, y2)
+		});
+		const contents = annotString(annot, "Contents");
+		const author = annotString(annot, "T");
+		const modifiedIso = parsePdfDate(annotString(annot, "M"));
+		annotations.push({
+			subtype,
+			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),
+			...contents !== void 0 ? { contents } : {},
+			...author !== void 0 ? { author } : {},
+			...modifiedIso !== void 0 ? { modifiedIso } : {},
+			...SEMANTIC_SUBTYPES.has(subtype) ? markupFields(annot, pageMatrix) : { source: {
+				format: "pdf",
+				xml: serializeObjectToText(annot)
+			} }
+		});
+	}
+	return annotations;
+}
+function annotString(annot, key) {
+	const obj = dictGet(annot, key);
+	return obj?.kind === "string" ? decodePdfString(obj.bytes) : void 0;
+}
+function markupFields(annot, pageMatrix) {
+	const quadPoints = asArray(dictGet(annot, "QuadPoints"));
+	if (quadPoints === void 0 || quadPoints.length < 8 || quadPoints.length % 8 !== 0) return {};
+	const quads = [];
+	for (let i = 0; i < quadPoints.length; i += 8) {
+		const corner = (index) => {
+			const x = asNumber(quadPoints[i + index * 2]) ?? 0;
+			const y = asNumber(quadPoints[i + index * 2 + 1]) ?? 0;
+			const transformed = applyMatrix(pageMatrix, {
+				x,
+				y
+			});
+			return {
+				xPt: transformed.x,
+				yPt: transformed.y
+			};
+		};
+		quads.push([
+			corner(0),
+			corner(1),
+			corner(2),
+			corner(3)
+		]);
+	}
+	return { quads };
+}
+//#endregion
+export { readPageAnnotations };

package/dist/attachments.cjs

@@ -0,0 +1,65 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objects = require("./objects.cjs");
+const require_pdf_text = require("./pdf-text.cjs");
+const require_filters = require("./filters.cjs");
+const require_names = require("./names.cjs");
+const require_util_base64 = require("./util/base64.cjs");
+//#region src/attachments.ts
+function readAttachments(catalog, pages, resolver, sink) {
+	const attachments = [];
+	const seen = /* @__PURE__ */ new Set();
+	const collect = (filespecRef) => {
+		const filespec = resolver.resolveDict(filespecRef);
+		if (filespec === void 0) return;
+		const name = filespecName(filespec);
+		if (name === void 0 || seen.has(name)) return;
+		const attachment = readFilespec(name, filespec, resolver, sink);
+		if (attachment !== void 0) {
+			seen.add(name);
+			attachments.push(attachment);
+		}
+	};
+	const namesRoot = resolver.resolveDict(require_objects.dictGet(catalog, "Names"));
+	for (const entry of require_names.walkNameTree(namesRoot === void 0 ? void 0 : require_objects.dictGet(namesRoot, "EmbeddedFiles"), resolver, sink)) collect(entry.value);
+	for (const page of pages) {
+		const annots = require_objects.asArray(require_objects.dictGet(page, "Annots"));
+		if (annots === void 0) continue;
+		for (const annotRef of annots) {
+			const annot = resolver.resolveDict(annotRef);
+			if (annot !== void 0 && require_objects.asName(require_objects.dictGet(annot, "Subtype")) === "FileAttachment") collect(require_objects.dictGet(annot, "FS"));
+		}
+	}
+	const af = require_objects.asArray(resolver.resolve(require_objects.dictGet(catalog, "AF")));
+	if (af !== void 0) for (const filespecRef of af) collect(filespecRef);
+	return attachments;
+}
+function filespecName(filespec) {
+	for (const key of ["UF", "F"]) {
+		const obj = require_objects.dictGet(filespec, key);
+		if (obj?.kind === "string") return require_pdf_text.decodePdfString(obj.bytes);
+	}
+}
+function readFilespec(name, filespec, resolver, sink) {
+	const ef = resolver.resolveDict(require_objects.dictGet(filespec, "EF"));
+	if (ef === void 0) return;
+	for (const key of ["F", "UF"]) {
+		const streamObj = resolver.resolve(require_objects.dictGet(ef, key));
+		if (streamObj?.kind !== "stream") continue;
+		const decoded = require_filters.decodeStream(streamObj.raw, streamObj.dict, sink);
+		const descObj = require_objects.dictGet(filespec, "Desc");
+		const subtype = require_objects.asName(require_objects.dictGet(streamObj.dict, "Subtype"));
+		return {
+			name,
+			...descObj?.kind === "string" ? { description: require_pdf_text.decodePdfString(descObj.bytes) } : {},
+			...subtype !== void 0 ? { mimeType: subtype } : {},
+			base64: require_util_base64.bytesToBase64(decoded.bytes)
+		};
+	}
+	sink({
+		code: "pdf/embedded-file-missing-stream",
+		severity: "warning",
+		message: "a filespec declares /EF but neither /F nor /UF resolves to an embedded stream"
+	});
+}
+//#endregion
+exports.readAttachments = readAttachments;

package/dist/attachments.d.cts

@@ -0,0 +1,8 @@
+import { PdfDiagnosticSink } from "./diagnostics.cjs";
+import { n as PdfDict } from "./objects-B7HdMeWS.cjs";
+import { PdfObjectResolver } from "./interpret.cjs";
+import { LayoutAttachment } from "./layout.cjs";
+//#region src/attachments.d.ts
+declare function readAttachments(catalog: PdfDict, pages: readonly PdfDict[], resolver: PdfObjectResolver, sink: PdfDiagnosticSink): LayoutAttachment[];
+//#endregion
+export { readAttachments };

package/dist/attachments.d.ts

@@ -0,0 +1,8 @@
+import { PdfDiagnosticSink } from "./diagnostics.js";
+import { n as PdfDict } from "./objects-B7HdMeWS.js";
+import { PdfObjectResolver } from "./interpret.js";
+import { LayoutAttachment } from "./layout.js";
+//#region src/attachments.d.ts
+declare function readAttachments(catalog: PdfDict, pages: readonly PdfDict[], resolver: PdfObjectResolver, sink: PdfDiagnosticSink): LayoutAttachment[];
+//#endregion
+export { readAttachments };

package/dist/attachments.js

@@ -0,0 +1,64 @@
+import { asArray, asName, dictGet } from "./objects.js";
+import { decodePdfString } from "./pdf-text.js";
+import { decodeStream } from "./filters.js";
+import { walkNameTree } from "./names.js";
+import { bytesToBase64 } from "./util/base64.js";
+//#region src/attachments.ts
+function readAttachments(catalog, pages, resolver, sink) {
+	const attachments = [];
+	const seen = /* @__PURE__ */ new Set();
+	const collect = (filespecRef) => {
+		const filespec = resolver.resolveDict(filespecRef);
+		if (filespec === void 0) return;
+		const name = filespecName(filespec);
+		if (name === void 0 || seen.has(name)) return;
+		const attachment = readFilespec(name, filespec, resolver, sink);
+		if (attachment !== void 0) {
+			seen.add(name);
+			attachments.push(attachment);
+		}
+	};
+	const namesRoot = resolver.resolveDict(dictGet(catalog, "Names"));
+	for (const entry of walkNameTree(namesRoot === void 0 ? void 0 : dictGet(namesRoot, "EmbeddedFiles"), resolver, sink)) collect(entry.value);
+	for (const page of pages) {
+		const annots = asArray(dictGet(page, "Annots"));
+		if (annots === void 0) continue;
+		for (const annotRef of annots) {
+			const annot = resolver.resolveDict(annotRef);
+			if (annot !== void 0 && asName(dictGet(annot, "Subtype")) === "FileAttachment") collect(dictGet(annot, "FS"));
+		}
+	}
+	const af = asArray(resolver.resolve(dictGet(catalog, "AF")));
+	if (af !== void 0) for (const filespecRef of af) collect(filespecRef);
+	return attachments;
+}
+function filespecName(filespec) {
+	for (const key of ["UF", "F"]) {
+		const obj = dictGet(filespec, key);
+		if (obj?.kind === "string") return decodePdfString(obj.bytes);
+	}
+}
+function readFilespec(name, filespec, resolver, sink) {
+	const ef = resolver.resolveDict(dictGet(filespec, "EF"));
+	if (ef === void 0) return;
+	for (const key of ["F", "UF"]) {
+		const streamObj = resolver.resolve(dictGet(ef, key));
+		if (streamObj?.kind !== "stream") continue;
+		const decoded = decodeStream(streamObj.raw, streamObj.dict, sink);
+		const descObj = dictGet(filespec, "Desc");
+		const subtype = asName(dictGet(streamObj.dict, "Subtype"));
+		return {
+			name,
+			...descObj?.kind === "string" ? { description: decodePdfString(descObj.bytes) } : {},
+			...subtype !== void 0 ? { mimeType: subtype } : {},
+			base64: bytesToBase64(decoded.bytes)
+		};
+	}
+	sink({
+		code: "pdf/embedded-file-missing-stream",
+		severity: "warning",
+		message: "a filespec declares /EF but neither /F nor /UF resolves to an embedded stream"
+	});
+}
+//#endregion
+export { readAttachments };

package/dist/builtin-encoding.cjs

@@ -0,0 +1,221 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_afm_widths = require("./afm-widths-BTu0IDp2.cjs");
+const require_sfnt = require("./sfnt.cjs");
+const require_cff = require("./cff.cjs");
+const require_cmap_table = require("./cmap-table.cjs");
+const require_font_tables = require("./font-tables.cjs");
+//#region src/builtin-encoding.ts
+function isPrivateUse(codePoint) {
+	return codePoint >= 57344 && codePoint <= 63743 || codePoint >= 983040 && codePoint <= 1048573 || codePoint >= 1048576 && codePoint <= 1114109;
+}
+function encodingFromSources(sources) {
+	const { codeToGlyphId, codeToName, glyphIdToName, glyphIdToUnicode } = sources;
+	const glyphUnicode = (glyphId) => {
+		const name = glyphIdToName?.(glyphId);
+		return (name !== void 0 ? require_afm_widths.glyphNameToUnicode(name) : void 0) ?? glyphIdToUnicode?.(glyphId);
+	};
+	const codeUnicode = (code) => {
+		const name = codeToName?.(code);
+		if (name !== void 0) {
+			const named = require_afm_widths.glyphNameToUnicode(name);
+			if (named !== void 0) return named;
+		}
+		const glyphId = codeToGlyphId?.(code);
+		return glyphId === void 0 ? void 0 : glyphUnicode(glyphId);
+	};
+	return codeToName !== void 0 || codeToGlyphId !== void 0 || glyphIdToName !== void 0 || glyphIdToUnicode !== void 0 ? {
+		codeToUnicode: codeUnicode,
+		glyphIdToUnicode: glyphUnicode
+	} : void 0;
+}
+const SYMBOL_CMAP_CODE_BASE = 61440;
+function symbolSubtable(subtables) {
+	return subtables.find((s) => s.platformId === 3 && s.encodingId === 0) ?? subtables.find((s) => s.platformId === 1 && s.encodingId === 0);
+}
+function unicodeSubtable(subtables) {
+	return subtables.find((s) => s.platformId === 3 && s.encodingId === 10) ?? subtables.find((s) => s.platformId === 3 && s.encodingId === 1) ?? subtables.find((s) => s.platformId === 0);
+}
+function invertUnicodeSubtable(subtable) {
+	let inverse;
+	return (glyphId) => {
+		if (inverse === void 0) {
+			const built = /* @__PURE__ */ new Map();
+			subtable.forEachMapping((code, mappedGlyphId) => {
+				if (!isPrivateUse(code) && !built.has(mappedGlyphId)) built.set(mappedGlyphId, code);
+			});
+			inverse = built;
+		}
+		return inverse.get(glyphId);
+	};
+}
+function trueTypeSources(font) {
+	const subtables = require_cmap_table.readCmapSubtables(font);
+	const symbol = symbolSubtable(subtables);
+	const unicode = unicodeSubtable(subtables);
+	return {
+		codeToGlyphId: symbol !== void 0 ? (code) => symbol.lookup(SYMBOL_CMAP_CODE_BASE | code) ?? symbol.lookup(code) : unicode !== void 0 ? (code) => unicode.lookup(SYMBOL_CMAP_CODE_BASE | code) : void 0,
+		glyphIdToName: require_font_tables.parsePostGlyphNames(font),
+		glyphIdToUnicode: unicode !== void 0 ? invertUnicodeSubtable(unicode) : void 0
+	};
+}
+const CFF_HEADER_SIZE = 4;
+const CFF_MAJOR_VERSION = 1;
+const CFF_PREDEFINED_CHARSET_ISO_ADOBE = 0;
+const CFF_PREDEFINED_ENCODING_STANDARD = 0;
+const CFF_ENCODING_FORMAT_MASK = 127;
+const CFF_ENCODING_SUPPLEMENT_FLAG = 128;
+function readCffCharset(bytes, offset, glyphCount) {
+	const sidByGlyph = /* @__PURE__ */ new Map();
+	if (offset === CFF_PREDEFINED_CHARSET_ISO_ADOBE) {
+		for (let glyphId = 1; glyphId < glyphCount; glyphId++) sidByGlyph.set(glyphId, glyphId);
+		return sidByGlyph;
+	}
+	if (offset < CFF_HEADER_SIZE || !require_sfnt.hasBytes(bytes, offset, 1)) return;
+	const format = require_sfnt.u8(bytes, offset);
+	let cursor = offset + 1;
+	if (format === 0) {
+		for (let glyphId = 1; glyphId < glyphCount; glyphId++) {
+			if (!require_sfnt.hasBytes(bytes, cursor, 2)) return sidByGlyph;
+			sidByGlyph.set(glyphId, require_sfnt.u16(bytes, cursor));
+			cursor += 2;
+		}
+		return sidByGlyph;
+	}
+	if (format !== 1 && format !== 2) return;
+	const nLeftSize = format === 1 ? 1 : 2;
+	let glyphId = 1;
+	while (glyphId < glyphCount) {
+		if (!require_sfnt.hasBytes(bytes, cursor, 2 + nLeftSize)) return sidByGlyph;
+		const firstSid = require_sfnt.u16(bytes, cursor);
+		const nLeft = format === 1 ? require_sfnt.u8(bytes, cursor + 2) : require_sfnt.u16(bytes, cursor + 2);
+		for (let i = 0; i <= nLeft && glyphId < glyphCount; i++) {
+			sidByGlyph.set(glyphId, firstSid + i);
+			glyphId++;
+		}
+		cursor += 2 + nLeftSize;
+	}
+	return sidByGlyph;
+}
+function readCffEncoding(bytes, offset, glyphCount, glyphBySid) {
+	if (offset < CFF_HEADER_SIZE || !require_sfnt.hasBytes(bytes, offset, 2)) return;
+	const formatByte = require_sfnt.u8(bytes, offset);
+	const format = formatByte & CFF_ENCODING_FORMAT_MASK;
+	const glyphByCode = /* @__PURE__ */ new Map();
+	let cursor = offset + 1;
+	if (format === 0) {
+		const nCodes = require_sfnt.u8(bytes, cursor);
+		cursor += 1;
+		for (let i = 0; i < nCodes; i++) {
+			if (!require_sfnt.hasBytes(bytes, cursor, 1)) return glyphByCode;
+			const glyphId = i + 1;
+			if (glyphId < glyphCount) glyphByCode.set(require_sfnt.u8(bytes, cursor), glyphId);
+			cursor += 1;
+		}
+	} else if (format === 1) {
+		const nRanges = require_sfnt.u8(bytes, cursor);
+		cursor += 1;
+		let glyphId = 1;
+		for (let i = 0; i < nRanges; i++) {
+			if (!require_sfnt.hasBytes(bytes, cursor, 2)) return glyphByCode;
+			const first = require_sfnt.u8(bytes, cursor);
+			const nLeft = require_sfnt.u8(bytes, cursor + 1);
+			for (let j = 0; j <= nLeft && glyphId < glyphCount; j++) {
+				glyphByCode.set(first + j, glyphId);
+				glyphId++;
+			}
+			cursor += 2;
+		}
+	} else return;
+	if ((formatByte & CFF_ENCODING_SUPPLEMENT_FLAG) !== 0) {
+		if (!require_sfnt.hasBytes(bytes, cursor, 1)) return glyphByCode;
+		const nSups = require_sfnt.u8(bytes, cursor);
+		cursor += 1;
+		for (let i = 0; i < nSups; i++) {
+			if (!require_sfnt.hasBytes(bytes, cursor, 3)) return glyphByCode;
+			const glyphId = glyphBySid.get(require_sfnt.u16(bytes, cursor + 1));
+			if (glyphId !== void 0) glyphByCode.set(require_sfnt.u8(bytes, cursor), glyphId);
+			cursor += 3;
+		}
+	}
+	return glyphByCode;
+}
+function cffSources(bytes, predefinedEncodingApplies) {
+	if (!require_sfnt.hasBytes(bytes, 0, CFF_HEADER_SIZE)) return;
+	const headerSize = require_sfnt.u8(bytes, 2);
+	if (require_sfnt.u8(bytes, 0) !== CFF_MAJOR_VERSION || headerSize < CFF_HEADER_SIZE) return;
+	const nameIndex = require_cff.readCffIndex(bytes, headerSize);
+	if (nameIndex === void 0) return;
+	const topDictIndex = require_cff.readCffIndex(bytes, nameIndex.endOffset);
+	const topDictBytes = topDictIndex?.entry(0);
+	if (topDictIndex === void 0 || topDictBytes === void 0) return;
+	const topDict = require_cff.parseCffDict(topDictBytes);
+	if (topDict === void 0 || topDict.has(1230)) return;
+	const stringIndex = require_cff.readCffIndex(bytes, topDictIndex.endOffset);
+	const charStringsOffset = topDict.get(17)?.[0];
+	const glyphCount = charStringsOffset === void 0 ? void 0 : require_cff.readCffIndex(bytes, charStringsOffset)?.count;
+	if (glyphCount === void 0) return;
+	const sidByGlyph = readCffCharset(bytes, topDict.get(15)?.[0] ?? CFF_PREDEFINED_CHARSET_ISO_ADOBE, glyphCount);
+	const glyphIdToName = sidByGlyph === void 0 ? void 0 : (glyphId) => {
+		const sid = sidByGlyph.get(glyphId);
+		return sid === void 0 ? void 0 : require_cff.cffStringForSid(sid, stringIndex);
+	};
+	const encodingOffset = topDict.get(16)?.[0] ?? CFF_PREDEFINED_ENCODING_STANDARD;
+	if (encodingOffset === CFF_PREDEFINED_ENCODING_STANDARD) return predefinedEncodingApplies ? {
+		codeToName: require_afm_widths.standardGlyphName,
+		glyphIdToName
+	} : { glyphIdToName };
+	const glyphBySid = /* @__PURE__ */ new Map();
+	for (const [glyphId, sid] of sidByGlyph ?? []) if (!glyphBySid.has(sid)) glyphBySid.set(sid, glyphId);
+	const glyphByCode = readCffEncoding(bytes, encodingOffset, glyphCount, glyphBySid);
+	return glyphByCode === void 0 ? { glyphIdToName } : {
+		codeToGlyphId: (code) => glyphByCode.get(code),
+		glyphIdToName
+	};
+}
+function matchesAscii(bytes, offset, text) {
+	for (let i = 0; i < text.length; i++) if (bytes[offset + i] !== text.charCodeAt(i)) return false;
+	return true;
+}
+const TYPE1_CLEARTEXT_TERMINATOR = "eexec";
+const PFB_SEGMENT_MARKER = 128;
+const PFB_SEGMENT_HEADER_SIZE = 6;
+const POSTSCRIPT_MAGIC = "%!";
+function type1Sources(bytes) {
+	const start = bytes[0] === PFB_SEGMENT_MARKER ? PFB_SEGMENT_HEADER_SIZE : 0;
+	if (!matchesAscii(bytes, start, POSTSCRIPT_MAGIC)) return;
+	let cleartextEnd = bytes.length;
+	for (let i = start; i + 5 <= bytes.length; i++) if (matchesAscii(bytes, i, TYPE1_CLEARTEXT_TERMINATOR)) {
+		cleartextEnd = i;
+		break;
+	}
+	let header = "";
+	for (let i = start; i < cleartextEnd; i++) header += String.fromCharCode(bytes[i] ?? 0);
+	if (!header.includes("/Encoding")) return;
+	if (/\/Encoding\s+StandardEncoding\s+def/.test(header)) return { codeToName: require_afm_widths.standardGlyphName };
+	const nameByCode = /* @__PURE__ */ new Map();
+	for (const match of header.matchAll(/dup\s+(\d+)\s*\/([^\s/[\]{}<>()%]+)\s+put/g)) {
+		const code = Number(match[1]);
+		const name = match[2];
+		if (name !== void 0 && Number.isInteger(code)) nameByCode.set(code, name);
+	}
+	return nameByCode.size === 0 ? void 0 : { codeToName: (code) => nameByCode.get(code) };
+}
+function readFontProgramEncoding(program) {
+	const font = require_sfnt.parseSfnt(program);
+	if (font !== void 0) {
+		const cff = require_sfnt.sfntTableBytes(font, "CFF ");
+		const container = trueTypeSources(font);
+		const outlines = cff === void 0 ? void 0 : cffSources(cff, false);
+		return encodingFromSources({
+			codeToGlyphId: container.codeToGlyphId ?? outlines?.codeToGlyphId,
+			glyphIdToName: container.glyphIdToName ?? outlines?.glyphIdToName,
+			glyphIdToUnicode: container.glyphIdToUnicode
+		});
+	}
+	const cff = cffSources(program, true);
+	if (cff !== void 0) return encodingFromSources(cff);
+	const type1 = type1Sources(program);
+	return type1 === void 0 ? void 0 : encodingFromSources(type1);
+}
+//#endregion
+exports.readFontProgramEncoding = readFontProgramEncoding;

package/dist/builtin-encoding.d.cts

@@ -0,0 +1,8 @@
+//#region src/builtin-encoding.d.ts
+interface BuiltinEncoding {
+  codeToUnicode(code: number): number | undefined;
+  glyphIdToUnicode(glyphId: number): number | undefined;
+}
+declare function readFontProgramEncoding(program: Uint8Array<ArrayBuffer>): BuiltinEncoding | undefined;
+//#endregion
+export { BuiltinEncoding, readFontProgramEncoding };

package/dist/builtin-encoding.d.ts

@@ -0,0 +1,8 @@
+//#region src/builtin-encoding.d.ts
+interface BuiltinEncoding {
+  codeToUnicode(code: number): number | undefined;
+  glyphIdToUnicode(glyphId: number): number | undefined;
+}
+declare function readFontProgramEncoding(program: Uint8Array<ArrayBuffer>): BuiltinEncoding | undefined;
+//#endregion
+export { BuiltinEncoding, readFontProgramEncoding };