pdf-codec 1.4.2 → 1.6.0

package/dist/cff-probe.cjs

@@ -0,0 +1,133 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/cff-probe.ts
+const CFF_HEADER_SIZE = 4;
+const CFF_MAJOR_VERSION = 1;
+const INDEX_COUNT_SIZE = 2;
+const INDEX_OFF_SIZE_SIZE = 1;
+const MIN_OFF_SIZE = 1;
+const MAX_OFF_SIZE = 4;
+const DICT_OPERATOR_MAX = 21;
+const DICT_OPERATOR_ESCAPE = 12;
+const DICT_ROS_ESCAPED_OPERATOR = 30;
+const DICT_OPERAND_INT16 = 28;
+const DICT_OPERAND_INT32 = 29;
+const DICT_OPERAND_REAL = 30;
+const DICT_OPERAND_INT16_SIZE = 3;
+const DICT_OPERAND_INT32_SIZE = 5;
+const DICT_OPERAND_SMALL_FIRST = 32;
+const DICT_OPERAND_SMALL_LAST = 246;
+const DICT_OPERAND_MEDIUM_FIRST = 247;
+const DICT_OPERAND_MEDIUM_LAST = 254;
+const DICT_OPERAND_MEDIUM_SIZE = 2;
+const DICT_REAL_TERMINATOR_NIBBLE = 15;
+function readOffsetAt(bytes, offset, offSize) {
+	if (offSize === 1) return require_sfnt.u8(bytes, offset);
+	if (offSize === 2) return require_sfnt.u16(bytes, offset);
+	if (offSize === 3) return require_sfnt.u24(bytes, offset);
+	return require_sfnt.u32(bytes, offset);
+}
+function readIndex(bytes, offset) {
+	if (!require_sfnt.hasBytes(bytes, offset, INDEX_COUNT_SIZE)) return;
+	const count = require_sfnt.u16(bytes, offset);
+	if (count === 0) return {
+		count: 0,
+		endOffset: offset + INDEX_COUNT_SIZE,
+		entry: () => void 0
+	};
+	if (!require_sfnt.hasBytes(bytes, offset + INDEX_COUNT_SIZE, INDEX_OFF_SIZE_SIZE)) return;
+	const offSize = require_sfnt.u8(bytes, offset + INDEX_COUNT_SIZE);
+	if (offSize < MIN_OFF_SIZE || offSize > MAX_OFF_SIZE) return;
+	const offsetArrayStart = offset + INDEX_COUNT_SIZE + INDEX_OFF_SIZE_SIZE;
+	const offsetArrayLength = (count + 1) * offSize;
+	if (!require_sfnt.hasBytes(bytes, offsetArrayStart, offsetArrayLength)) return;
+	const offsets = [];
+	for (let i = 0; i <= count; i++) offsets.push(readOffsetAt(bytes, offsetArrayStart + i * offSize, offSize));
+	if (offsets[0] !== 1) return;
+	for (let i = 1; i <= count; i++) if (offsets[i] < offsets[i - 1]) return;
+	const dataOrigin = offsetArrayStart + offsetArrayLength - 1;
+	const dataLength = offsets[count] - 1;
+	if (!require_sfnt.hasBytes(bytes, dataOrigin + 1, dataLength)) return;
+	return {
+		count,
+		endOffset: dataOrigin + 1 + dataLength,
+		entry: (index) => index < 0 || index >= count ? void 0 : bytes.subarray(dataOrigin + offsets[index], dataOrigin + offsets[index + 1])
+	};
+}
+function dictDeclaresRos(data) {
+	let i = 0;
+	while (i < data.length) {
+		const b0 = data[i];
+		if (b0 <= DICT_OPERATOR_MAX) {
+			if (b0 !== DICT_OPERATOR_ESCAPE) {
+				i += 1;
+				continue;
+			}
+			if (i + 1 >= data.length) return;
+			if (data[i + 1] === DICT_ROS_ESCAPED_OPERATOR) return true;
+			i += 2;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_INT16) {
+			if (i + DICT_OPERAND_INT16_SIZE > data.length) return;
+			i += DICT_OPERAND_INT16_SIZE;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_INT32) {
+			if (i + DICT_OPERAND_INT32_SIZE > data.length) return;
+			i += DICT_OPERAND_INT32_SIZE;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_REAL) {
+			const end = findRealOperandEnd(data, i + 1);
+			if (end === void 0) return;
+			i = end;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_SMALL_FIRST && b0 <= DICT_OPERAND_SMALL_LAST) {
+			i += 1;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_MEDIUM_FIRST && b0 <= DICT_OPERAND_MEDIUM_LAST) {
+			if (i + DICT_OPERAND_MEDIUM_SIZE > data.length) return;
+			i += DICT_OPERAND_MEDIUM_SIZE;
+			continue;
+		}
+		return;
+	}
+	return false;
+}
+function findRealOperandEnd(data, start) {
+	for (let i = start; i < data.length; i++) {
+		const byte = data[i];
+		if (byte >> 4 === DICT_REAL_TERMINATOR_NIBBLE || (byte & 15) === DICT_REAL_TERMINATOR_NIBBLE) return i + 1;
+	}
+}
+function decodeAscii(bytes) {
+	let text = "";
+	for (const byte of bytes) text += String.fromCharCode(byte);
+	return text;
+}
+function probeCff(bytes) {
+	if (!require_sfnt.hasBytes(bytes, 0, CFF_HEADER_SIZE)) return;
+	const majorVersion = require_sfnt.u8(bytes, 0);
+	const minorVersion = require_sfnt.u8(bytes, 1);
+	const headerSize = require_sfnt.u8(bytes, 2);
+	if (majorVersion !== CFF_MAJOR_VERSION || headerSize < CFF_HEADER_SIZE) return;
+	const nameIndex = readIndex(bytes, headerSize);
+	if (nameIndex === void 0 || nameIndex.count === 0) return;
+	const nameBytes = nameIndex.entry(0);
+	if (nameBytes === void 0) return;
+	const topDict = readIndex(bytes, nameIndex.endOffset)?.entry(0);
+	if (topDict === void 0) return;
+	const cidKeyed = dictDeclaresRos(topDict);
+	if (cidKeyed === void 0) return;
+	return {
+		majorVersion,
+		minorVersion,
+		name: decodeAscii(nameBytes),
+		cidKeyed
+	};
+}
+//#endregion
+exports.probeCff = probeCff;

