pdf-codec 5.7.3 → 5.8.0

package/dist/builtin-encoding.js

@@ -1,9 +1,11 @@
 import { standardGlyphName } from "./encoding-standard-tables.js";
-import { a as glyphNameToUnicode } from "./afm-widths-BNI8qa2S.js";
 import { hasBytes, parseSfnt, sfntTableBytes, u16, u8 } from "./sfnt.js";
 import { cffStringForSid, parseCffDict, readCffIndex } from "./cff.js";
 import { readCmapSubtables } from "./cmap-table.js";
-import { parsePostGlyphNames } from "./font-tables.js";
+import { coreFaceGlyphOrder } from "./core-font-glyph-orders.js";
+import { withoutSubsetTag } from "./font-style.js";
+import { parseHead, parseMaxp, parseName, parsePostGlyphNames } from "./font-tables.js";
+import { glyphNameToUnicode } from "./glyph-names.js";
 //#region src/builtin-encoding.ts
 const PRIVATE_USE_BMP_START = 57344;
 const PRIVATE_USE_BMP_END = 63743;
@@ -15,7 +17,7 @@ function isPrivateUse(codePoint) {
 	return codePoint >= PRIVATE_USE_BMP_START && codePoint <= PRIVATE_USE_BMP_END || codePoint >= PRIVATE_USE_PLANE_A_START && codePoint <= PRIVATE_USE_PLANE_A_END || codePoint >= PRIVATE_USE_PLANE_B_START && codePoint <= PRIVATE_USE_PLANE_B_END;
 }
 function encodingFromSources(sources) {
-	const { codeToGlyphId, codeToName, glyphIdToName, glyphIdToUnicode } = sources;
+	const { codeToGlyphId, codeToName, glyphIdToName, nameToGlyphId, glyphIdToUnicode } = sources;
 	const glyphUnicode = (glyphId) => {
 		const name = glyphIdToName?.(glyphId);
 		return (name !== void 0 ? glyphNameToUnicode(name) : void 0) ?? glyphIdToUnicode?.(glyphId);
@@ -31,9 +33,24 @@ function encodingFromSources(sources) {
 	};
 	return codeToName !== void 0 || codeToGlyphId !== void 0 || glyphIdToName !== void 0 || glyphIdToUnicode !== void 0 ? {
 		codeToUnicode: codeUnicode,
-		glyphIdToUnicode: glyphUnicode
+		glyphIdToUnicode: glyphUnicode,
+		glyphIdOfName: (name) => nameToGlyphId?.(name)
 	} : void 0;
 }
+function invertGlyphNames(glyphIdToName, glyphCount) {
+	let inverse;
+	return (name) => {
+		if (inverse === void 0) {
+			const built = /* @__PURE__ */ new Map();
+			for (let glyphId = 0; glyphId < glyphCount; glyphId++) {
+				const glyphName = glyphIdToName(glyphId);
+				if (glyphName !== void 0 && !built.has(glyphName)) built.set(glyphName, glyphId);
+			}
+			inverse = built;
+		}
+		return inverse.get(name);
+	};
+}
 const SYMBOL_CMAP_CODE_BASE = 61440;
 const CMAP_PLATFORM_MICROSOFT = 3;
 const CMAP_MICROSOFT_ENCODING_SYMBOL = 0;
@@ -55,17 +72,43 @@ function invertUnicodeSubtable(subtable) {
 			});
 			inverse = built;
 		}
-		return inverse.get(glyphId);
+		const codePoint = inverse.get(glyphId);
+		return codePoint === void 0 ? void 0 : String.fromCodePoint(codePoint);
 	};
 }
