pdf-codec 1.4.2 → 1.6.0

package/dist/sfnt-subset.d.cts

@@ -0,0 +1,11 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
+//#region src/sfnt-subset.d.ts
+interface SfntSubsetResult {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly numGlyphs: number;
+  readonly glyphIds: readonly number[];
+  readonly unmappedCodePoints: readonly number[];
+}
+declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>): SfntSubsetResult | undefined;
+//#endregion
+export { SfntSubsetResult, subsetSfnt };

package/dist/sfnt-subset.d.ts

@@ -0,0 +1,11 @@
+import { t as SfntFont } from "./sfnt-V08bb5ut.js";
+//#region src/sfnt-subset.d.ts
+interface SfntSubsetResult {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly numGlyphs: number;
+  readonly glyphIds: readonly number[];
+  readonly unmappedCodePoints: readonly number[];
+}
+declare function subsetSfnt(font: SfntFont, codePoints: Iterable<number>): SfntSubsetResult | undefined;
+//#endregion
+export { SfntSubsetResult, subsetSfnt };

package/dist/sfnt-subset.js

@@ -0,0 +1,249 @@
+import { hasBytes, sfntTableBytes, u16, u32 } from "./sfnt.js";
+import { buildCmapLookup } from "./cmap-table.js";
+import { parseHead, parseMaxp } from "./font-tables.js";
+import { parseGlyf } from "./glyf.js";
+//#region src/sfnt-subset.ts
+const HEAD_TABLE_SIZE = 54;
+const HEAD_CHECKSUM_ADJUSTMENT_OFFSET = 8;
+const HEAD_INDEX_TO_LOC_FORMAT_OFFSET = 50;
+const INDEX_TO_LOC_FORMAT_LONG = 1;
+const HHEA_TABLE_SIZE = 36;
+const HHEA_NUMBER_OF_HMETRICS_OFFSET = 34;
+const MAXP_MIN_SIZE = 6;
+const MAXP_NUM_GLYPHS_OFFSET = 4;
+const POST_STUB_SIZE = 32;
+const POST_VERSION_3_0 = 196608;
+const POST_METRICS_OFFSET = 4;
+const POST_METRICS_SIZE = 12;
+const LONG_HOR_METRIC_SIZE = 4;
+const LEFT_SIDE_BEARING_SIZE = 2;
+const LOCA_LONG_ENTRY_SIZE = 4;
+const TABLE_DIRECTORY_HEADER_SIZE = 12;
+const TABLE_RECORD_SIZE = 16;
+const SFNT_VERSION_TRUETYPE = 65536;
+const CHECKSUM_ADJUSTMENT_MAGIC = 2981146554;
+const GLYPH_ALIGNMENT = 4;
+const COPIED_TAGS = [
+	"cvt ",
+	"fpgm",
+	"prep"
+];
+function alignUp(value) {
+	return Math.ceil(value / GLYPH_ALIGNMENT) * GLYPH_ALIGNMENT;
+}
+function writeU16(bytes, offset, value) {
+	bytes[offset] = value >>> 8 & 255;
+	bytes[offset + 1] = value & 255;
+}
+function writeU32(bytes, offset, value) {
+	bytes[offset] = value >>> 24 & 255;
+	bytes[offset + 1] = value >>> 16 & 255;
+	bytes[offset + 2] = value >>> 8 & 255;
+	bytes[offset + 3] = value & 255;
+}
+function checksum(bytes, offset, length) {
+	let sum = 0;
+	for (let i = 0; i < length; i += GLYPH_ALIGNMENT) sum = sum + u32(bytes, offset + i) >>> 0;
+	return sum;
+}
+function readHorizontalMetrics(source, glyphId) {
+	if (glyphId < source.numberOfHMetrics) {
+		const offset = glyphId * LONG_HOR_METRIC_SIZE;
+		if (!hasBytes(source.bytes, offset, LONG_HOR_METRIC_SIZE)) return;
+		return {
+			advanceWidth: u16(source.bytes, offset),
+			leftSideBearing: u16(source.bytes, offset + 2)
+		};
+	}
+	const lastAdvanceOffset = (source.numberOfHMetrics - 1) * LONG_HOR_METRIC_SIZE;
+	const bearingOffset = source.numberOfHMetrics * LONG_HOR_METRIC_SIZE + (glyphId - source.numberOfHMetrics) * LEFT_SIDE_BEARING_SIZE;
+	if (!hasBytes(source.bytes, lastAdvanceOffset, LONG_HOR_METRIC_SIZE) || !hasBytes(source.bytes, bearingOffset, LEFT_SIDE_BEARING_SIZE)) return;
+	return {
+		advanceWidth: u16(source.bytes, lastAdvanceOffset),
+		leftSideBearing: u16(source.bytes, bearingOffset)
+	};
+}
+function buildPostStub(font) {
+	const post = new Uint8Array(POST_STUB_SIZE);
+	writeU32(post, 0, POST_VERSION_3_0);
+	const sourcePost = sfntTableBytes(font, "post");
+	if (sourcePost !== void 0 && hasBytes(sourcePost, POST_METRICS_OFFSET, POST_METRICS_SIZE)) post.set(sourcePost.subarray(POST_METRICS_OFFSET, 16), POST_METRICS_OFFSET);
+	return post;
+}
+function collectGlyphIds(glyf, cmap, numGlyphs, codePoints) {
+	const used = /* @__PURE__ */ new Set([0]);
+	const unmapped = /* @__PURE__ */ new Set();
+	const pending = [0];
+	for (const codePoint of codePoints) {
+		const glyphId = cmap(codePoint);
+		if (glyphId === void 0) {
+			unmapped.add(codePoint);
+			continue;
+		}
+		if (glyphId >= numGlyphs) return;
+		if (!used.has(glyphId)) {
+			used.add(glyphId);
+			pending.push(glyphId);
+		}
+	}
+	while (pending.length > 0) {
+		const glyphId = pending.pop();
+		if (glyf.glyphBytes(glyphId) === void 0) return;
+		const header = glyf.glyphHeader(glyphId);
+		if (header === void 0 || header.numberOfContours >= 0) continue;
+		const components = glyf.compositeComponents(glyphId);
+		if (components === void 0) return;
+		for (const component of components) {
+			if (component.glyphIndex >= numGlyphs) return;
+			if (!used.has(component.glyphIndex)) {
+				used.add(component.glyphIndex);
+				pending.push(component.glyphIndex);
+			}
+		}
+	}
+	return {
+		used,
+		unmapped: [...unmapped].sort((a, b) => a - b)
+	};
+}
+function subsetSfnt(font, codePoints) {
+	const head = parseHead(font);
+	const maxp = parseMaxp(font);
+	const sourceHead = sfntTableBytes(font, "head");
+	const sourceHhea = sfntTableBytes(font, "hhea");
+	const sourceMaxp = sfntTableBytes(font, "maxp");
+	const sourceHmtx = sfntTableBytes(font, "hmtx");
+	if (head === void 0 || maxp === void 0 || sourceHead === void 0 || sourceHhea === void 0 || sourceMaxp === void 0 || sourceHmtx === void 0) return;
+	if (!hasBytes(sourceHead, 0, HEAD_TABLE_SIZE) || !hasBytes(sourceHhea, 0, HHEA_TABLE_SIZE) || !hasBytes(sourceMaxp, 0, MAXP_MIN_SIZE)) return;
+	const numberOfHMetrics = u16(sourceHhea, HHEA_NUMBER_OF_HMETRICS_OFFSET);
+	if (numberOfHMetrics === 0) return;
+	const glyf = parseGlyf(font, {
+		numGlyphs: maxp.numGlyphs,
+		indexToLocFormat: head.indexToLocFormat
+	});
+	const cmap = buildCmapLookup(font);
+	if (glyf === void 0 || cmap === void 0) return;
+	const collected = collectGlyphIds(glyf, cmap, maxp.numGlyphs, codePoints);
+	if (collected === void 0) return;
+	const glyphIds = [...collected.used].sort((a, b) => a - b);
+	const numGlyphs = glyphIds[glyphIds.length - 1] + 1;
+	const outlines = /* @__PURE__ */ new Map();
+	let glyfLength = 0;
+	for (const glyphId of glyphIds) {
+		const bytes = glyf.glyphBytes(glyphId);
+		if (bytes === void 0) return;
+		outlines.set(glyphId, bytes);
+		glyfLength += alignUp(bytes.length);
+	}
+	const glyfData = new Uint8Array(glyfLength);
+	const locaData = new Uint8Array((numGlyphs + 1) * LOCA_LONG_ENTRY_SIZE);
+	let glyfOffset = 0;
+	for (let glyphId = 0; glyphId < numGlyphs; glyphId++) {
+		writeU32(locaData, glyphId * LOCA_LONG_ENTRY_SIZE, glyfOffset);
+		const bytes = outlines.get(glyphId);
+		if (bytes === void 0) continue;
+		glyfData.set(bytes, glyfOffset);
+		glyfOffset += alignUp(bytes.length);
+	}
+	writeU32(locaData, numGlyphs * LOCA_LONG_ENTRY_SIZE, glyfOffset);
+	const hmtxData = new Uint8Array(numGlyphs * LONG_HOR_METRIC_SIZE);
+	for (let glyphId = 0; glyphId < numGlyphs; glyphId++) {
+		const metrics = readHorizontalMetrics({
+			bytes: sourceHmtx,
+			numberOfHMetrics
+		}, glyphId);
+		if (metrics === void 0) return;
+		writeU16(hmtxData, glyphId * LONG_HOR_METRIC_SIZE, metrics.advanceWidth);
+		writeU16(hmtxData, glyphId * LONG_HOR_METRIC_SIZE + 2, metrics.leftSideBearing);
+	}
+	const headData = new Uint8Array(HEAD_TABLE_SIZE);
+	headData.set(sourceHead.subarray(0, HEAD_TABLE_SIZE));
+	writeU32(headData, HEAD_CHECKSUM_ADJUSTMENT_OFFSET, 0);
+	writeU16(headData, HEAD_INDEX_TO_LOC_FORMAT_OFFSET, INDEX_TO_LOC_FORMAT_LONG);
+	const hheaData = new Uint8Array(HHEA_TABLE_SIZE);
+	hheaData.set(sourceHhea.subarray(0, HHEA_TABLE_SIZE));
+	writeU16(hheaData, HHEA_NUMBER_OF_HMETRICS_OFFSET, numGlyphs);
+	const maxpData = new Uint8Array(sourceMaxp.length);
+	maxpData.set(sourceMaxp);
+	writeU16(maxpData, MAXP_NUM_GLYPHS_OFFSET, numGlyphs);
+	const tables = [
+		{
+			tag: "glyf",
+			data: glyfData
+		},
+		{
+			tag: "head",
+			data: headData
+		},
+		{
+			tag: "hhea",
+			data: hheaData
+		},
+		{
+			tag: "hmtx",
+			data: hmtxData
+		},
+		{
+			tag: "loca",
+			data: locaData
+		},
+		{
+			tag: "maxp",
+			data: maxpData
+		},
+		{
+			tag: "post",
+			data: buildPostStub(font)
+		}
+	];
+	for (const tag of COPIED_TAGS) {
+		const bytes = sfntTableBytes(font, tag);
+		if (bytes !== void 0) {
+			const copy = new Uint8Array(bytes.length);
+			copy.set(bytes);
+			tables.push({
+				tag,
+				data: copy
+			});
+		}
+	}
+	tables.sort((a, b) => a.tag < b.tag ? -1 : 1);
+	const numTables = tables.length;
+	let entrySelector = 0;
+	while (1 << entrySelector + 1 <= numTables) entrySelector++;
+	const searchRange = (1 << entrySelector) * TABLE_RECORD_SIZE;
+	const rangeShift = numTables * TABLE_RECORD_SIZE - searchRange;
+	const directorySize = TABLE_DIRECTORY_HEADER_SIZE + numTables * TABLE_RECORD_SIZE;
+	const offsets = [];
+	let fileLength = alignUp(directorySize);
+	for (const table of tables) {
+		offsets.push(fileLength);
+		fileLength += alignUp(table.data.length);
+	}
+	const file = new Uint8Array(fileLength);
+	writeU32(file, 0, SFNT_VERSION_TRUETYPE);
+	writeU16(file, 4, numTables);
+	writeU16(file, 6, searchRange);
+	writeU16(file, 8, entrySelector);
+	writeU16(file, 10, rangeShift);
+	for (let i = 0; i < numTables; i++) {
+		const table = tables[i];
+		const tableOffset = offsets[i];
+		file.set(table.data, tableOffset);
+		const recordOffset = TABLE_DIRECTORY_HEADER_SIZE + i * TABLE_RECORD_SIZE;
+		for (let c = 0; c < table.tag.length; c++) file[recordOffset + c] = table.tag.charCodeAt(c);
+		writeU32(file, recordOffset + 4, checksum(file, tableOffset, alignUp(table.data.length)));
+		writeU32(file, recordOffset + 8, tableOffset);
+		writeU32(file, recordOffset + 12, table.data.length);
+	}
+	const headOffsetInFile = offsets[tables.findIndex((table) => table.tag === "head")];
+	writeU32(file, headOffsetInFile + HEAD_CHECKSUM_ADJUSTMENT_OFFSET, CHECKSUM_ADJUSTMENT_MAGIC - checksum(file, 0, fileLength) >>> 0);
+	return {
+		bytes: file,
+		numGlyphs,
+		glyphIds,
+		unmappedCodePoints: collected.unmapped
+	};
+}
+//#endregion
+export { subsetSfnt };