package/dist/cff-probe.d.cts

@@ -0,0 +1,10 @@
+//#region src/cff-probe.d.ts
+interface CffProbeResult {
+  readonly majorVersion: number;
+  readonly minorVersion: number;
+  readonly name: string;
+  readonly cidKeyed: boolean;
+}
+declare function probeCff(bytes: Uint8Array<ArrayBuffer>): CffProbeResult | undefined;
+//#endregion
+export { CffProbeResult, probeCff };

package/dist/cff-probe.d.ts

@@ -0,0 +1,10 @@
+//#region src/cff-probe.d.ts
+interface CffProbeResult {
+  readonly majorVersion: number;
+  readonly minorVersion: number;
+  readonly name: string;
+  readonly cidKeyed: boolean;
+}
+declare function probeCff(bytes: Uint8Array<ArrayBuffer>): CffProbeResult | undefined;
+//#endregion
+export { CffProbeResult, probeCff };

package/dist/cff-probe.js

@@ -0,0 +1,132 @@
+import { hasBytes, u16, u24, u32, u8 } from "./sfnt.js";
+//#region src/cff-probe.ts
+const CFF_HEADER_SIZE = 4;
+const CFF_MAJOR_VERSION = 1;
+const INDEX_COUNT_SIZE = 2;
+const INDEX_OFF_SIZE_SIZE = 1;
+const MIN_OFF_SIZE = 1;
+const MAX_OFF_SIZE = 4;
+const DICT_OPERATOR_MAX = 21;
+const DICT_OPERATOR_ESCAPE = 12;
+const DICT_ROS_ESCAPED_OPERATOR = 30;
+const DICT_OPERAND_INT16 = 28;
+const DICT_OPERAND_INT32 = 29;
+const DICT_OPERAND_REAL = 30;
+const DICT_OPERAND_INT16_SIZE = 3;
+const DICT_OPERAND_INT32_SIZE = 5;
+const DICT_OPERAND_SMALL_FIRST = 32;
+const DICT_OPERAND_SMALL_LAST = 246;
+const DICT_OPERAND_MEDIUM_FIRST = 247;
+const DICT_OPERAND_MEDIUM_LAST = 254;
+const DICT_OPERAND_MEDIUM_SIZE = 2;
+const DICT_REAL_TERMINATOR_NIBBLE = 15;
+function readOffsetAt(bytes, offset, offSize) {
+	if (offSize === 1) return u8(bytes, offset);
+	if (offSize === 2) return u16(bytes, offset);
+	if (offSize === 3) return u24(bytes, offset);
+	return u32(bytes, offset);
+}
+function readIndex(bytes, offset) {
+	if (!hasBytes(bytes, offset, INDEX_COUNT_SIZE)) return;
+	const count = u16(bytes, offset);
+	if (count === 0) return {
+		count: 0,
+		endOffset: offset + INDEX_COUNT_SIZE,
+		entry: () => void 0
+	};
+	if (!hasBytes(bytes, offset + INDEX_COUNT_SIZE, INDEX_OFF_SIZE_SIZE)) return;
+	const offSize = u8(bytes, offset + INDEX_COUNT_SIZE);
+	if (offSize < MIN_OFF_SIZE || offSize > MAX_OFF_SIZE) return;
+	const offsetArrayStart = offset + INDEX_COUNT_SIZE + INDEX_OFF_SIZE_SIZE;
+	const offsetArrayLength = (count + 1) * offSize;
+	if (!hasBytes(bytes, offsetArrayStart, offsetArrayLength)) return;
+	const offsets = [];
+	for (let i = 0; i <= count; i++) offsets.push(readOffsetAt(bytes, offsetArrayStart + i * offSize, offSize));
+	if (offsets[0] !== 1) return;
+	for (let i = 1; i <= count; i++) if (offsets[i] < offsets[i - 1]) return;
+	const dataOrigin = offsetArrayStart + offsetArrayLength - 1;
+	const dataLength = offsets[count] - 1;
+	if (!hasBytes(bytes, dataOrigin + 1, dataLength)) return;
+	return {
+		count,
+		endOffset: dataOrigin + 1 + dataLength,
+		entry: (index) => index < 0 || index >= count ? void 0 : bytes.subarray(dataOrigin + offsets[index], dataOrigin + offsets[index + 1])
+	};
+}
+function dictDeclaresRos(data) {
+	let i = 0;
+	while (i < data.length) {
+		const b0 = data[i];
+		if (b0 <= DICT_OPERATOR_MAX) {
+			if (b0 !== DICT_OPERATOR_ESCAPE) {
+				i += 1;
+				continue;
+			}
+			if (i + 1 >= data.length) return;
+			if (data[i + 1] === DICT_ROS_ESCAPED_OPERATOR) return true;
+			i += 2;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_INT16) {
+			if (i + DICT_OPERAND_INT16_SIZE > data.length) return;
+			i += DICT_OPERAND_INT16_SIZE;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_INT32) {
+			if (i + DICT_OPERAND_INT32_SIZE > data.length) return;
+			i += DICT_OPERAND_INT32_SIZE;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_REAL) {
+			const end = findRealOperandEnd(data, i + 1);
+			if (end === void 0) return;
+			i = end;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_SMALL_FIRST && b0 <= DICT_OPERAND_SMALL_LAST) {
+			i += 1;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_MEDIUM_FIRST && b0 <= DICT_OPERAND_MEDIUM_LAST) {
+			if (i + DICT_OPERAND_MEDIUM_SIZE > data.length) return;
+			i += DICT_OPERAND_MEDIUM_SIZE;
+			continue;
+		}
+		return;
+	}
+	return false;
+}
+function findRealOperandEnd(data, start) {
+	for (let i = start; i < data.length; i++) {
+		const byte = data[i];
+		if (byte >> 4 === DICT_REAL_TERMINATOR_NIBBLE || (byte & 15) === DICT_REAL_TERMINATOR_NIBBLE) return i + 1;
+	}
+}
+function decodeAscii(bytes) {
+	let text = "";
+	for (const byte of bytes) text += String.fromCharCode(byte);
+	return text;
+}
+function probeCff(bytes) {
+	if (!hasBytes(bytes, 0, CFF_HEADER_SIZE)) return;
+	const majorVersion = u8(bytes, 0);
+	const minorVersion = u8(bytes, 1);
+	const headerSize = u8(bytes, 2);
+	if (majorVersion !== CFF_MAJOR_VERSION || headerSize < CFF_HEADER_SIZE) return;
+	const nameIndex = readIndex(bytes, headerSize);
+	if (nameIndex === void 0 || nameIndex.count === 0) return;
+	const nameBytes = nameIndex.entry(0);
+	if (nameBytes === void 0) return;
+	const topDict = readIndex(bytes, nameIndex.endOffset)?.entry(0);
+	if (topDict === void 0) return;
+	const cidKeyed = dictDeclaresRos(topDict);
+	if (cidKeyed === void 0) return;
+	return {
+		majorVersion,
+		minorVersion,
+		name: decodeAscii(nameBytes),
+		cidKeyed
+	};
+}
+//#endregion
+export { probeCff };