-function trueTypeSources(font) {
+const HHEA_NUMBER_OF_H_METRICS_OFFSET = 34;
+const HMTX_LONG_HOR_METRIC_SIZE = 4;
+function advanceWidths(font) {
+	const hhea = sfntTableBytes(font, "hhea");
+	const hmtx = sfntTableBytes(font, "hmtx");
+	if (hhea === void 0 || hmtx === void 0 || !hasBytes(hhea, HHEA_NUMBER_OF_H_METRICS_OFFSET, 2)) return;
+	const metricCount = u16(hhea, HHEA_NUMBER_OF_H_METRICS_OFFSET);
+	if (metricCount === 0 || !hasBytes(hmtx, 0, metricCount * HMTX_LONG_HOR_METRIC_SIZE)) return;
+	return (glyphId) => u16(hmtx, Math.min(glyphId, metricCount - 1) * HMTX_LONG_HOR_METRIC_SIZE);
+}
+function coreFaceSource(font, fontName) {
+	const name = parseName(font)?.postScriptName ?? fontName;
+	const unitsPerEm = parseHead(font)?.unitsPerEm;
+	const advanceOf = advanceWidths(font);
+	if (name === void 0 || unitsPerEm === void 0 || advanceOf === void 0) return;
+	const order = coreFaceGlyphOrder(withoutSubsetTag(name), unitsPerEm);
+	if (order === void 0) return;
+	return (glyphId) => order(glyphId, advanceOf(glyphId));
+}
+function trueTypeSources(font, fontName) {
 	const subtables = readCmapSubtables(font);
 	const symbol = symbolSubtable(subtables);
 	const unicode = unicodeSubtable(subtables);
+	const symbolLookup = 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;
+	const glyphIdToName = parsePostGlyphNames(font);
+	const glyphCount = parseMaxp(font)?.numGlyphs;
+	const fromCmap = unicode !== void 0 ? invertUnicodeSubtable(unicode) : void 0;
+	const fromCoreFace = coreFaceSource(font, fontName);
 	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: parsePostGlyphNames(font),
-		glyphIdToUnicode: unicode !== void 0 ? invertUnicodeSubtable(unicode) : void 0
+		codeToGlyphId: symbolLookup,
+		glyphIdToName,
+		nameToGlyphId: glyphIdToName !== void 0 && glyphCount !== void 0 ? invertGlyphNames(glyphIdToName, glyphCount) : void 0,
+		glyphIdToUnicode: fromCmap === void 0 && fromCoreFace === void 0 ? void 0 : (glyphId) => fromCmap?.(glyphId) ?? fromCoreFace?.(glyphId)
 	};
 }
 const CFF_HEADER_SIZE = 4;
@@ -170,17 +213,26 @@ function cffSources(bytes, predefinedEncodingApplies) {
 		const sid = sidByGlyph.get(glyphId);
 		return sid === void 0 ? void 0 : cffStringForSid(sid, stringIndex);
 	};
+	const nameToGlyphId = glyphIdToName === void 0 ? void 0 : invertGlyphNames(glyphIdToName, glyphCount);
 	const encodingOffset = topDict.get(16)?.[0] ?? CFF_PREDEFINED_ENCODING_STANDARD;
 	if (encodingOffset === CFF_PREDEFINED_ENCODING_STANDARD) return predefinedEncodingApplies ? {
 		codeToName: standardGlyphName,
-		glyphIdToName
-	} : { glyphIdToName };
+		glyphIdToName,
+		nameToGlyphId
+	} : {
+		glyphIdToName,
+		nameToGlyphId
+	};
 	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 } : {
+	return glyphByCode === void 0 ? {
+		glyphIdToName,
+		nameToGlyphId
+	} : {
 		codeToGlyphId: (code) => glyphByCode.get(code),
-		glyphIdToName
+		glyphIdToName,
+		nameToGlyphId
 	};
 }
 function matchesAscii(bytes, offset, text) {
@@ -211,15 +263,22 @@ function type1Sources(bytes) {
 	}
 	return nameByCode.size === 0 ? void 0 : { codeToName: (code) => nameByCode.get(code) };
 }
