modern-pdf-lib 0.9.0

package/dist/fontSubset-C0Rm9ih6.cjs

@@ -0,0 +1,226 @@
+const require_rolldown_runtime = require('./rolldown-runtime-CKhH4XqG.cjs');
+
+//#region src/assets/font/fontSubset.ts
+var fontSubset_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	buildSubsetCmap: () => buildSubsetCmap,
+	computeSubsetTag: () => computeSubsetTag,
+	initSubsetWasm: () => initSubsetWasm,
+	subsetFont: () => subsetFont
+});
+/**
+* Holds the subsetting WASM instance after initialization.
+* `undefined` means WASM is not loaded (fallback mode).
+*/
+let wasmInstance;
+/**
+* Initialize the font subsetting WASM module.
+*
+* Call this once if you want WASM-accelerated subsetting.  If not
+* called, {@link subsetFont} falls back to returning the entire font
+* file (no size reduction, but still functional).
+*
+* @param wasmSource - The `.wasm` binary, a URL, or a fetch Response.
+*/
+async function initSubsetWasm(wasmSource) {
+	if (wasmInstance) return;
+	const imports = { env: {} };
+	let result;
+	try {
+		if (wasmSource instanceof Uint8Array) result = await WebAssembly.instantiate(wasmSource.buffer, imports);
+		else if (typeof Response !== "undefined" && wasmSource instanceof Response) result = await WebAssembly.instantiateStreaming(wasmSource, imports);
+		else if (typeof wasmSource === "string" || wasmSource instanceof URL) {
+			const resp = await fetch(String(wasmSource));
+			result = await WebAssembly.instantiateStreaming(resp, imports);
+		} else {
+			const { loadWasmModule } = await Promise.resolve().then(() => require("./loader-mwt5wRJz.cjs"));
+			const bytes = await loadWasmModule("ttf");
+			result = await WebAssembly.instantiate(bytes.buffer, imports);
+		}
+		wasmInstance = result.instance.exports;
+	} catch {
+		wasmInstance = void 0;
+	}
+}
+/**
+* Subset a font using the WASM module.
+* @internal
+*/
+function subsetWithWasm(_fontData, _usedGlyphIds) {
+	throw new Error("WASM subsetting not yet implemented");
+}
+/**
+* Fallback "subsetting" that returns the full font unchanged.
+*
+* Since the full font data is returned unmodified, glyph IDs do not
+* change.  The mappings are therefore **true identity** for each used
+* glyph: `oldGID === newGID`.  This is functionally correct — PDF
+* viewers render the font normally via `CIDToGIDMap /Identity` — but
+* does not reduce file size.
+*
+* The `newToOldGid` array contains the used glyph IDs in sorted
+* order.  Because the font is not actually subsetted, each "new" GID
+* equals the original GID (identity mapping).
+*
+* @param fontData      The raw TTF font file bytes.
+* @param usedGlyphIds  Set of glyph IDs that are actually used.
+* @returns A {@link SubsetResult} with the original font bytes and
+*          identity glyph-ID mappings for the used glyphs.
+* @internal
+*/
+function subsetFallback(fontData, usedGlyphIds) {
+	const allGids = new Set(usedGlyphIds);
+	allGids.add(0);
+	const sortedGids = allGids.values().toArray().sort((a, b) => a - b);
+	const newToOldGid = sortedGids;
+	const oldToNewGid = /* @__PURE__ */ new Map();
+	for (const gid of sortedGids) oldToNewGid.set(gid, gid);
+	return {
+		fontData: new Uint8Array(fontData),
+		newToOldGid,
+		oldToNewGid
+	};
+}
+/**
+* Subset a TrueType font to include only the specified glyphs.
+*
+* Uses WASM-accelerated subsetting if available (via {@link initSubsetWasm}),
+* otherwise falls back to returning the full font with identity glyph
+* mappings.
+*
+* Glyph ID 0 (.notdef) is always included automatically.
+*
+* @param fontData     - The raw TTF font file bytes.
+* @param usedGlyphIds - Set of glyph IDs that are actually used.
+* @returns The subset result with the (possibly reduced) font and
+*          glyph-ID remapping tables.
+*/
+function subsetFont(fontData, usedGlyphIds) {
+	if (usedGlyphIds.size === 0) return subsetFallback(fontData, new Set([0]));
+	if (wasmInstance) return subsetWithWasm(fontData, usedGlyphIds);
+	return subsetFallback(fontData, usedGlyphIds);
+}
+/**
+* Build a PDF `/ToUnicode` CMap stream for a subsetted font.
+*
+* The CMap maps CIDs (new glyph IDs in the subset) back to Unicode
+* codepoints, enabling text extraction and copy-paste in PDF viewers.
+*
+* @param subsetResult       - The result from {@link subsetFont}.
+* @param originalCmapTable  - The original font's cmap table (Unicode
+*                             codepoint → original glyph ID).
+* @returns A CMap stream body and a CID-to-Unicode lookup.
+*/
+function buildSubsetCmap(subsetResult, originalCmapTable) {
+	const oldGidToUnicode = /* @__PURE__ */ new Map();
+	for (const [codepoint, gid] of originalCmapTable) {
+		const existing = oldGidToUnicode.get(gid);
+		if (existing) existing.push(codepoint);
+		else oldGidToUnicode.set(gid, [codepoint]);
+	}
+	const cidToUnicode = /* @__PURE__ */ new Map();
+	for (let newGid = 0; newGid < subsetResult.newToOldGid.length; newGid++) {
+		const oldGid = subsetResult.newToOldGid[newGid];
+		const unicodes = oldGidToUnicode.get(oldGid);
+		if (unicodes && unicodes.length > 0) cidToUnicode.set(newGid, unicodes);
+	}
+	return {
+		cmapStream: generateToUnicodeCmap(cidToUnicode),
+		cidToUnicode
+	};
+}
+/**
+* Generate a PDF `/ToUnicode` CMap program.
+*
+* The CMap uses `beginbfchar` / `endbfchar` sections to map individual
+* CIDs to Unicode values.  For ranges of consecutive mappings it uses
+* `beginbfrange` / `endbfrange`.
+*
+* @internal
+*/
+function generateToUnicodeCmap(cidToUnicode) {
+	const lines = [];
+	lines.push("/CIDInit /ProcSet findresource begin");
+	lines.push("12 dict begin");
+	lines.push("begincmap");
+	lines.push("/CIDSystemInfo");
+	lines.push("<< /Registry (Adobe)");
+	lines.push("/Ordering (UCS)");
+	lines.push("/Supplement 0");
+	lines.push(">> def");
+	lines.push("/CMapName /Adobe-Identity-UCS def");
+	lines.push("/CMapType 2 def");
+	lines.push("1 begincodespacerange");
+	lines.push("<0000> <FFFF>");
+	lines.push("endcodespacerange");
+	const entries = cidToUnicode.entries().toArray().sort((a, b) => a[0] - b[0]);
+	const CHUNK_SIZE = 100;
+	for (let i = 0; i < entries.length; i += CHUNK_SIZE) {
+		const chunk = entries.slice(i, i + CHUNK_SIZE);
+		lines.push(`${chunk.length} beginbfchar`);
+		for (const [cid, unicodes] of chunk) {
+			const cidHex = cid.toString(16).padStart(4, "0").toUpperCase();
+			if (unicodes.length === 1) {
+				const uniHex = unicodes[0].toString(16).padStart(4, "0").toUpperCase();
+				lines.push(`<${cidHex}> <${uniHex}>`);
+			} else {
+				let uniHex = "";
+				for (const cp of unicodes.slice(0, 1)) uniHex += cp.toString(16).padStart(4, "0").toUpperCase();
+				lines.push(`<${cidHex}> <${uniHex}>`);
+			}
+		}
+		lines.push("endbfchar");
+	}
+	lines.push("endcmap");
+	lines.push("CMapName currentdict /CMap defineresource pop");
+	lines.push("end");
+	lines.push("end");
+	return lines.join("\n");
+}
+/**
+* Generate a 6-letter uppercase tag for the subset font name.
+*
+* PDF spec recommends a tag prefix like `ABCDEF+FontName` to indicate
+* the font is subsetted.  This function generates a deterministic tag
+* from the set of glyph IDs.
+*
+* @param usedGlyphIds - The set of glyph IDs in the subset.
+* @returns A 6-character uppercase ASCII string (e.g. `"BCDEFG"`).
+*/
+function computeSubsetTag(usedGlyphIds) {
+	let hash = 0;
+	for (const gid of usedGlyphIds) hash = (hash << 5) - hash + gid | 0;
+	const tag = [];
+	let h = Math.abs(hash);
+	for (let i = 0; i < 6; i++) {
+		tag.push(String.fromCharCode(65 + h % 26));
+		h = Math.floor(h / 26);
+	}
+	return tag.join("");
+}
+
+//#endregion
+Object.defineProperty(exports, 'buildSubsetCmap', {
+  enumerable: true,
+  get: function () {
+    return buildSubsetCmap;
+  }
+});
+Object.defineProperty(exports, 'computeSubsetTag', {
+  enumerable: true,
+  get: function () {
+    return computeSubsetTag;
+  }
+});
+Object.defineProperty(exports, 'fontSubset_exports', {
+  enumerable: true,
+  get: function () {
+    return fontSubset_exports;
+  }
+});
+Object.defineProperty(exports, 'subsetFont', {
+  enumerable: true,
+  get: function () {
+    return subsetFont;
+  }
+});
+//# sourceMappingURL=fontSubset-C0Rm9ih6.cjs.map