package/dist/cmap-table.cjs

@@ -0,0 +1,108 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/cmap-table.ts
+const CMAP_HEADER_SIZE = 4;
+const SUBTABLE_RECORD_SIZE = 8;
+const FORMAT_4_HEADER_SIZE = 14;
+function parseFormat4(bytes, subtableOffset) {
+	if (!require_sfnt.hasBytes(bytes, subtableOffset, FORMAT_4_HEADER_SIZE)) return;
+	const segCountX2 = require_sfnt.u16(bytes, subtableOffset + 6);
+	if (segCountX2 === 0 || segCountX2 % 2 !== 0) return;
+	const segCount = segCountX2 / 2;
+	const endCodesOffset = subtableOffset + FORMAT_4_HEADER_SIZE;
+	const startCodesOffset = endCodesOffset + segCountX2 + 2;
+	const idDeltasOffset = startCodesOffset + segCountX2;
+	const idRangeOffsetsOffset = idDeltasOffset + segCountX2;
+	if (!require_sfnt.hasBytes(bytes, endCodesOffset, segCountX2 * 4 + 2)) return;
+	const segments = [];
+	for (let i = 0; i < segCount; i++) {
+		const idRangeOffsetPos = idRangeOffsetsOffset + i * 2;
+		const rawDelta = require_sfnt.u16(bytes, idDeltasOffset + i * 2);
+		segments.push({
+			endCode: require_sfnt.u16(bytes, endCodesOffset + i * 2),
+			startCode: require_sfnt.u16(bytes, startCodesOffset + i * 2),
+			idDelta: rawDelta >= 32768 ? rawDelta - 65536 : rawDelta,
+			idRangeOffsetPos,
+			idRangeOffset: require_sfnt.u16(bytes, idRangeOffsetPos)
+		});
+	}
+	return (codePoint) => {
+		if (codePoint > 65535) return;
+		for (const segment of segments) {
+			if (codePoint < segment.startCode || codePoint > segment.endCode) continue;
+			if (segment.idRangeOffset === 0) return codePoint + segment.idDelta & 65535;
+			const glyphIndexAddress = segment.idRangeOffsetPos + segment.idRangeOffset + (codePoint - segment.startCode) * 2;
+			if (!require_sfnt.hasBytes(bytes, glyphIndexAddress, 2)) return;
+			const glyphId = require_sfnt.u16(bytes, glyphIndexAddress);
+			return glyphId === 0 ? void 0 : glyphId + segment.idDelta & 65535;
+		}
+	};
+}
+const FORMAT_12_HEADER_SIZE = 16;
+const FORMAT_12_GROUP_SIZE = 12;
+function parseFormat12(bytes, subtableOffset) {
+	if (!require_sfnt.hasBytes(bytes, subtableOffset, FORMAT_12_HEADER_SIZE)) return;
+	const numGroups = require_sfnt.u32(bytes, subtableOffset + 12);
+	const groupsOffset = subtableOffset + FORMAT_12_HEADER_SIZE;
+	if (!require_sfnt.hasBytes(bytes, groupsOffset, numGroups * FORMAT_12_GROUP_SIZE)) return;
+	const groups = [];
+	for (let i = 0; i < numGroups; i++) {
+		const recordOffset = groupsOffset + i * FORMAT_12_GROUP_SIZE;
+		groups.push({
+			startCharCode: require_sfnt.u32(bytes, recordOffset),
+			endCharCode: require_sfnt.u32(bytes, recordOffset + 4),
+			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);
+	};
+}
+const FORMAT_6_HEADER_SIZE = 10;
+function parseFormat6(bytes, subtableOffset) {
+	if (!require_sfnt.hasBytes(bytes, subtableOffset, FORMAT_6_HEADER_SIZE)) return;
+	const firstCode = require_sfnt.u16(bytes, subtableOffset + 6);
+	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 index = codePoint - firstCode;
+		if (index < 0 || index >= entryCount) return;
+		const glyphId = require_sfnt.u16(bytes, glyphIdArrayOffset + index * 2);
+		return glyphId === 0 ? void 0 : glyphId;
+	};
+}
+function preferenceRank(subtable) {
+	if (subtable.format === 12) {
+		if (subtable.platformId === 3 && subtable.encodingId === 10) return 0;
+		if (subtable.platformId === 0) return 1;
+		return 2;
+	}
+	if (subtable.format === 4) return subtable.platformId === 3 && subtable.encodingId === 1 ? 3 : 4;
+	return 5;
+}
+function buildCmapLookup(font) {
+	const cmapBytes = require_sfnt.sfntTableBytes(font, "cmap");
+	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;
+	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({
+			platformId: require_sfnt.u16(cmapBytes, recordOffset),
+			encodingId: require_sfnt.u16(cmapBytes, recordOffset + 2),
+			offset,
+			format: require_sfnt.u16(cmapBytes, offset)
+		});
+	}
+	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;
+	}
+}
+//#endregion
+exports.buildCmapLookup = buildCmapLookup;