-function readFontProgramEncoding(program) {
+/**
+* Reads whatever encoding an embedded font program carries in itself.
+* @param program - the decoded bytes of a /FontFile, /FontFile2 or /FontFile3 stream
+* @param fontName - the font dictionary's /BaseFont, which identifies a core face only when the program's own 'name' table states no PostScript name; absent when the program is read on its own
+* @returns the program's encoding, or undefined when it states nothing this codec can read (a program in a format not read here, or one too damaged to parse), in which case the caller must fall back rather than treat the absence as a mapping
+*/
+function readFontProgramEncoding(program, fontName) {
 	const font = parseSfnt(program);
 	if (font !== void 0) {
 		const cff = sfntTableBytes(font, "CFF ");
-		const container = trueTypeSources(font);
+		const container = trueTypeSources(font, fontName);
 		const outlines = cff === void 0 ? void 0 : cffSources(cff, false);
 		return encodingFromSources({
 			codeToGlyphId: container.codeToGlyphId ?? outlines?.codeToGlyphId,
 			glyphIdToName: container.glyphIdToName ?? outlines?.glyphIdToName,
+			nameToGlyphId: container.nameToGlyphId ?? outlines?.nameToGlyphId,
 			glyphIdToUnicode: container.glyphIdToUnicode
 		});
 	}

package/dist/content-write.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_afm_widths = require("./afm-widths-sjaRvmQX.cjs");
 const require_objects = require("./objects.cjs");
 const require_bytes_writer = require("./bytes/writer.cjs");
 const require_serialize = require("./serialize.cjs");
 const require_matrix = require("./matrix.cjs");
 const require_embedded_font = require("./embedded-font.cjs");
+const require_winansi = require("./winansi.cjs");
 //#region src/content-write.ts
 const GLYPH_SPACE_UNITS_PER_EM = 1e3;
 const EMBEDDED_HORIZONTAL_SCALE_PERCENT = 100;
@@ -45,7 +45,7 @@ function writeShowTextBlock(writer, item, resourceName, scalePercent, show) {
 	writer.writeAscii("ET\n");
 }
 function writeStandardText(writer, item, standardName, resourceName, measurer) {
-	const encoded = require_afm_widths.encodeForShow(item.text, standardName);
+	const encoded = require_winansi.encodeForShow(item.text, standardName);
 	const scale = measurer.horizontalScaleFor(item.font);
 	writeShowTextBlock(writer, item, resourceName, scale * PERCENT_SCALE_FACTOR, {
 		operand: require_objects.pdfHexString(encoded.codes),

package/dist/content-write.js

@@ -1,9 +1,9 @@
-import { c as encodeForShow } from "./afm-widths-BNI8qa2S.js";
 import { pdfArray, pdfHexString, pdfNum } from "./objects.js";
 import { ByteWriter } from "./bytes/writer.js";
 import { formatNumber, writeObject } from "./serialize.js";
 import { BEZIER_KAPPA, multiplyMatrices, rotationMatrix, scaleMatrix, translationMatrix } from "./matrix.js";
 import { encodeForShowEmbedded } from "./embedded-font.js";
+import { encodeForShow } from "./winansi.js";
 //#region src/content-write.ts
 const GLYPH_SPACE_UNITS_PER_EM = 1e3;
 const EMBEDDED_HORIZONTAL_SCALE_PERCENT = 100;

package/dist/core-font-glyph-orders.cjs

@@ -0,0 +1,62 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_glyph_data_core_font_glyph_orders = require("./glyph-data/core-font-glyph-orders.cjs");
+let fflate = require("fflate");
+let byte_codec = require("byte-codec");
+//#region src/core-font-glyph-orders.ts
+const FACE_COUNT_SIZE = 2;
+const NAME_LENGTH_SIZE = 1;
+const FACE_HEADER_SIZE = 4;
+const CODE_POINT_COUNT_SIZE = 1;
+const CODE_POINT_SIZE = 3;
+const ADVANCE_SIZE = 2;
+let faces;
+function readFaces() {
+	if (faces !== void 0) return faces;
+	const bytes = (0, fflate.inflateSync)((0, byte_codec.base64ToBytes)(require_glyph_data_core_font_glyph_orders.CORE_FONT_GLYPH_ORDERS_DEFLATED_BASE64));
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const read = /* @__PURE__ */ new Map();
+	let at = FACE_COUNT_SIZE;
+	for (let face = 0; face < view.getUint16(0); face++) {
+		const nameLength = view.getUint8(at);
+		at += NAME_LENGTH_SIZE;
+		const name = String.fromCharCode(...bytes.subarray(at, at + nameLength));
+		at += nameLength;
+		const unitsPerEm = view.getUint16(at);
+		const glyphCount = view.getUint16(at + 2);
+		at += FACE_HEADER_SIZE;
+		const texts = [];
+		const advances = new Uint16Array(glyphCount);
+		for (let glyphId = 0; glyphId < glyphCount; glyphId++) {
+			const codePointCount = view.getUint8(at);
+			at += CODE_POINT_COUNT_SIZE;
+			const codePoints = [];
+			for (let i = 0; i < codePointCount; i++) {
+				codePoints.push(view.getUint8(at) << 16 | view.getUint16(at + 1));
+				at += CODE_POINT_SIZE;
+			}
+			texts.push(codePoints.length === 0 ? void 0 : String.fromCodePoint(...codePoints));
+			advances[glyphId] = view.getUint16(at);
+			at += ADVANCE_SIZE;
+		}
+		read.set(name, {
+			unitsPerEm,
+			texts,
+			advances
+		});
+	}
+	faces = read;
+	return read;
+}
+/**
+* The glyph order of a core face, checked glyph by glyph against the program that claims to be it.
+* @param postScriptName - the face's PostScript name without any subset tag, as the program's own 'name' table states it or, for a program with none, as the font dictionary's /BaseFont does
+* @param unitsPerEm - the program's own design grid; a program on another grid is not the face, whatever its name
+* @returns a lookup from a glyph id and the program's own advance width for that glyph to the character the face draws there, answering undefined wherever the width disagrees with the face's or the face draws no character; or undefined when the name is not a core face or the grid is not the face's
+*/
+function coreFaceGlyphOrder(postScriptName, unitsPerEm) {
+	const face = readFaces().get(postScriptName);
+	if (face?.unitsPerEm !== unitsPerEm) return;
+	return (glyphId, advanceWidth) => face.advances[glyphId] === advanceWidth ? face.texts[glyphId] : void 0;
+}
+//#endregion
+exports.coreFaceGlyphOrder = coreFaceGlyphOrder;

package/dist/core-font-glyph-orders.d.cts

@@ -0,0 +1,10 @@
+//#region src/core-font-glyph-orders.d.ts
+/**
+ * The glyph order of a core face, checked glyph by glyph against the program that claims to be it.
+ * @param postScriptName - the face's PostScript name without any subset tag, as the program's own 'name' table states it or, for a program with none, as the font dictionary's /BaseFont does
+ * @param unitsPerEm - the program's own design grid; a program on another grid is not the face, whatever its name
+ * @returns a lookup from a glyph id and the program's own advance width for that glyph to the character the face draws there, answering undefined wherever the width disagrees with the face's or the face draws no character; or undefined when the name is not a core face or the grid is not the face's
+ */
+declare function coreFaceGlyphOrder(postScriptName: string, unitsPerEm: number): ((glyphId: number, advanceWidth: number) => string | undefined) | undefined;
+//#endregion
+export { coreFaceGlyphOrder };

package/dist/core-font-glyph-orders.d.ts

@@ -0,0 +1,10 @@
+//#region src/core-font-glyph-orders.d.ts
+/**
+ * The glyph order of a core face, checked glyph by glyph against the program that claims to be it.
+ * @param postScriptName - the face's PostScript name without any subset tag, as the program's own 'name' table states it or, for a program with none, as the font dictionary's /BaseFont does
+ * @param unitsPerEm - the program's own design grid; a program on another grid is not the face, whatever its name
+ * @returns a lookup from a glyph id and the program's own advance width for that glyph to the character the face draws there, answering undefined wherever the width disagrees with the face's or the face draws no character; or undefined when the name is not a core face or the grid is not the face's
+ */
+declare function coreFaceGlyphOrder(postScriptName: string, unitsPerEm: number): ((glyphId: number, advanceWidth: number) => string | undefined) | undefined;
+//#endregion
+export { coreFaceGlyphOrder };

package/dist/core-font-glyph-orders.js

@@ -0,0 +1,61 @@
+import { CORE_FONT_GLYPH_ORDERS_DEFLATED_BASE64 } from "./glyph-data/core-font-glyph-orders.js";
+import { inflateSync } from "fflate";
+import { base64ToBytes } from "byte-codec";
+//#region src/core-font-glyph-orders.ts
+const FACE_COUNT_SIZE = 2;
+const NAME_LENGTH_SIZE = 1;
+const FACE_HEADER_SIZE = 4;
+const CODE_POINT_COUNT_SIZE = 1;
+const CODE_POINT_SIZE = 3;
+const ADVANCE_SIZE = 2;
+let faces;
+function readFaces() {
+	if (faces !== void 0) return faces;
+	const bytes = inflateSync(base64ToBytes(CORE_FONT_GLYPH_ORDERS_DEFLATED_BASE64));
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	const read = /* @__PURE__ */ new Map();
+	let at = FACE_COUNT_SIZE;
+	for (let face = 0; face < view.getUint16(0); face++) {
+		const nameLength = view.getUint8(at);
+		at += NAME_LENGTH_SIZE;
+		const name = String.fromCharCode(...bytes.subarray(at, at + nameLength));
+		at += nameLength;
+		const unitsPerEm = view.getUint16(at);
+		const glyphCount = view.getUint16(at + 2);
+		at += FACE_HEADER_SIZE;
+		const texts = [];
+		const advances = new Uint16Array(glyphCount);
+		for (let glyphId = 0; glyphId < glyphCount; glyphId++) {
+			const codePointCount = view.getUint8(at);
+			at += CODE_POINT_COUNT_SIZE;
+			const codePoints = [];
+			for (let i = 0; i < codePointCount; i++) {
+				codePoints.push(view.getUint8(at) << 16 | view.getUint16(at + 1));
+				at += CODE_POINT_SIZE;
+			}
+			texts.push(codePoints.length === 0 ? void 0 : String.fromCodePoint(...codePoints));
+			advances[glyphId] = view.getUint16(at);
+			at += ADVANCE_SIZE;
+		}
+		read.set(name, {
+			unitsPerEm,
+			texts,
+			advances
+		});
+	}
+	faces = read;
+	return read;
+}
+/**
+* The glyph order of a core face, checked glyph by glyph against the program that claims to be it.
+* @param postScriptName - the face's PostScript name without any subset tag, as the program's own 'name' table states it or, for a program with none, as the font dictionary's /BaseFont does
+* @param unitsPerEm - the program's own design grid; a program on another grid is not the face, whatever its name
+* @returns a lookup from a glyph id and the program's own advance width for that glyph to the character the face draws there, answering undefined wherever the width disagrees with the face's or the face draws no character; or undefined when the name is not a core face or the grid is not the face's
+*/
+function coreFaceGlyphOrder(postScriptName, unitsPerEm) {
+	const face = readFaces().get(postScriptName);
+	if (face?.unitsPerEm !== unitsPerEm) return;
+	return (glyphId, advanceWidth) => face.advances[glyphId] === advanceWidth ? face.texts[glyphId] : void 0;
+}
+//#endregion
+export { coreFaceGlyphOrder };

package/dist/encoding.cjs

@@ -1,6 +1,274 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_afm_widths = require("./afm-widths-sjaRvmQX.cjs");
-exports.WINANSI_GLYPH_NAMES = require_afm_widths.WINANSI_GLYPH_NAMES;
-exports.glyphNameToUnicode = require_afm_widths.glyphNameToUnicode;
-exports.namedEncodingGlyphName = require_afm_widths.namedEncodingGlyphName;
-exports.winAnsiGlyphName = require_afm_widths.winAnsiGlyphName;
+const require_encoding_standard_tables = require("./encoding-standard-tables.cjs");
+//#region src/encoding.ts
+const WINANSI_GLYPH_NAMES = [
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"",
+	"space",
+	"exclam",
+	"quotedbl",
+	"numbersign",
+	"dollar",
+	"percent",
+	"ampersand",
+	"quotesingle",
+	"parenleft",
+	"parenright",
+	"asterisk",
+	"plus",
+	"comma",
+	"hyphen",
+	"period",
+	"slash",
+	"zero",
+	"one",
+	"two",
+	"three",
+	"four",
+	"five",
+	"six",
+	"seven",
+	"eight",
+	"nine",
+	"colon",
+	"semicolon",
+	"less",
+	"equal",
+	"greater",
+	"question",
+	"at",
+	"A",
+	"B",
+	"C",
+	"D",
+	"E",
+	"F",
+	"G",
+	"H",
+	"I",
+	"J",
+	"K",
+	"L",
+	"M",
+	"N",
+	"O",
+	"P",
+	"Q",
+	"R",
+	"S",
+	"T",
+	"U",
+	"V",
+	"W",
+	"X",
+	"Y",
+	"Z",
+	"bracketleft",
+	"backslash",
+	"bracketright",
+	"asciicircum",
+	"underscore",
+	"grave",
+	"a",
+	"b",
+	"c",
+	"d",
+	"e",
+	"f",
+	"g",
+	"h",
+	"i",
+	"j",
+	"k",
+	"l",
+	"m",
+	"n",
+	"o",
+	"p",
+	"q",
+	"r",
+	"s",
+	"t",
+	"u",
+	"v",
+	"w",
+	"x",
+	"y",
+	"z",
+	"braceleft",
+	"bar",
+	"braceright",
+	"asciitilde",
+	"bullet",
+	"Euro",
+	"bullet",
+	"quotesinglbase",
+	"florin",
+	"quotedblbase",
+	"ellipsis",
+	"dagger",
+	"daggerdbl",
+	"circumflex",
+	"perthousand",
+	"Scaron",
+	"guilsinglleft",
+	"OE",
+	"bullet",
+	"Zcaron",
+	"bullet",
+	"bullet",
+	"quoteleft",
+	"quoteright",
+	"quotedblleft",
+	"quotedblright",
+	"bullet",
+	"endash",
+	"emdash",
+	"tilde",
+	"trademark",
+	"scaron",
+	"guilsinglright",
+	"oe",
+	"bullet",
+	"zcaron",
+	"Ydieresis",
+	"space",
+	"exclamdown",
+	"cent",
+	"sterling",
+	"currency",
+	"yen",
+	"brokenbar",
+	"section",
+	"dieresis",
+	"copyright",
+	"ordfeminine",
+	"guillemotleft",
+	"logicalnot",
+	"hyphen",
+	"registered",
+	"macron",
+	"degree",
+	"plusminus",
+	"twosuperior",
+	"threesuperior",
+	"acute",
+	"mu",
+	"paragraph",
+	"periodcentered",
+	"cedilla",
+	"onesuperior",
+	"ordmasculine",
+	"guillemotright",
+	"onequarter",
+	"onehalf",
+	"threequarters",
+	"questiondown",
+	"Agrave",
+	"Aacute",
+	"Acircumflex",
+	"Atilde",
+	"Adieresis",
+	"Aring",
+	"AE",
+	"Ccedilla",
+	"Egrave",
+	"Eacute",
+	"Ecircumflex",
+	"Edieresis",
+	"Igrave",
+	"Iacute",
+	"Icircumflex",
+	"Idieresis",
+	"Eth",
+	"Ntilde",
+	"Ograve",
+	"Oacute",
+	"Ocircumflex",
+	"Otilde",
+	"Odieresis",
+	"multiply",
+	"Oslash",
+	"Ugrave",
+	"Uacute",
+	"Ucircumflex",
+	"Udieresis",
+	"Yacute",
+	"Thorn",
+	"germandbls",
+	"agrave",
+	"aacute",
+	"acircumflex",
+	"atilde",
+	"adieresis",
+	"aring",
+	"ae",
+	"ccedilla",
+	"egrave",
+	"eacute",
+	"ecircumflex",
+	"edieresis",
+	"igrave",
+	"iacute",
+	"icircumflex",
+	"idieresis",
+	"eth",
+	"ntilde",
+	"ograve",
+	"oacute",
+	"ocircumflex",
+	"otilde",
+	"odieresis",
+	"divide",
+	"oslash",
+	"ugrave",
+	"uacute",
+	"ucircumflex",
+	"udieresis",
+	"yacute",
+	"thorn",
+	"ydieresis"
+];
+function winAnsiGlyphName(code) {
+	const name = WINANSI_GLYPH_NAMES[code];
+	return name === void 0 || name === "" ? void 0 : name;
+}
+function namedEncodingGlyphName(encodingName) {
+	if (encodingName === "WinAnsiEncoding") return winAnsiGlyphName;
+	if (encodingName === "MacRomanEncoding") return require_encoding_standard_tables.macRomanGlyphName;
+	if (encodingName === "StandardEncoding") return require_encoding_standard_tables.standardGlyphName;
+}
+//#endregion
+exports.WINANSI_GLYPH_NAMES = WINANSI_GLYPH_NAMES;
+exports.namedEncodingGlyphName = namedEncodingGlyphName;
+exports.winAnsiGlyphName = winAnsiGlyphName;

package/dist/encoding.d.cts

@@ -2,6 +2,5 @@
 declare const WINANSI_GLYPH_NAMES: readonly string[];
 declare function winAnsiGlyphName(code: number): string | undefined;
 declare function namedEncodingGlyphName(encodingName: string): ((code: number) => string | undefined) | undefined;
-declare function glyphNameToUnicode(name: string): number | undefined;
 //#endregion
-export { WINANSI_GLYPH_NAMES, glyphNameToUnicode, namedEncodingGlyphName, winAnsiGlyphName };
+export { WINANSI_GLYPH_NAMES, namedEncodingGlyphName, winAnsiGlyphName };

package/dist/encoding.d.ts

@@ -2,6 +2,5 @@
 declare const WINANSI_GLYPH_NAMES: readonly string[];
 declare function winAnsiGlyphName(code: number): string | undefined;
 declare function namedEncodingGlyphName(encodingName: string): ((code: number) => string | undefined) | undefined;
-declare function glyphNameToUnicode(name: string): number | undefined;
 //#endregion
-export { WINANSI_GLYPH_NAMES, glyphNameToUnicode, namedEncodingGlyphName, winAnsiGlyphName };
+export { WINANSI_GLYPH_NAMES, namedEncodingGlyphName, winAnsiGlyphName };