package/dist/sfnt.cjs

@@ -1,21 +1,49 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/sfnt.ts
+const TABLE_DIRECTORY_HEADER_SIZE = 12;
+const TABLE_RECORD_SIZE = 16;
+const TABLE_TAG_SIZE = 4;
+const SFNT_VERSIONS = /* @__PURE__ */ new Set([
+	65536,
+	1330926671,
+	1953658213,
+	1954115633
+]);
+function hasBytes(bytes, offset, length) {
+	return Number.isInteger(offset) && Number.isInteger(length) && offset >= 0 && length >= 0 && offset + length <= bytes.length;
+}
+function requireBytes(bytes, offset, length) {
+	if (!hasBytes(bytes, offset, length)) throw new Error(`sfnt read of ${String(length)} byte(s) at offset ${String(offset)} is outside the ${String(bytes.length)}-byte range`);
+}
 function readUint16(bytes, offset) {
 	return bytes[offset] << 8 | bytes[offset + 1];
 }
 function readUint32(bytes, offset) {
 	return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
 }
-const TABLE_DIRECTORY_HEADER_SIZE = 12;
-const TABLE_RECORD_SIZE = 16;
+function decodeTag(bytes, offset) {
+	let tag = "";
+	for (let i = 0; i < TABLE_TAG_SIZE; i++) {
+		const byte = bytes[offset + i];
+		if (byte < 32 || byte > 126) return;
+		tag += String.fromCharCode(byte);
+	}
+	return tag;
+}
 function parseSfnt(bytes) {
+	if (!hasBytes(bytes, 0, TABLE_DIRECTORY_HEADER_SIZE)) return;
+	if (!SFNT_VERSIONS.has(readUint32(bytes, 0))) return;
 	const numTables = readUint16(bytes, 4);
+	if (!hasBytes(bytes, 0, TABLE_DIRECTORY_HEADER_SIZE + numTables * TABLE_RECORD_SIZE)) return;
 	const tables = /* @__PURE__ */ new Map();
 	for (let i = 0; i < numTables; i++) {
 		const recordOffset = TABLE_DIRECTORY_HEADER_SIZE + i * TABLE_RECORD_SIZE;
-		const tag = new TextDecoder("ascii").decode(bytes.subarray(recordOffset, recordOffset + 4));
+		const tag = decodeTag(bytes, recordOffset);
+		if (tag === void 0) return;
 		const offset = readUint32(bytes, recordOffset + 8);
 		const length = readUint32(bytes, recordOffset + 12);
+		if (!hasBytes(bytes, offset, length)) continue;
+		if (tables.has(tag)) continue;
 		tables.set(tag, {
 			offset,
 			length
@@ -31,22 +59,40 @@ function sfntTableBytes(font, tag) {
 	return table === void 0 ? void 0 : font.bytes.subarray(table.offset, table.offset + table.length);
 }
 function u8(bytes, offset) {
+	requireBytes(bytes, offset, 1);
 	return bytes[offset];
 }
 function u16(bytes, offset) {
+	requireBytes(bytes, offset, 2);
 	return readUint16(bytes, offset);
 }
 function i16(bytes, offset) {
-	const value = readUint16(bytes, offset);
+	const value = u16(bytes, offset);
 	return value >= 32768 ? value - 65536 : value;
 }
+function u24(bytes, offset) {
+	requireBytes(bytes, offset, 3);
+	return bytes[offset] << 16 | bytes[offset + 1] << 8 | bytes[offset + 2];
+}
 function u32(bytes, offset) {
+	requireBytes(bytes, offset, 4);
 	return readUint32(bytes, offset);
 }
+function i32(bytes, offset) {
+	return u32(bytes, offset) | 0;
+}
+const F2DOT14_SCALE = 16384;
+function f2dot14(bytes, offset) {
+	return i16(bytes, offset) / F2DOT14_SCALE;
+}
 //#endregion
+exports.f2dot14 = f2dot14;
+exports.hasBytes = hasBytes;
 exports.i16 = i16;
+exports.i32 = i32;
 exports.parseSfnt = parseSfnt;
 exports.sfntTableBytes = sfntTableBytes;
 exports.u16 = u16;
+exports.u24 = u24;
 exports.u32 = u32;
 exports.u8 = u8;

package/dist/sfnt.d.cts

@@ -1,17 +1,2 @@
-//#region src/sfnt.d.ts
-interface SfntTable {
-  readonly offset: number;
-  readonly length: number;
-}
-interface SfntFont {
-  readonly bytes: Uint8Array<ArrayBuffer>;
-  readonly tables: ReadonlyMap<string, SfntTable>;
-}
-declare function parseSfnt(bytes: Uint8Array<ArrayBuffer>): SfntFont;
-declare function sfntTableBytes(font: SfntFont, tag: string): Uint8Array<ArrayBuffer> | undefined;
-declare function u8(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
-declare function u16(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
-declare function i16(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
-declare function u32(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
-//#endregion
-export { SfntFont, SfntTable, i16, parseSfnt, sfntTableBytes, u16, u32, u8 };
+import { a as i16, c as sfntTableBytes, d as u32, f as u8, i as hasBytes, l as u16, n as SfntTable, o as i32, r as f2dot14, s as parseSfnt, t as SfntFont, u as u24 } from "./sfnt-V08bb5ut.cjs";
+export { SfntFont, SfntTable, f2dot14, hasBytes, i16, i32, parseSfnt, sfntTableBytes, u16, u24, u32, u8 };

package/dist/sfnt.d.ts

@@ -1,17 +1,2 @@
-//#region src/sfnt.d.ts
-interface SfntTable {
-  readonly offset: number;
-  readonly length: number;
-}
-interface SfntFont {
-  readonly bytes: Uint8Array<ArrayBuffer>;
-  readonly tables: ReadonlyMap<string, SfntTable>;
-}
-declare function parseSfnt(bytes: Uint8Array<ArrayBuffer>): SfntFont;
-declare function sfntTableBytes(font: SfntFont, tag: string): Uint8Array<ArrayBuffer> | undefined;
-declare function u8(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
-declare function u16(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
-declare function i16(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
-declare function u32(bytes: Uint8Array<ArrayBuffer>, offset: number): number;
-//#endregion
-export { SfntFont, SfntTable, i16, parseSfnt, sfntTableBytes, u16, u32, u8 };
+import { a as i16, c as sfntTableBytes, d as u32, f as u8, i as hasBytes, l as u16, n as SfntTable, o as i32, r as f2dot14, s as parseSfnt, t as SfntFont, u as u24 } from "./sfnt-V08bb5ut.js";
+export { SfntFont, SfntTable, f2dot14, hasBytes, i16, i32, parseSfnt, sfntTableBytes, u16, u24, u32, u8 };

package/dist/sfnt.js

@@ -1,20 +1,48 @@
 //#region src/sfnt.ts
+const TABLE_DIRECTORY_HEADER_SIZE = 12;
+const TABLE_RECORD_SIZE = 16;
+const TABLE_TAG_SIZE = 4;
+const SFNT_VERSIONS = /* @__PURE__ */ new Set([
+	65536,
+	1330926671,
+	1953658213,
+	1954115633
+]);
+function hasBytes(bytes, offset, length) {
+	return Number.isInteger(offset) && Number.isInteger(length) && offset >= 0 && length >= 0 && offset + length <= bytes.length;
+}
+function requireBytes(bytes, offset, length) {
+	if (!hasBytes(bytes, offset, length)) throw new Error(`sfnt read of ${String(length)} byte(s) at offset ${String(offset)} is outside the ${String(bytes.length)}-byte range`);
+}
 function readUint16(bytes, offset) {
 	return bytes[offset] << 8 | bytes[offset + 1];
 }
 function readUint32(bytes, offset) {
 	return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
 }
-const TABLE_DIRECTORY_HEADER_SIZE = 12;
-const TABLE_RECORD_SIZE = 16;
+function decodeTag(bytes, offset) {
+	let tag = "";
+	for (let i = 0; i < TABLE_TAG_SIZE; i++) {
+		const byte = bytes[offset + i];
+		if (byte < 32 || byte > 126) return;
+		tag += String.fromCharCode(byte);
+	}
+	return tag;
+}
 function parseSfnt(bytes) {
+	if (!hasBytes(bytes, 0, TABLE_DIRECTORY_HEADER_SIZE)) return;
+	if (!SFNT_VERSIONS.has(readUint32(bytes, 0))) return;
 	const numTables = readUint16(bytes, 4);
+	if (!hasBytes(bytes, 0, TABLE_DIRECTORY_HEADER_SIZE + numTables * TABLE_RECORD_SIZE)) return;
 	const tables = /* @__PURE__ */ new Map();
 	for (let i = 0; i < numTables; i++) {
 		const recordOffset = TABLE_DIRECTORY_HEADER_SIZE + i * TABLE_RECORD_SIZE;
-		const tag = new TextDecoder("ascii").decode(bytes.subarray(recordOffset, recordOffset + 4));
+		const tag = decodeTag(bytes, recordOffset);
+		if (tag === void 0) return;
 		const offset = readUint32(bytes, recordOffset + 8);
 		const length = readUint32(bytes, recordOffset + 12);
+		if (!hasBytes(bytes, offset, length)) continue;
+		if (tables.has(tag)) continue;
 		tables.set(tag, {
 			offset,
 			length
@@ -30,17 +58,31 @@ function sfntTableBytes(font, tag) {
 	return table === void 0 ? void 0 : font.bytes.subarray(table.offset, table.offset + table.length);
 }
 function u8(bytes, offset) {
+	requireBytes(bytes, offset, 1);
 	return bytes[offset];
 }
 function u16(bytes, offset) {
+	requireBytes(bytes, offset, 2);
 	return readUint16(bytes, offset);
 }
 function i16(bytes, offset) {
-	const value = readUint16(bytes, offset);
+	const value = u16(bytes, offset);
 	return value >= 32768 ? value - 65536 : value;
 }
+function u24(bytes, offset) {
+	requireBytes(bytes, offset, 3);
+	return bytes[offset] << 16 | bytes[offset + 1] << 8 | bytes[offset + 2];
+}
 function u32(bytes, offset) {
+	requireBytes(bytes, offset, 4);
 	return readUint32(bytes, offset);
 }
+function i32(bytes, offset) {
+	return u32(bytes, offset) | 0;
+}
+const F2DOT14_SCALE = 16384;
+function f2dot14(bytes, offset) {
+	return i16(bytes, offset) / F2DOT14_SCALE;
+}
 //#endregion
-export { i16, parseSfnt, sfntTableBytes, u16, u32, u8 };
+export { f2dot14, hasBytes, i16, i32, parseSfnt, sfntTableBytes, u16, u24, u32, u8 };

package/dist/tounicode.cjs

@@ -0,0 +1,34 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_objects = require("./objects.cjs");
+//#region src/tounicode.ts
+const MAX_BFCHAR_ENTRIES_PER_BLOCK = 100;
+function codePointToUtf16BEHex(codePoint) {
+	const text = String.fromCodePoint(codePoint);
+	let hex = "";
+	for (let i = 0; i < text.length; i++) hex += text.charCodeAt(i).toString(16).padStart(4, "0");
+	return hex;
+}
+function buildToUnicodeCMap(codeToCodePoint) {
+	const entries = [...codeToCodePoint].sort((a, b) => a[0] - b[0]);
+	const lines = [
+		"/CIDInit /ProcSet findresource begin",
+		"12 dict begin",
+		"begincmap",
+		"/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def",
+		"/CMapName /Adobe-Identity-UCS def",
+		"/CMapType 2 def",
+		"1 begincodespacerange",
+		"<0000> <FFFF>",
+		"endcodespacerange"
+	];
+	for (let start = 0; start < entries.length; start += MAX_BFCHAR_ENTRIES_PER_BLOCK) {
+		const block = entries.slice(start, start + MAX_BFCHAR_ENTRIES_PER_BLOCK);
+		lines.push(`${block.length} beginbfchar`);
+		for (const [code, codePoint] of block) lines.push(`<${code.toString(16).padStart(4, "0")}> <${codePointToUtf16BEHex(codePoint)}>`);
+		lines.push("endbfchar");
+	}
+	lines.push("endcmap", "CMapName currentdict /CMap defineresource pop", "end", "end");
+	return require_objects.pdfStream(require_objects.pdfDict({}), new TextEncoder().encode(`${lines.join("\n")}\n`));
+}
+//#endregion
+exports.buildToUnicodeCMap = buildToUnicodeCMap;

package/dist/tounicode.d.cts

@@ -0,0 +1,5 @@
+import { PdfObject } from "./objects.cjs";
+//#region src/tounicode.d.ts
+declare function buildToUnicodeCMap(codeToCodePoint: ReadonlyMap<number, number>): PdfObject;
+//#endregion
+export { buildToUnicodeCMap };

package/dist/tounicode.d.ts

@@ -0,0 +1,5 @@
+import { PdfObject } from "./objects.js";
+//#region src/tounicode.d.ts
+declare function buildToUnicodeCMap(codeToCodePoint: ReadonlyMap<number, number>): PdfObject;
+//#endregion
+export { buildToUnicodeCMap };

package/dist/tounicode.js

@@ -0,0 +1,33 @@
+import { pdfDict, pdfStream } from "./objects.js";
+//#region src/tounicode.ts
+const MAX_BFCHAR_ENTRIES_PER_BLOCK = 100;
+function codePointToUtf16BEHex(codePoint) {
+	const text = String.fromCodePoint(codePoint);
+	let hex = "";
+	for (let i = 0; i < text.length; i++) hex += text.charCodeAt(i).toString(16).padStart(4, "0");
+	return hex;
+}
+function buildToUnicodeCMap(codeToCodePoint) {
+	const entries = [...codeToCodePoint].sort((a, b) => a[0] - b[0]);
+	const lines = [
+		"/CIDInit /ProcSet findresource begin",
+		"12 dict begin",
+		"begincmap",
+		"/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def",
+		"/CMapName /Adobe-Identity-UCS def",
+		"/CMapType 2 def",
+		"1 begincodespacerange",
+		"<0000> <FFFF>",
+		"endcodespacerange"
+	];
+	for (let start = 0; start < entries.length; start += MAX_BFCHAR_ENTRIES_PER_BLOCK) {
+		const block = entries.slice(start, start + MAX_BFCHAR_ENTRIES_PER_BLOCK);
+		lines.push(`${block.length} beginbfchar`);
+		for (const [code, codePoint] of block) lines.push(`<${code.toString(16).padStart(4, "0")}> <${codePointToUtf16BEHex(codePoint)}>`);
+		lines.push("endbfchar");
+	}
+	lines.push("endcmap", "CMapName currentdict /CMap defineresource pop", "end", "end");
+	return pdfStream(pdfDict({}), new TextEncoder().encode(`${lines.join("\n")}\n`));
+}
+//#endregion
+export { buildToUnicodeCMap };