package/dist/cmap-table.d.cts

@@ -0,0 +1,6 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+//#region src/cmap-table.d.ts
+type CmapLookup = (codePoint: number) => number | undefined;
+declare function buildCmapLookup(font: SfntFont): CmapLookup | undefined;
+//#endregion
+export { CmapLookup, buildCmapLookup };

package/dist/cmap-table.d.ts

@@ -0,0 +1,6 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+//#region src/cmap-table.d.ts
+type CmapLookup = (codePoint: number) => number | undefined;
+declare function buildCmapLookup(font: SfntFont): CmapLookup | undefined;
+//#endregion
+export { CmapLookup, buildCmapLookup };

package/dist/cmap-table.js

@@ -0,0 +1,107 @@
+import { hasBytes, sfntTableBytes, u16, u32 } from "./sfnt.js";
+//#region src/cmap-table.ts
+const CMAP_HEADER_SIZE = 4;
+const SUBTABLE_RECORD_SIZE = 8;
+const FORMAT_4_HEADER_SIZE = 14;
+function parseFormat4(bytes, subtableOffset) {
+	if (!hasBytes(bytes, subtableOffset, FORMAT_4_HEADER_SIZE)) return;
+	const segCountX2 = u16(bytes, subtableOffset + 6);
+	if (segCountX2 === 0 || segCountX2 % 2 !== 0) return;
+	const segCount = segCountX2 / 2;
+	const endCodesOffset = subtableOffset + FORMAT_4_HEADER_SIZE;
+	const startCodesOffset = endCodesOffset + segCountX2 + 2;
+	const idDeltasOffset = startCodesOffset + segCountX2;
+	const idRangeOffsetsOffset = idDeltasOffset + segCountX2;
+	if (!hasBytes(bytes, endCodesOffset, segCountX2 * 4 + 2)) return;
+	const segments = [];
+	for (let i = 0; i < segCount; i++) {
+		const idRangeOffsetPos = idRangeOffsetsOffset + i * 2;
+		const rawDelta = u16(bytes, idDeltasOffset + i * 2);
+		segments.push({
+			endCode: u16(bytes, endCodesOffset + i * 2),
+			startCode: u16(bytes, startCodesOffset + i * 2),
+			idDelta: rawDelta >= 32768 ? rawDelta - 65536 : rawDelta,
+			idRangeOffsetPos,
+			idRangeOffset: u16(bytes, idRangeOffsetPos)
+		});
+	}
+	return (codePoint) => {
+		if (codePoint > 65535) return;
+		for (const segment of segments) {
+			if (codePoint < segment.startCode || codePoint > segment.endCode) continue;
+			if (segment.idRangeOffset === 0) return codePoint + segment.idDelta & 65535;
+			const glyphIndexAddress = segment.idRangeOffsetPos + segment.idRangeOffset + (codePoint - segment.startCode) * 2;
+			if (!hasBytes(bytes, glyphIndexAddress, 2)) return;
+			const glyphId = u16(bytes, glyphIndexAddress);
+			return glyphId === 0 ? void 0 : glyphId + segment.idDelta & 65535;
+		}
+	};
+}
+const FORMAT_12_HEADER_SIZE = 16;
+const FORMAT_12_GROUP_SIZE = 12;
+function parseFormat12(bytes, subtableOffset) {
+	if (!hasBytes(bytes, subtableOffset, FORMAT_12_HEADER_SIZE)) return;
+	const numGroups = u32(bytes, subtableOffset + 12);
+	const groupsOffset = subtableOffset + FORMAT_12_HEADER_SIZE;
+	if (!hasBytes(bytes, groupsOffset, numGroups * FORMAT_12_GROUP_SIZE)) return;
+	const groups = [];
+	for (let i = 0; i < numGroups; i++) {
+		const recordOffset = groupsOffset + i * FORMAT_12_GROUP_SIZE;
+		groups.push({
+			startCharCode: u32(bytes, recordOffset),
+			endCharCode: u32(bytes, recordOffset + 4),
+			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);
+	};
+}
+const FORMAT_6_HEADER_SIZE = 10;
+function parseFormat6(bytes, subtableOffset) {
+	if (!hasBytes(bytes, subtableOffset, FORMAT_6_HEADER_SIZE)) return;
+	const firstCode = u16(bytes, subtableOffset + 6);
+	const entryCount = u16(bytes, subtableOffset + 8);
+	const glyphIdArrayOffset = subtableOffset + FORMAT_6_HEADER_SIZE;
+	if (!hasBytes(bytes, glyphIdArrayOffset, entryCount * 2)) return;
+	return (codePoint) => {
+		const index = codePoint - firstCode;
+		if (index < 0 || index >= entryCount) return;
+		const glyphId = u16(bytes, glyphIdArrayOffset + index * 2);
+		return glyphId === 0 ? void 0 : glyphId;
+	};
+}
+function preferenceRank(subtable) {
+	if (subtable.format === 12) {
+		if (subtable.platformId === 3 && subtable.encodingId === 10) return 0;
+		if (subtable.platformId === 0) return 1;
+		return 2;
+	}
+	if (subtable.format === 4) return subtable.platformId === 3 && subtable.encodingId === 1 ? 3 : 4;
+	return 5;
+}
+function buildCmapLookup(font) {
+	const cmapBytes = sfntTableBytes(font, "cmap");
+	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;
+	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({
+			platformId: u16(cmapBytes, recordOffset),
+			encodingId: u16(cmapBytes, recordOffset + 2),
+			offset,
+			format: u16(cmapBytes, offset)
+		});
+	}
+	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;
+	}
+}
+//#endregion
+export { buildCmapLookup };

