pdf-parser.js 3.0.8 → 4.5.2

package/dist/builtin-encoding.js

@@ -0,0 +1,220 @@
+import { c as glyphNameToUnicode, d as standardGlyphName } from "./afm-widths-De_QMWgC.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";
+//#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 ? glyphNameToUnicode(name) : void 0) ?? glyphIdToUnicode?.(glyphId);
+	};
+	const codeUnicode = (code) => {
+		const name = codeToName?.(code);
+		if (name !== void 0) {
+			const named = 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 = 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: 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 || !hasBytes(bytes, offset, 1)) return;
+	const format = u8(bytes, offset);
+	let cursor = offset + 1;
+	if (format === 0) {
+		for (let glyphId = 1; glyphId < glyphCount; glyphId++) {
+			if (!hasBytes(bytes, cursor, 2)) return sidByGlyph;
+			sidByGlyph.set(glyphId, 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 (!hasBytes(bytes, cursor, 2 + nLeftSize)) return sidByGlyph;
+		const firstSid = u16(bytes, cursor);
+		const nLeft = format === 1 ? u8(bytes, cursor + 2) : 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 || !hasBytes(bytes, offset, 2)) return;
+	const formatByte = u8(bytes, offset);
+	const format = formatByte & CFF_ENCODING_FORMAT_MASK;
+	const glyphByCode = /* @__PURE__ */ new Map();
+	let cursor = offset + 1;
+	if (format === 0) {
+		const nCodes = u8(bytes, cursor);
+		cursor += 1;
+		for (let i = 0; i < nCodes; i++) {
+			if (!hasBytes(bytes, cursor, 1)) return glyphByCode;
+			const glyphId = i + 1;
+			if (glyphId < glyphCount) glyphByCode.set(u8(bytes, cursor), glyphId);
+			cursor += 1;
+		}
+	} else if (format === 1) {
+		const nRanges = u8(bytes, cursor);
+		cursor += 1;
+		let glyphId = 1;
+		for (let i = 0; i < nRanges; i++) {
+			if (!hasBytes(bytes, cursor, 2)) return glyphByCode;
+			const first = u8(bytes, cursor);
+			const nLeft = 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 (!hasBytes(bytes, cursor, 1)) return glyphByCode;
+		const nSups = u8(bytes, cursor);
+		cursor += 1;
+		for (let i = 0; i < nSups; i++) {
+			if (!hasBytes(bytes, cursor, 3)) return glyphByCode;
+			const glyphId = glyphBySid.get(u16(bytes, cursor + 1));
+			if (glyphId !== void 0) glyphByCode.set(u8(bytes, cursor), glyphId);
+			cursor += 3;
+		}
+	}
+	return glyphByCode;
+}
+function cffSources(bytes, predefinedEncodingApplies) {
+	if (!hasBytes(bytes, 0, CFF_HEADER_SIZE)) return;
+	const headerSize = u8(bytes, 2);
+	if (u8(bytes, 0) !== CFF_MAJOR_VERSION || headerSize < CFF_HEADER_SIZE) return;
+	const nameIndex = readCffIndex(bytes, headerSize);
+	if (nameIndex === void 0) return;
+	const topDictIndex = readCffIndex(bytes, nameIndex.endOffset);
+	const topDictBytes = topDictIndex?.entry(0);
+	if (topDictIndex === void 0 || topDictBytes === void 0) return;
+	const topDict = parseCffDict(topDictBytes);
+	if (topDict === void 0 || topDict.has(1230)) return;
+	const stringIndex = readCffIndex(bytes, topDictIndex.endOffset);
+	const charStringsOffset = topDict.get(17)?.[0];
+	const glyphCount = charStringsOffset === void 0 ? void 0 : 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 : cffStringForSid(sid, stringIndex);
+	};
+	const encodingOffset = topDict.get(16)?.[0] ?? CFF_PREDEFINED_ENCODING_STANDARD;
+	if (encodingOffset === CFF_PREDEFINED_ENCODING_STANDARD) return predefinedEncodingApplies ? {
+		codeToName: 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: 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 = parseSfnt(program);
+	if (font !== void 0) {
+		const cff = 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
+export { readFontProgramEncoding };

package/dist/bytes/flate.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_bytes_reader = require("./reader.cjs");
 const require_bytes_writer = require("./writer.cjs");
+const require_bytes_reader = require("./reader.cjs");
 let fflate = require("fflate");
 //#region src/bytes/flate.ts
 const MAX_INFLATE_OUTPUT_BYTES = 536870912;

package/dist/bytes/flate.js

@@ -1,5 +1,5 @@
-import { isAsciiWhitespace } from "./reader.js";
 import { concatBytes } from "./writer.js";
+import { isAsciiWhitespace } from "./reader.js";
 import { Unzlib, inflateSync, unzlibSync, zlibSync } from "fflate";
 //#region src/bytes/flate.ts
 const MAX_INFLATE_OUTPUT_BYTES = 536870912;

package/dist/cff.cjs

@@ -3,6 +3,7 @@ const require_sfnt = require("./sfnt.cjs");
 //#region src/cff.ts
 const CFF_ESCAPED_OPERATOR_BASE = 1200;
 const CFF_DICT_OP_CHARSET = 15;
+const CFF_DICT_OP_ENCODING = 16;
 const CFF_DICT_OP_CHARSTRINGS = 17;
 const CFF_DICT_OP_PRIVATE = 18;
 const CFF_DICT_OP_SUBRS = 19;
@@ -147,12 +148,25 @@ function parseCffDict(data) {
 	}
 	return dict;
 }
+const CFF_STANDARD_STRINGS = ".notdef space exclam quotedbl numbersign dollar percent ampersand quoteright 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 quoteleft 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 exclamdown cent sterling fraction yen florin section currency quotesingle quotedblleft guillemotleft guilsinglleft guilsinglright fi fl endash dagger daggerdbl periodcentered paragraph bullet quotesinglbase quotedblbase quotedblright guillemotright ellipsis perthousand questiondown grave acute circumflex tilde macron breve dotaccent dieresis ring cedilla hungarumlaut ogonek caron emdash AE ordfeminine Lslash Oslash OE ordmasculine ae dotlessi lslash oslash oe germandbls onesuperior logicalnot mu trademark Eth onehalf plusminus Thorn onequarter divide brokenbar degree thorn threequarters twosuperior registered minus eth multiply threesuperior copyright Aacute Acircumflex Adieresis Agrave Aring Atilde Ccedilla Eacute Ecircumflex Edieresis Egrave Iacute Icircumflex Idieresis Igrave Ntilde Oacute Ocircumflex Odieresis Ograve Otilde Scaron Uacute Ucircumflex Udieresis Ugrave Yacute Ydieresis Zcaron aacute acircumflex adieresis agrave aring atilde ccedilla eacute ecircumflex edieresis egrave iacute icircumflex idieresis igrave ntilde oacute ocircumflex odieresis ograve otilde scaron uacute ucircumflex udieresis ugrave yacute ydieresis zcaron exclamsmall Hungarumlautsmall dollaroldstyle dollarsuperior ampersandsmall Acutesmall parenleftsuperior parenrightsuperior twodotenleader onedotenleader zerooldstyle oneoldstyle twooldstyle threeoldstyle fouroldstyle fiveoldstyle sixoldstyle sevenoldstyle eightoldstyle nineoldstyle commasuperior threequartersemdash periodsuperior questionsmall asuperior bsuperior centsuperior dsuperior esuperior isuperior lsuperior msuperior nsuperior osuperior rsuperior ssuperior tsuperior ff ffi ffl parenleftinferior parenrightinferior Circumflexsmall hyphensuperior Gravesmall Asmall Bsmall Csmall Dsmall Esmall Fsmall Gsmall Hsmall Ismall Jsmall Ksmall Lsmall Msmall Nsmall Osmall Psmall Qsmall Rsmall Ssmall Tsmall Usmall Vsmall Wsmall Xsmall Ysmall Zsmall colonmonetary onefitted rupiah Tildesmall exclamdownsmall centoldstyle Lslashsmall Scaronsmall Zcaronsmall Dieresissmall Brevesmall Caronsmall Dotaccentsmall Macronsmall figuredash hypheninferior Ogoneksmall Ringsmall Cedillasmall questiondownsmall oneeighth threeeighths fiveeighths seveneighths onethird twothirds zerosuperior foursuperior fivesuperior sixsuperior sevensuperior eightsuperior ninesuperior zeroinferior oneinferior twoinferior threeinferior fourinferior fiveinferior sixinferior seveninferior eightinferior nineinferior centinferior dollarinferior periodinferior commainferior Agravesmall Aacutesmall Acircumflexsmall Atildesmall Adieresissmall Aringsmall AEsmall Ccedillasmall Egravesmall Eacutesmall Ecircumflexsmall Edieresissmall Igravesmall Iacutesmall Icircumflexsmall Idieresissmall Ethsmall Ntildesmall Ogravesmall Oacutesmall Ocircumflexsmall Otildesmall Odieresissmall OEsmall Oslashsmall Ugravesmall Uacutesmall Ucircumflexsmall Udieresissmall Yacutesmall Thornsmall Ydieresissmall 001.000 001.001 001.002 001.003 Black Bold Book Light Medium Regular Roman Semibold".split(" ");
+function cffStringForSid(sid, stringIndex) {
+	const standard = CFF_STANDARD_STRINGS[sid];
+	if (standard !== void 0) return standard;
+	const entry = stringIndex?.entry(sid - CFF_STANDARD_STRINGS.length);
+	if (entry === void 0) return;
+	let text = "";
+	for (const byte of entry) text += String.fromCharCode(byte);
+	return text;
+}
 //#endregion
 exports.CFF_DICT_OP_CHARSET = CFF_DICT_OP_CHARSET;
 exports.CFF_DICT_OP_CHARSTRINGS = CFF_DICT_OP_CHARSTRINGS;
+exports.CFF_DICT_OP_ENCODING = CFF_DICT_OP_ENCODING;
 exports.CFF_DICT_OP_PRIVATE = CFF_DICT_OP_PRIVATE;
 exports.CFF_DICT_OP_ROS = CFF_DICT_OP_ROS;
 exports.CFF_DICT_OP_SUBRS = CFF_DICT_OP_SUBRS;
 exports.CFF_ESCAPED_OPERATOR_BASE = CFF_ESCAPED_OPERATOR_BASE;
+exports.CFF_STANDARD_STRINGS = CFF_STANDARD_STRINGS;
+exports.cffStringForSid = cffStringForSid;
 exports.parseCffDict = parseCffDict;
 exports.readCffIndex = readCffIndex;

package/dist/cff.d.cts

@@ -7,11 +7,14 @@ interface CffIndex {
 type CffDict = ReadonlyMap<number, readonly number[]>;
 declare const CFF_ESCAPED_OPERATOR_BASE = 1200;
 declare const CFF_DICT_OP_CHARSET = 15;
+declare const CFF_DICT_OP_ENCODING = 16;
 declare const CFF_DICT_OP_CHARSTRINGS = 17;
 declare const CFF_DICT_OP_PRIVATE = 18;
 declare const CFF_DICT_OP_SUBRS = 19;
 declare const CFF_DICT_OP_ROS: number;
 declare function readCffIndex(bytes: Uint8Array<ArrayBuffer>, offset: number): CffIndex | undefined;
 declare function parseCffDict(data: Uint8Array<ArrayBuffer>): CffDict | undefined;
+declare const CFF_STANDARD_STRINGS: readonly string[];
+declare function cffStringForSid(sid: number, stringIndex: CffIndex | undefined): string | undefined;
 //#endregion
-export { CFF_DICT_OP_CHARSET, CFF_DICT_OP_CHARSTRINGS, CFF_DICT_OP_PRIVATE, CFF_DICT_OP_ROS, CFF_DICT_OP_SUBRS, CFF_ESCAPED_OPERATOR_BASE, CffDict, CffIndex, parseCffDict, readCffIndex };
+export { CFF_DICT_OP_CHARSET, CFF_DICT_OP_CHARSTRINGS, CFF_DICT_OP_ENCODING, CFF_DICT_OP_PRIVATE, CFF_DICT_OP_ROS, CFF_DICT_OP_SUBRS, CFF_ESCAPED_OPERATOR_BASE, CFF_STANDARD_STRINGS, CffDict, CffIndex, cffStringForSid, parseCffDict, readCffIndex };

package/dist/cff.d.ts

@@ -7,11 +7,14 @@ interface CffIndex {
 type CffDict = ReadonlyMap<number, readonly number[]>;
 declare const CFF_ESCAPED_OPERATOR_BASE = 1200;
 declare const CFF_DICT_OP_CHARSET = 15;
+declare const CFF_DICT_OP_ENCODING = 16;
 declare const CFF_DICT_OP_CHARSTRINGS = 17;
 declare const CFF_DICT_OP_PRIVATE = 18;
 declare const CFF_DICT_OP_SUBRS = 19;
 declare const CFF_DICT_OP_ROS: number;
 declare function readCffIndex(bytes: Uint8Array<ArrayBuffer>, offset: number): CffIndex | undefined;
 declare function parseCffDict(data: Uint8Array<ArrayBuffer>): CffDict | undefined;
+declare const CFF_STANDARD_STRINGS: readonly string[];
+declare function cffStringForSid(sid: number, stringIndex: CffIndex | undefined): string | undefined;
 //#endregion
-export { CFF_DICT_OP_CHARSET, CFF_DICT_OP_CHARSTRINGS, CFF_DICT_OP_PRIVATE, CFF_DICT_OP_ROS, CFF_DICT_OP_SUBRS, CFF_ESCAPED_OPERATOR_BASE, CffDict, CffIndex, parseCffDict, readCffIndex };
+export { CFF_DICT_OP_CHARSET, CFF_DICT_OP_CHARSTRINGS, CFF_DICT_OP_ENCODING, CFF_DICT_OP_PRIVATE, CFF_DICT_OP_ROS, CFF_DICT_OP_SUBRS, CFF_ESCAPED_OPERATOR_BASE, CFF_STANDARD_STRINGS, CffDict, CffIndex, cffStringForSid, parseCffDict, readCffIndex };

package/dist/cff.js

@@ -2,6 +2,7 @@ import { hasBytes, u16, u24, u32, u8 } from "./sfnt.js";
 //#region src/cff.ts
 const CFF_ESCAPED_OPERATOR_BASE = 1200;
 const CFF_DICT_OP_CHARSET = 15;
+const CFF_DICT_OP_ENCODING = 16;
 const CFF_DICT_OP_CHARSTRINGS = 17;
 const CFF_DICT_OP_PRIVATE = 18;
 const CFF_DICT_OP_SUBRS = 19;
@@ -146,5 +147,15 @@ function parseCffDict(data) {
 	}
 	return dict;
 }
+const CFF_STANDARD_STRINGS = ".notdef space exclam quotedbl numbersign dollar percent ampersand quoteright 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 quoteleft 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 exclamdown cent sterling fraction yen florin section currency quotesingle quotedblleft guillemotleft guilsinglleft guilsinglright fi fl endash dagger daggerdbl periodcentered paragraph bullet quotesinglbase quotedblbase quotedblright guillemotright ellipsis perthousand questiondown grave acute circumflex tilde macron breve dotaccent dieresis ring cedilla hungarumlaut ogonek caron emdash AE ordfeminine Lslash Oslash OE ordmasculine ae dotlessi lslash oslash oe germandbls onesuperior logicalnot mu trademark Eth onehalf plusminus Thorn onequarter divide brokenbar degree thorn threequarters twosuperior registered minus eth multiply threesuperior copyright Aacute Acircumflex Adieresis Agrave Aring Atilde Ccedilla Eacute Ecircumflex Edieresis Egrave Iacute Icircumflex Idieresis Igrave Ntilde Oacute Ocircumflex Odieresis Ograve Otilde Scaron Uacute Ucircumflex Udieresis Ugrave Yacute Ydieresis Zcaron aacute acircumflex adieresis agrave aring atilde ccedilla eacute ecircumflex edieresis egrave iacute icircumflex idieresis igrave ntilde oacute ocircumflex odieresis ograve otilde scaron uacute ucircumflex udieresis ugrave yacute ydieresis zcaron exclamsmall Hungarumlautsmall dollaroldstyle dollarsuperior ampersandsmall Acutesmall parenleftsuperior parenrightsuperior twodotenleader onedotenleader zerooldstyle oneoldstyle twooldstyle threeoldstyle fouroldstyle fiveoldstyle sixoldstyle sevenoldstyle eightoldstyle nineoldstyle commasuperior threequartersemdash periodsuperior questionsmall asuperior bsuperior centsuperior dsuperior esuperior isuperior lsuperior msuperior nsuperior osuperior rsuperior ssuperior tsuperior ff ffi ffl parenleftinferior parenrightinferior Circumflexsmall hyphensuperior Gravesmall Asmall Bsmall Csmall Dsmall Esmall Fsmall Gsmall Hsmall Ismall Jsmall Ksmall Lsmall Msmall Nsmall Osmall Psmall Qsmall Rsmall Ssmall Tsmall Usmall Vsmall Wsmall Xsmall Ysmall Zsmall colonmonetary onefitted rupiah Tildesmall exclamdownsmall centoldstyle Lslashsmall Scaronsmall Zcaronsmall Dieresissmall Brevesmall Caronsmall Dotaccentsmall Macronsmall figuredash hypheninferior Ogoneksmall Ringsmall Cedillasmall questiondownsmall oneeighth threeeighths fiveeighths seveneighths onethird twothirds zerosuperior foursuperior fivesuperior sixsuperior sevensuperior eightsuperior ninesuperior zeroinferior oneinferior twoinferior threeinferior fourinferior fiveinferior sixinferior seveninferior eightinferior nineinferior centinferior dollarinferior periodinferior commainferior Agravesmall Aacutesmall Acircumflexsmall Atildesmall Adieresissmall Aringsmall AEsmall Ccedillasmall Egravesmall Eacutesmall Ecircumflexsmall Edieresissmall Igravesmall Iacutesmall Icircumflexsmall Idieresissmall Ethsmall Ntildesmall Ogravesmall Oacutesmall Ocircumflexsmall Otildesmall Odieresissmall OEsmall Oslashsmall Ugravesmall Uacutesmall Ucircumflexsmall Udieresissmall Yacutesmall Thornsmall Ydieresissmall 001.000 001.001 001.002 001.003 Black Bold Book Light Medium Regular Roman Semibold".split(" ");
+function cffStringForSid(sid, stringIndex) {
+	const standard = CFF_STANDARD_STRINGS[sid];
+	if (standard !== void 0) return standard;
+	const entry = stringIndex?.entry(sid - CFF_STANDARD_STRINGS.length);
+	if (entry === void 0) return;
+	let text = "";
+	for (const byte of entry) text += String.fromCharCode(byte);
+	return text;
+}
 //#endregion
-export { CFF_DICT_OP_CHARSET, CFF_DICT_OP_CHARSTRINGS, CFF_DICT_OP_PRIVATE, CFF_DICT_OP_ROS, CFF_DICT_OP_SUBRS, CFF_ESCAPED_OPERATOR_BASE, parseCffDict, readCffIndex };
+export { CFF_DICT_OP_CHARSET, CFF_DICT_OP_CHARSTRINGS, CFF_DICT_OP_ENCODING, CFF_DICT_OP_PRIVATE, CFF_DICT_OP_ROS, CFF_DICT_OP_SUBRS, CFF_ESCAPED_OPERATOR_BASE, CFF_STANDARD_STRINGS, cffStringForSid, parseCffDict, readCffIndex };

package/dist/cmap-table.cjs

@@ -3,6 +3,7 @@ const require_sfnt = require("./sfnt.cjs");
 //#region src/cmap-table.ts
 const CMAP_HEADER_SIZE = 4;
 const SUBTABLE_RECORD_SIZE = 8;
+const MAX_UNICODE_CODE_POINT = 1114111;
 const FORMAT_4_HEADER_SIZE = 14;
 function parseFormat4(bytes, subtableOffset) {
 	if (!require_sfnt.hasBytes(bytes, subtableOffset, FORMAT_4_HEADER_SIZE)) return;
@@ -26,7 +27,7 @@ function parseFormat4(bytes, subtableOffset) {
 			idRangeOffset: require_sfnt.u16(bytes, idRangeOffsetPos)
 		});
 	}
-	return (codePoint) => {
+	const lookup = (codePoint) => {
 		if (codePoint > 65535) return;
 		for (const segment of segments) {
 			if (codePoint < segment.startCode || codePoint > segment.endCode) continue;
@@ -37,6 +38,18 @@ function parseFormat4(bytes, subtableOffset) {
 			return glyphId === 0 ? void 0 : glyphId + segment.idDelta & 65535;
 		}
 	};
+	return {
+		lookup,
+		forEachMapping(visit) {
+			for (const segment of segments) {
+				const end = Math.min(segment.endCode, 65534);
+				for (let code = segment.startCode; code <= end; code++) {
+					const glyphId = lookup(code);
+					if (glyphId !== void 0 && glyphId !== 0) visit(code, glyphId);
+				}
+			}
+		}
+	};
 }
 const FORMAT_12_HEADER_SIZE = 16;
 const FORMAT_12_GROUP_SIZE = 12;
@@ -54,8 +67,35 @@ function parseFormat12(bytes, subtableOffset) {
 			startGlyphId: require_sfnt.u32(bytes, recordOffset + 8)
 		});
 	}
-	return (codePoint) => {
-		for (const group of groups) if (codePoint >= group.startCharCode && codePoint <= group.endCharCode) return group.startGlyphId + (codePoint - group.startCharCode);
+	return {
+		lookup(codePoint) {
+			for (const group of groups) if (codePoint >= group.startCharCode && codePoint <= group.endCharCode) return group.startGlyphId + (codePoint - group.startCharCode);
+		},
+		forEachMapping(visit) {
+			for (const group of groups) {
+				const end = Math.min(group.endCharCode, MAX_UNICODE_CODE_POINT);
+				for (let code = group.startCharCode; code <= end; code++) visit(code, group.startGlyphId + (code - group.startCharCode));
+			}
+		}
+	};
+}
+const FORMAT_0_SIZE = 262;
+function parseFormat0(bytes, subtableOffset) {
+	if (!require_sfnt.hasBytes(bytes, subtableOffset, FORMAT_0_SIZE)) return;
+	const glyphIdArrayOffset = subtableOffset + 6;
+	const lookup = (codePoint) => {
+		if (codePoint < 0 || codePoint > 255) return;
+		const glyphId = require_sfnt.u8(bytes, glyphIdArrayOffset + codePoint);
+		return glyphId === 0 ? void 0 : glyphId;
+	};
+	return {
+		lookup,
+		forEachMapping(visit) {
+			for (let code = 0; code <= 255; code++) {
+				const glyphId = lookup(code);
+				if (glyphId !== void 0) visit(code, glyphId);
+			}
+		}
 	};
 }
 const FORMAT_6_HEADER_SIZE = 10;
@@ -65,12 +105,22 @@ function parseFormat6(bytes, subtableOffset) {
 	const entryCount = require_sfnt.u16(bytes, subtableOffset + 8);
 	const glyphIdArrayOffset = subtableOffset + FORMAT_6_HEADER_SIZE;
 	if (!require_sfnt.hasBytes(bytes, glyphIdArrayOffset, entryCount * 2)) return;
-	return (codePoint) => {
+	const lookup = (codePoint) => {
 		const index = codePoint - firstCode;
 		if (index < 0 || index >= entryCount) return;
 		const glyphId = require_sfnt.u16(bytes, glyphIdArrayOffset + index * 2);
 		return glyphId === 0 ? void 0 : glyphId;
 	};
+	return {
+		lookup,
+		forEachMapping(visit) {
+			for (let index = 0; index < entryCount; index++) {
+				const code = firstCode + index;
+				const glyphId = lookup(code);
+				if (glyphId !== void 0) visit(code, glyphId);
+			}
+		}
+	};
 }
 function preferenceRank(subtable) {
 	if (subtable.format === 12) {
@@ -81,28 +131,41 @@ function preferenceRank(subtable) {
 	if (subtable.format === 4) return subtable.platformId === 3 && subtable.encodingId === 1 ? 3 : 4;
 	return 5;
 }
-function buildCmapLookup(font) {
+function parseSubtable(bytes, record) {
+	if (record.format === 12) return parseFormat12(bytes, record.offset);
+	if (record.format === 4) return parseFormat4(bytes, record.offset);
+	if (record.format === 6) return parseFormat6(bytes, record.offset);
+	return record.format === 0 ? parseFormat0(bytes, record.offset) : void 0;
+}
+function readCmapSubtables(font) {
 	const cmapBytes = require_sfnt.sfntTableBytes(font, "cmap");
-	if (cmapBytes === void 0 || !require_sfnt.hasBytes(cmapBytes, 0, CMAP_HEADER_SIZE)) return;
+	if (cmapBytes === void 0 || !require_sfnt.hasBytes(cmapBytes, 0, CMAP_HEADER_SIZE)) return [];
 	const numTables = require_sfnt.u16(cmapBytes, 2);
-	if (!require_sfnt.hasBytes(cmapBytes, CMAP_HEADER_SIZE, numTables * SUBTABLE_RECORD_SIZE)) return;
+	if (!require_sfnt.hasBytes(cmapBytes, CMAP_HEADER_SIZE, numTables * SUBTABLE_RECORD_SIZE)) return [];
 	const subtables = [];
 	for (let i = 0; i < numTables; i++) {
 		const recordOffset = CMAP_HEADER_SIZE + i * SUBTABLE_RECORD_SIZE;
 		const offset = require_sfnt.u32(cmapBytes, recordOffset + 4);
 		if (!require_sfnt.hasBytes(cmapBytes, offset, 2)) continue;
-		subtables.push({
+		const record = {
 			platformId: require_sfnt.u16(cmapBytes, recordOffset),
 			encodingId: require_sfnt.u16(cmapBytes, recordOffset + 2),
 			offset,
 			format: require_sfnt.u16(cmapBytes, offset)
+		};
+		const parsed = parseSubtable(cmapBytes, record);
+		if (parsed !== void 0) subtables.push({
+			platformId: record.platformId,
+			encodingId: record.encodingId,
+			format: record.format,
+			...parsed
 		});
 	}
-	const candidates = subtables.filter((s) => s.format === 4 || s.format === 6 || s.format === 12).sort((a, b) => preferenceRank(a) - preferenceRank(b));
-	for (const candidate of candidates) {
-		const lookup = candidate.format === 12 ? parseFormat12(cmapBytes, candidate.offset) : candidate.format === 4 ? parseFormat4(cmapBytes, candidate.offset) : parseFormat6(cmapBytes, candidate.offset);
-		if (lookup !== void 0) return lookup;
-	}
+	return subtables;
+}
+function buildCmapLookup(font) {
+	return readCmapSubtables(font).filter((s) => s.format === 4 || s.format === 6 || s.format === 12).sort((a, b) => preferenceRank(a) - preferenceRank(b))[0]?.lookup;
 }
 //#endregion
 exports.buildCmapLookup = buildCmapLookup;
+exports.readCmapSubtables = readCmapSubtables;

package/dist/cmap-table.d.cts

@@ -1,6 +1,14 @@
 import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
 //#region src/cmap-table.d.ts
 type CmapLookup = (codePoint: number) => number | undefined;
+interface CmapSubtable {
+  readonly platformId: number;
+  readonly encodingId: number;
+  readonly format: number;
+  readonly lookup: CmapLookup;
+  forEachMapping(visit: (code: number, glyphId: number) => void): void;
+}
+declare function readCmapSubtables(font: SfntFont): readonly CmapSubtable[];
 declare function buildCmapLookup(font: SfntFont): CmapLookup | undefined;
 //#endregion
-export { CmapLookup, buildCmapLookup };
+export { CmapLookup, CmapSubtable, buildCmapLookup, readCmapSubtables };

package/dist/cmap-table.d.ts

@@ -1,6 +1,14 @@
 import { t as SfntFont } from "./sfnt-V08bb5ut.js";
 //#region src/cmap-table.d.ts
 type CmapLookup = (codePoint: number) => number | undefined;
+interface CmapSubtable {
+  readonly platformId: number;
+  readonly encodingId: number;
+  readonly format: number;
+  readonly lookup: CmapLookup;
+  forEachMapping(visit: (code: number, glyphId: number) => void): void;
+}
+declare function readCmapSubtables(font: SfntFont): readonly CmapSubtable[];
 declare function buildCmapLookup(font: SfntFont): CmapLookup | undefined;
 //#endregion
-export { CmapLookup, buildCmapLookup };
+export { CmapLookup, CmapSubtable, buildCmapLookup, readCmapSubtables };

package/dist/cmap-table.js

@@ -1,7 +1,8 @@
-import { hasBytes, sfntTableBytes, u16, u32 } from "./sfnt.js";
+import { hasBytes, sfntTableBytes, u16, u32, u8 } from "./sfnt.js";
 //#region src/cmap-table.ts
 const CMAP_HEADER_SIZE = 4;
 const SUBTABLE_RECORD_SIZE = 8;
+const MAX_UNICODE_CODE_POINT = 1114111;
 const FORMAT_4_HEADER_SIZE = 14;
 function parseFormat4(bytes, subtableOffset) {
 	if (!hasBytes(bytes, subtableOffset, FORMAT_4_HEADER_SIZE)) return;
@@ -25,7 +26,7 @@ function parseFormat4(bytes, subtableOffset) {
 			idRangeOffset: u16(bytes, idRangeOffsetPos)
 		});
 	}
-	return (codePoint) => {
+	const lookup = (codePoint) => {
 		if (codePoint > 65535) return;
 		for (const segment of segments) {
 			if (codePoint < segment.startCode || codePoint > segment.endCode) continue;
@@ -36,6 +37,18 @@ function parseFormat4(bytes, subtableOffset) {
 			return glyphId === 0 ? void 0 : glyphId + segment.idDelta & 65535;
 		}
 	};
+	return {
+		lookup,
+		forEachMapping(visit) {
+			for (const segment of segments) {
+				const end = Math.min(segment.endCode, 65534);
+				for (let code = segment.startCode; code <= end; code++) {
+					const glyphId = lookup(code);
+					if (glyphId !== void 0 && glyphId !== 0) visit(code, glyphId);
+				}
+			}
+		}
+	};
 }
 const FORMAT_12_HEADER_SIZE = 16;
 const FORMAT_12_GROUP_SIZE = 12;
@@ -53,8 +66,35 @@ function parseFormat12(bytes, subtableOffset) {
 			startGlyphId: u32(bytes, recordOffset + 8)
 		});
 	}
-	return (codePoint) => {
-		for (const group of groups) if (codePoint >= group.startCharCode && codePoint <= group.endCharCode) return group.startGlyphId + (codePoint - group.startCharCode);
+	return {
+		lookup(codePoint) {
+			for (const group of groups) if (codePoint >= group.startCharCode && codePoint <= group.endCharCode) return group.startGlyphId + (codePoint - group.startCharCode);
+		},
+		forEachMapping(visit) {
+			for (const group of groups) {
+				const end = Math.min(group.endCharCode, MAX_UNICODE_CODE_POINT);
+				for (let code = group.startCharCode; code <= end; code++) visit(code, group.startGlyphId + (code - group.startCharCode));
+			}
+		}
+	};
+}
+const FORMAT_0_SIZE = 262;
+function parseFormat0(bytes, subtableOffset) {
+	if (!hasBytes(bytes, subtableOffset, FORMAT_0_SIZE)) return;
+	const glyphIdArrayOffset = subtableOffset + 6;
+	const lookup = (codePoint) => {
+		if (codePoint < 0 || codePoint > 255) return;
+		const glyphId = u8(bytes, glyphIdArrayOffset + codePoint);
+		return glyphId === 0 ? void 0 : glyphId;
+	};
+	return {
+		lookup,
+		forEachMapping(visit) {
+			for (let code = 0; code <= 255; code++) {
+				const glyphId = lookup(code);
+				if (glyphId !== void 0) visit(code, glyphId);
+			}
+		}
 	};
 }
 const FORMAT_6_HEADER_SIZE = 10;
@@ -64,12 +104,22 @@ function parseFormat6(bytes, subtableOffset) {
 	const entryCount = u16(bytes, subtableOffset + 8);
 	const glyphIdArrayOffset = subtableOffset + FORMAT_6_HEADER_SIZE;
 	if (!hasBytes(bytes, glyphIdArrayOffset, entryCount * 2)) return;
-	return (codePoint) => {
+	const lookup = (codePoint) => {
 		const index = codePoint - firstCode;
 		if (index < 0 || index >= entryCount) return;
 		const glyphId = u16(bytes, glyphIdArrayOffset + index * 2);
 		return glyphId === 0 ? void 0 : glyphId;
 	};
+	return {
+		lookup,
+		forEachMapping(visit) {
+			for (let index = 0; index < entryCount; index++) {
+				const code = firstCode + index;
+				const glyphId = lookup(code);
+				if (glyphId !== void 0) visit(code, glyphId);
+			}
+		}
+	};
 }
 function preferenceRank(subtable) {
 	if (subtable.format === 12) {
@@ -80,28 +130,40 @@ function preferenceRank(subtable) {
 	if (subtable.format === 4) return subtable.platformId === 3 && subtable.encodingId === 1 ? 3 : 4;
 	return 5;
 }
-function buildCmapLookup(font) {
+function parseSubtable(bytes, record) {
+	if (record.format === 12) return parseFormat12(bytes, record.offset);
+	if (record.format === 4) return parseFormat4(bytes, record.offset);
+	if (record.format === 6) return parseFormat6(bytes, record.offset);
+	return record.format === 0 ? parseFormat0(bytes, record.offset) : void 0;
+}
+function readCmapSubtables(font) {
 	const cmapBytes = sfntTableBytes(font, "cmap");
-	if (cmapBytes === void 0 || !hasBytes(cmapBytes, 0, CMAP_HEADER_SIZE)) return;
+	if (cmapBytes === void 0 || !hasBytes(cmapBytes, 0, CMAP_HEADER_SIZE)) return [];
 	const numTables = u16(cmapBytes, 2);
-	if (!hasBytes(cmapBytes, CMAP_HEADER_SIZE, numTables * SUBTABLE_RECORD_SIZE)) return;
+	if (!hasBytes(cmapBytes, CMAP_HEADER_SIZE, numTables * SUBTABLE_RECORD_SIZE)) return [];
 	const subtables = [];
 	for (let i = 0; i < numTables; i++) {
 		const recordOffset = CMAP_HEADER_SIZE + i * SUBTABLE_RECORD_SIZE;
 		const offset = u32(cmapBytes, recordOffset + 4);
 		if (!hasBytes(cmapBytes, offset, 2)) continue;
-		subtables.push({
+		const record = {
 			platformId: u16(cmapBytes, recordOffset),
 			encodingId: u16(cmapBytes, recordOffset + 2),
 			offset,
 			format: u16(cmapBytes, offset)
+		};
+		const parsed = parseSubtable(cmapBytes, record);
+		if (parsed !== void 0) subtables.push({
+			platformId: record.platformId,
+			encodingId: record.encodingId,
+			format: record.format,
+			...parsed
 		});
 	}
-	const candidates = subtables.filter((s) => s.format === 4 || s.format === 6 || s.format === 12).sort((a, b) => preferenceRank(a) - preferenceRank(b));
-	for (const candidate of candidates) {
-		const lookup = candidate.format === 12 ? parseFormat12(cmapBytes, candidate.offset) : candidate.format === 4 ? parseFormat4(cmapBytes, candidate.offset) : parseFormat6(cmapBytes, candidate.offset);
-		if (lookup !== void 0) return lookup;
-	}
+	return subtables;
+}
+function buildCmapLookup(font) {
+	return readCmapSubtables(font).filter((s) => s.format === 4 || s.format === 6 || s.format === 12).sort((a, b) => preferenceRank(a) - preferenceRank(b))[0]?.lookup;
 }
 //#endregion
-export { buildCmapLookup };
+export { buildCmapLookup, readCmapSubtables };