package/dist/content-write.cjs

@@ -3,9 +3,11 @@ const require_afm_widths = require("./afm-widths-BoeTOK2r.cjs");
 const require_bytes_writer = require("./bytes/writer.cjs");
 const require_objects = require("./objects.cjs");
 const require_matrix = require("./matrix.cjs");
+const require_embedded_font = require("./embedded-font.cjs");
 const require_serialize = require("./serialize.cjs");
 //#region src/content-write.ts
-const BEZIER_KAPPA = .5522847498;
+const GLYPH_SPACE_UNITS_PER_EM = 1e3;
+const EMBEDDED_HORIZONTAL_SCALE_PERCENT = 100;
 function writeRgbOperator(writer, color, operator) {
 	writer.writeAscii(`${require_serialize.formatNumber(color.r)} ${require_serialize.formatNumber(color.g)} ${require_serialize.formatNumber(color.b)} ${operator}\n`);
 }
@@ -23,8 +25,7 @@ function anchorMatrix(xPt, yPt, rotationDeg) {
 		yPt
 	];
 }
-function writeUnderline(writer, item, widthPt, measurer) {
-	const underline = measurer.underlineAtSize(item.font, item.sizePt);
+function writeUnderline(writer, item, widthPt, underline) {
 	writer.writeAscii("q\n");
 	writeMatrixOperator(writer, anchorMatrix(item.xPt, item.yPt, item.rotationDeg), "cm");
 	writeRgbOperator(writer, item.color, "rg");
@@ -32,23 +33,39 @@ function writeUnderline(writer, item, widthPt, measurer) {
 	writer.writeAscii("f\n");
 	writer.writeAscii("Q\n");
 }
-function writeText(writer, item, context, substitutions) {
-	const font = context.resolveFont(item.font);
-	const encoded = require_afm_widths.encodeForShow(item.text, font.standardName);
-	substitutions.push(...encoded.substitutions);
-	const scalePercent = context.measurer.horizontalScaleFor(item.font) * 100;
+function writeShowTextBlock(writer, item, resourceName, scalePercent, codes) {
 	writer.writeAscii("BT\n");
-	writer.writeAscii(`/${font.resourceName} ${require_serialize.formatNumber(item.sizePt)} Tf\n`);
+	writer.writeAscii(`/${resourceName} ${require_serialize.formatNumber(item.sizePt)} Tf\n`);
 	writer.writeAscii(`${require_serialize.formatNumber(scalePercent)} Tz\n`);
 	writeRgbOperator(writer, item.color, "rg");
 	writeMatrixOperator(writer, anchorMatrix(item.xPt, item.yPt, item.rotationDeg), "Tm");
-	require_serialize.writeObject(writer, require_objects.pdfHexString(encoded.codes));
+	require_serialize.writeObject(writer, require_objects.pdfHexString(codes));
 	writer.writeAscii(" Tj\n");
 	writer.writeAscii("ET\n");
-	if (item.underline === true) {
-		const scale = context.measurer.horizontalScaleFor(item.font);
-		writeUnderline(writer, item, item.widthPt ?? encoded.width1000 / 1e3 * item.sizePt * scale, context.measurer);
+}
+function writeStandardText(writer, item, standardName, resourceName, measurer, substitutions) {
+	const encoded = require_afm_widths.encodeForShow(item.text, standardName);
+	substitutions.push(...encoded.substitutions);
+	const scale = measurer.horizontalScaleFor(item.font);
+	writeShowTextBlock(writer, item, resourceName, scale * 100, encoded.codes);
+	if (item.underline === true) writeUnderline(writer, item, item.widthPt ?? encoded.width1000 / GLYPH_SPACE_UNITS_PER_EM * item.sizePt * scale, measurer.underlineAtSize(item.font, item.sizePt));
+}
+function writeEmbeddedText(writer, item, face, resourceName, missingGlyphs) {
+	const encoded = require_embedded_font.encodeForShowEmbedded(item.text, face);
+	missingGlyphs.push(...encoded.substitutions);
+	writeShowTextBlock(writer, item, resourceName, EMBEDDED_HORIZONTAL_SCALE_PERCENT, encoded.codes);
+	if (item.underline === true) writeUnderline(writer, item, item.widthPt ?? encoded.width1000 / GLYPH_SPACE_UNITS_PER_EM * item.sizePt, {
+		offsetPt: face.metrics.underlinePositionGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * item.sizePt,
+		thicknessPt: face.metrics.underlineThicknessGlyphSpace / GLYPH_SPACE_UNITS_PER_EM * item.sizePt
+	});
+}
+function writeText(writer, item, context, substitutions, missingGlyphs) {
+	const font = context.resolveFont(item.font);
+	if (font.kind === "embedded") {
+		writeEmbeddedText(writer, item, font.face, font.resourceName, missingGlyphs);
+		return;
 	}
+	writeStandardText(writer, item, font.standardName, font.resourceName, context.measurer, substitutions);
 }
 function paintOperatorFor(fill, stroke, fillRule) {
 	const evenOdd = fillRule === "evenodd";
@@ -87,8 +104,8 @@ function writeEllipse(writer, item) {
 	const cy = item.yPt + item.heightPt / 2;
 	const rx = item.widthPt / 2;
 	const ry = item.heightPt / 2;
-	const kx = rx * BEZIER_KAPPA;
-	const ky = ry * BEZIER_KAPPA;
+	const kx = rx * require_matrix.BEZIER_KAPPA;
+	const ky = ry * require_matrix.BEZIER_KAPPA;
 	writer.writeAscii(`${formatPoint(cx + rx, cy)} m\n`);
 	writer.writeAscii(`${formatPoint(cx + rx, cy + ky)} ${formatPoint(cx + kx, cy + ry)} ${formatPoint(cx, cy + ry)} c\n`);
 	writer.writeAscii(`${formatPoint(cx - kx, cy + ry)} ${formatPoint(cx - rx, cy + ky)} ${formatPoint(cx - rx, cy)} c\n`);
@@ -123,7 +140,8 @@ function writeImage(writer, item, context) {
 function writeContentStream(items, context) {
 	const writer = new require_bytes_writer.ByteWriter();
 	const substitutions = [];
-	for (const item of items) if (item.kind === "text") writeText(writer, item, context, substitutions);
+	const missingGlyphs = [];
+	for (const item of items) if (item.kind === "text") writeText(writer, item, context, substitutions, missingGlyphs);
 	else if (item.kind === "image") writeImage(writer, item, context);
 	else if (item.kind === "rect") writeRect(writer, item);
 	else if (item.kind === "line") writeLine(writer, item);
@@ -131,7 +149,8 @@ function writeContentStream(items, context) {
 	else if (item.kind === "path") writePath(writer, item);
 	return {
 		bytes: writer.toBytes(),
-		substitutions
+		substitutions,
+		missingGlyphs
 	};
 }
 //#endregion

package/dist/content-write.d.cts

@@ -1,12 +1,18 @@
 import { r as StandardFontName } from "./afm-widths-DyDq56Ph.cjs";
+import { r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-CLedn-mT.cjs";
 import { TextMeasurer } from "./measure.cjs";
 import { WinAnsiSubstitution } from "./winansi.cjs";
 import { LayoutFont, LayoutItem } from "document-schema.js";
 //#region src/content-write.d.ts
-interface ResolvedFontResource {
+type ResolvedFontResource = {
+  readonly kind: 'standard';
   readonly resourceName: string;
   readonly standardName: StandardFontName;
-}
+} | {
+  readonly kind: 'embedded';
+  readonly resourceName: string;
+  readonly face: EmbeddedFace;
+};
 interface ResolvedImageResource {
   readonly resourceName: string;
 }
@@ -18,6 +24,7 @@ interface ContentWriteContext {
 interface ContentStreamResult {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly substitutions: readonly WinAnsiSubstitution[];
+  readonly missingGlyphs: readonly EmbeddedFaceSubstitution[];
 }
 declare function writeContentStream(items: readonly LayoutItem[], context: ContentWriteContext): ContentStreamResult;
 //#endregion

package/dist/content-write.d.ts

@@ -1,12 +1,18 @@
 import { r as StandardFontName } from "./afm-widths-DyDq56Ph.js";
+import { r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-CbqkKgBl.js";
 import { TextMeasurer } from "./measure.js";
 import { WinAnsiSubstitution } from "./winansi.js";
 import { LayoutFont, LayoutItem } from "document-schema.js";
 //#region src/content-write.d.ts
-interface ResolvedFontResource {
+type ResolvedFontResource = {
+  readonly kind: 'standard';
   readonly resourceName: string;
   readonly standardName: StandardFontName;
-}
+} | {
+  readonly kind: 'embedded';
+  readonly resourceName: string;
+  readonly face: EmbeddedFace;
+};
 interface ResolvedImageResource {
   readonly resourceName: string;
 }
@@ -18,6 +24,7 @@ interface ContentWriteContext {
 interface ContentStreamResult {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly substitutions: readonly WinAnsiSubstitution[];
+  readonly missingGlyphs: readonly EmbeddedFaceSubstitution[];
 }
 declare function writeContentStream(items: readonly LayoutItem[], context: ContentWriteContext): ContentStreamResult;
 //#endregion