modern-pdf-lib 0.11.6 → 0.12.1

package/README.md

@@ -15,7 +15,7 @@ Create, parse, fill, merge, sign, and manipulate PDF documents<br />in Node, Den
 
 [![npm version](https://img.shields.io/npm/v/modern-pdf-lib?style=flat-square&color=cb3837)](https://www.npmjs.com/package/modern-pdf-lib)
 [![bundle size](https://img.shields.io/badge/gzip-36kb_core-blue?style=flat-square)](https://bundlephobia.com/package/modern-pdf-lib)
-[![tests](https://img.shields.io/badge/tests-1%2C952_passing-brightgreen?style=flat-square)](#)
+[![tests](https://img.shields.io/badge/tests-1%2C973_passing-brightgreen?style=flat-square)](#)
 [![TypeScript](https://img.shields.io/badge/TypeScript-6.0-3178c6?style=flat-square&logo=typescript&logoColor=white)](#)
 [![License: MIT](https://img.shields.io/badge/license-MIT-yellow?style=flat-square)](LICENSE)
 
@@ -429,7 +429,7 @@ modern-pdf-lib/
     outline/        Bookmarks / document outline
     metadata/       XMP metadata, viewer preferences
     wasm/           Rust crate sources (4 modules)
-  tests/            1,952 tests across 90 suites
+  tests/            1,973 tests across 91 suites
   docs/             VitePress documentation
 ```
 
@@ -441,7 +441,7 @@ modern-pdf-lib/
 git clone https://github.com/ABCrimson/modern-pdf-lib.git
 cd modern-pdf-lib
 npm install
-npm test          # 1,952 tests
+npm test          # 1,973 tests
 npm run typecheck # TypeScript 6.0 strict
 npm run build     # ESM + CJS + declarations
 ```

package/dist/{fflateAdapter-cT4YeY_h.cjs → fflateAdapter-AHC_S3cb.cjs}

@@ -204,4 +204,4 @@ Object.defineProperty(exports, 'fflateAdapter_exports', {
     return fflateAdapter_exports;
   }
 });
-//# sourceMappingURL=fflateAdapter-cT4YeY_h.cjs.map
+//# sourceMappingURL=fflateAdapter-AHC_S3cb.cjs.map

package/dist/{fflateAdapter-D2mv_ttM.mjs → fflateAdapter-DX0VqT5k.mjs}

@@ -193,4 +193,4 @@ var FflateEngine = class {
 
 //#endregion
 export { fflateAdapter_exports as n, decompressSync as t };
-//# sourceMappingURL=fflateAdapter-D2mv_ttM.mjs.map
+//# sourceMappingURL=fflateAdapter-DX0VqT5k.mjs.map

package/dist/fontSubset-ZpLoOZ2e.mjs

@@ -0,0 +1,495 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+
+//#region src/assets/font/ttfSubset.ts
+/**
+* @module assets/font/ttfSubset
+*
+* Pure TypeScript TrueType font subsetter.
+*
+* Reduces font file size by replacing glyph outline data for unused
+* glyphs with zero-length entries. Keeps all glyph ID slots intact
+* so that `CIDToGIDMap /Identity` (CID = GID) continues to work
+* without any changes to the PDF embedding pipeline.
+*
+* The subsetter:
+* 1. Parses the TrueType table directory and `loca`/`glyf` tables.
+* 2. Resolves composite glyph dependencies (component glyphs).
+* 3. Builds a new `glyf` table containing only data for retained glyphs.
+* 4. Builds a new `loca` table with updated offsets.
+* 5. Reassembles a valid TrueType font with correct checksums.
+*
+* No external dependencies. No Buffer — uses Uint8Array and DataView.
+*/
+/** Composite glyph flag: arguments are 16-bit instead of 8-bit. */
+const ARG_1_AND_2_ARE_WORDS = 1;
+/** Composite glyph flag: a single F2Dot14 scale follows. */
+const WE_HAVE_A_SCALE = 8;
+/** Composite glyph flag: more component records follow. */
+const MORE_COMPONENTS = 32;
+/** Composite glyph flag: separate X and Y scales follow. */
+const WE_HAVE_AN_X_AND_Y_SCALE = 64;
+/** Composite glyph flag: a 2×2 transformation matrix follows. */
+const WE_HAVE_A_TWO_BY_TWO = 128;
+function parseTableDir(data) {
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const numTables = view.getUint16(4, false);
+	const tables = /* @__PURE__ */ new Map();
+	const requiredLen = 12 + numTables * 16;
+	if (data.length < requiredLen) throw new RangeError("Font data too small for table directory");
+	for (let i = 0; i < numTables; i++) {
+		const off = 12 + i * 16;
+		const tag = String.fromCharCode(data[off], data[off + 1], data[off + 2], data[off + 3]);
+		tables.set(tag, {
+			tag,
+			offset: view.getUint32(off + 8, false),
+			length: view.getUint32(off + 12, false)
+		});
+	}
+	return tables;
+}
+/**
+* Parse the `loca` table to get glyph offsets within the `glyf` table.
+*
+* Returns an array of `numGlyphs + 1` offsets. The glyph data for
+* glyph `i` spans from `offsets[i]` to `offsets[i+1]`. A zero-length
+* span means the glyph has no outline (e.g. space or unused).
+*/
+function parseLoca(data, locaOffset, locaLength, numGlyphs, indexToLocFormat) {
+	const view = new DataView(data.buffer, data.byteOffset + locaOffset, locaLength);
+	const offsets = [];
+	const count = numGlyphs + 1;
+	if (indexToLocFormat === 0) for (let i = 0; i < count; i++) offsets.push(view.getUint16(i * 2, false) * 2);
+	else for (let i = 0; i < count; i++) offsets.push(view.getUint32(i * 4, false));
+	return offsets;
+}
+/**
+* Scan composite glyphs and collect all component glyph IDs that are
+* referenced (directly or transitively).
+*/
+function resolveCompositeDeps(data, glyfOffset, locaOffsets, usedGids) {
+	const retained = new Set(usedGids);
+	const queue = [...usedGids];
+	while (queue.length > 0) {
+		const gid = queue.pop();
+		const glyphStart = glyfOffset + locaOffsets[gid];
+		if (glyfOffset + locaOffsets[gid + 1] <= glyphStart) continue;
+		const view = new DataView(data.buffer, data.byteOffset);
+		if (view.getInt16(glyphStart, false) >= 0) continue;
+		let off = glyphStart + 10;
+		let flags;
+		do {
+			flags = view.getUint16(off, false);
+			const componentGid = view.getUint16(off + 2, false);
+			off += 4;
+			if (!retained.has(componentGid)) {
+				retained.add(componentGid);
+				queue.push(componentGid);
+			}
+			if (flags & ARG_1_AND_2_ARE_WORDS) off += 4;
+			else off += 2;
+			if (flags & WE_HAVE_A_SCALE) off += 2;
+			else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) off += 4;
+			else if (flags & WE_HAVE_A_TWO_BY_TWO) off += 8;
+		} while (flags & MORE_COMPONENTS);
+	}
+	return retained;
+}
+function calcTableChecksum(data, offset, length) {
+	const aligned = length + 3 & -4;
+	let sum = 0;
+	const view = new DataView(data.buffer, data.byteOffset + offset);
+	for (let i = 0; i < aligned; i += 4) if (i + 3 < length) sum = sum + view.getUint32(i, false) >>> 0;
+	else {
+		let val = 0;
+		for (let j = 0; j < 4; j++) val = val << 8 | (i + j < length ? data[offset + i + j] : 0);
+		sum = sum + val >>> 0;
+	}
+	return sum;
+}
+function writeTag(buf, offset, tag) {
+	buf[offset] = tag.charCodeAt(0);
+	buf[offset + 1] = tag.charCodeAt(1);
+	buf[offset + 2] = tag.charCodeAt(2);
+	buf[offset + 3] = tag.charCodeAt(3);
+}
+/**
+* Compute `searchRange`, `entrySelector`, `rangeShift` for the offset
+* table header.
+*/
+function offsetTableParams(numTables) {
+	let entrySelector = 0;
+	let searchRange = 1;
+	while (searchRange * 2 <= numTables) {
+		searchRange *= 2;
+		entrySelector++;
+	}
+	searchRange *= 16;
+	const rangeShift = numTables * 16 - searchRange;
+	return {
+		searchRange,
+		entrySelector,
+		rangeShift
+	};
+}
+/**
+* Subset a TrueType font, keeping only glyph outlines for the
+* specified glyph IDs.
+*
+* Unused glyphs become zero-length entries in the `glyf` table.
+* All glyph ID slots are preserved so `CIDToGIDMap /Identity` still
+* works. Composite glyph dependencies are resolved automatically.
+*
+* @param fontData     The raw TrueType font bytes.
+* @param usedGlyphIds Set of glyph IDs to retain (GID 0 is always kept).
+* @returns The subsetted font bytes.
+*/
+function subsetTtf(fontData, usedGlyphIds) {
+	if (fontData.length < 28) return new Uint8Array(fontData);
+	let tables;
+	try {
+		tables = parseTableDir(fontData);
+	} catch {
+		return new Uint8Array(fontData);
+	}
+	const headEntry = tables.get("head");
+	const locaEntry = tables.get("loca");
+	const glyfEntry = tables.get("glyf");
+	const maxpEntry = tables.get("maxp");
+	if (!headEntry || !locaEntry || !glyfEntry || !maxpEntry) return new Uint8Array(fontData);
+	const view = new DataView(fontData.buffer, fontData.byteOffset, fontData.byteLength);
+	const indexToLocFormat = view.getInt16(headEntry.offset + 50, false);
+	const numGlyphs = view.getUint16(maxpEntry.offset + 4, false);
+	const locaOffsets = parseLoca(fontData, locaEntry.offset, locaEntry.length, numGlyphs, indexToLocFormat);
+	const allUsed = new Set(usedGlyphIds);
+	allUsed.add(0);
+	const retained = resolveCompositeDeps(fontData, glyfEntry.offset, locaOffsets, allUsed);
+	let newGlyfSize = 0;
+	for (let gid = 0; gid < numGlyphs; gid++) if (retained.has(gid)) {
+		const glyphLen = locaOffsets[gid + 1] - locaOffsets[gid];
+		newGlyfSize += glyphLen + 1 & -2;
+	}
+	const newGlyf = new Uint8Array(newGlyfSize);
+	const newLocaOffsets = [];
+	let glyfPos = 0;
+	for (let gid = 0; gid < numGlyphs; gid++) {
+		newLocaOffsets.push(glyfPos);
+		if (retained.has(gid)) {
+			const srcStart = glyfEntry.offset + locaOffsets[gid];
+			const glyphLen = locaOffsets[gid + 1] - locaOffsets[gid];
+			if (glyphLen > 0) {
+				newGlyf.set(fontData.subarray(srcStart, srcStart + glyphLen), glyfPos);
+				glyfPos += glyphLen + 1 & -2;
+			}
+		}
+	}
+	newLocaOffsets.push(glyfPos);
+	const useShortLoca = glyfPos <= 131070;
+	let newLocaSize;
+	let newLoca;
+	if (useShortLoca) {
+		newLocaSize = (numGlyphs + 1) * 2;
+		newLoca = new Uint8Array(newLocaSize);
+		const locaView = new DataView(newLoca.buffer);
+		for (let i = 0; i <= numGlyphs; i++) locaView.setUint16(i * 2, newLocaOffsets[i] >>> 1, false);
+	} else {
+		newLocaSize = (numGlyphs + 1) * 4;
+		newLoca = new Uint8Array(newLocaSize);
+		const locaView = new DataView(newLoca.buffer);
+		for (let i = 0; i <= numGlyphs; i++) locaView.setUint32(i * 4, newLocaOffsets[i], false);
+	}
+	const copyTags = [
+		"hhea",
+		"maxp",
+		"OS/2",
+		"name",
+		"cmap",
+		"post",
+		"cvt ",
+		"fpgm",
+		"prep",
+		"hmtx",
+		"gasp",
+		"GDEF",
+		"GPOS",
+		"GSUB"
+	];
+	const outputTables = [];
+	const newHead = new Uint8Array(headEntry.length);
+	newHead.set(fontData.subarray(headEntry.offset, headEntry.offset + headEntry.length));
+	const headView = new DataView(newHead.buffer);
+	headView.setInt16(50, useShortLoca ? 0 : 1, false);
+	headView.setUint32(8, 0, false);
+	outputTables.push({
+		tag: "head",
+		data: newHead
+	});
+	for (const tag of copyTags) {
+		const entry = tables.get(tag);
+		if (entry) outputTables.push({
+			tag,
+			data: fontData.subarray(entry.offset, entry.offset + entry.length)
+		});
+	}
+	outputTables.push({
+		tag: "loca",
+		data: newLoca
+	});
+	outputTables.push({
+		tag: "glyf",
+		data: newGlyf
+	});
+	const numOutputTables = outputTables.length;
+	const { searchRange, entrySelector, rangeShift } = offsetTableParams(numOutputTables);
+	const headerSize = 12;
+	const dirSize = numOutputTables * 16;
+	let totalSize = headerSize + dirSize;
+	for (const t of outputTables) totalSize += t.data.length + 3 & -4;
+	const output = new Uint8Array(totalSize);
+	const outView = new DataView(output.buffer);
+	outView.setUint32(0, 65536, false);
+	outView.setUint16(4, numOutputTables, false);
+	outView.setUint16(6, searchRange, false);
+	outView.setUint16(8, entrySelector, false);
+	outView.setUint16(10, rangeShift, false);
+	let dataOffset = headerSize + dirSize;
+	for (let i = 0; i < outputTables.length; i++) {
+		const t = outputTables[i];
+		const dirOff = headerSize + i * 16;
+		const alignedLen = t.data.length + 3 & -4;
+		output.set(t.data, dataOffset);
+		const checksum = calcTableChecksum(output, dataOffset, t.data.length);
+		writeTag(output, dirOff, t.tag);
+		outView.setUint32(dirOff + 4, checksum, false);
+		outView.setUint32(dirOff + 8, dataOffset, false);
+		outView.setUint32(dirOff + 12, t.data.length, false);
+		dataOffset += alignedLen;
+	}
+	const adjustment = 2981146554 - calcTableChecksum(output, 0, output.length) >>> 0;
+	for (let i = 0; i < outputTables.length; i++) if (outputTables[i].tag === "head") {
+		const headDataOff = outView.getUint32(headerSize + i * 16 + 8, false);
+		outView.setUint32(headDataOff + 8, adjustment, false);
+		const newHeadChecksum = calcTableChecksum(output, headDataOff, outputTables[i].data.length);
+		outView.setUint32(headerSize + i * 16 + 4, newHeadChecksum, false);
+		break;
+	}
+	return output;
+}
+
+//#endregion
+//#region src/assets/font/fontSubset.ts
+/**
+* @module assets/font/fontSubset
+*
+* Font subsetting — removes unused glyphs from a TrueType font to
+* reduce file size.  Offers WASM-accelerated subsetting with a pure
+* JS subsetter as the default.
+*
+* The JS subsetter replaces unused glyph outlines with zero-length
+* entries in the `glyf` table, preserving all glyph ID slots so that
+* `CIDToGIDMap /Identity` continues to work without changes to the
+* PDF embedding pipeline.  Composite glyph dependencies are resolved
+* automatically.
+*
+* Also builds CMap streams for the subset encoding, mapping CIDs to
+* Unicode codepoints (required for PDF text extraction / copy-paste).
+*
+* No Buffer — uses Uint8Array exclusively.
+* No fs — no file system access.
+* No require() — ESM import only.
+*/
+var fontSubset_exports = /* @__PURE__ */ __exportAll({
+	buildSubsetCmap: () => buildSubsetCmap,
+	computeSubsetTag: () => computeSubsetTag,
+	initSubsetWasm: () => initSubsetWasm,
+	subsetFont: () => subsetFont
+});
+/**
+* WASM subsetter is not available — the TTF WASM module (`src/wasm/ttf`)
+* provides `parse_font()` for metric extraction but does NOT include a
+* `subset_font()` export. The pure JS subsetter (`ttfSubset.ts`) is
+* the primary subsetting path for all runtimes.
+*
+* This flag exists for forward-compatibility: a dedicated subsetting
+* WASM module could be added in the future.
+*/
+let wasmSubsetReady = false;
+/**
+* Initialize the font subsetting WASM module.
+*
+* **Note:** No WASM subsetter currently exists — the TTF WASM module
+* only parses fonts, it does not subset them. The pure JS subsetter
+* (`subsetTtf`) handles all subsetting. This function is a no-op
+* placeholder for forward-compatibility.
+*
+* @param _wasmSource - Unused. Reserved for a future WASM subsetter.
+*/
+async function initSubsetWasm(_wasmSource) {
+	wasmSubsetReady = false;
+}
+/**
+* Subset a font using a WASM module.
+*
+* Currently no WASM subsetter exists — this delegates to the JS subsetter.
+* Reserved for forward-compatibility with a future WASM subsetting module.
+*
+* @internal
+*/
+function subsetWithWasm(fontData, usedGlyphIds) {
+	return subsetJs(fontData, usedGlyphIds);
+}
+/**
+* Subset a TrueType font using the pure JS subsetter.
+*
+* Replaces unused glyph outline data with zero-length entries in the
+* `glyf` table while preserving all glyph ID slots.  This keeps
+* `CIDToGIDMap /Identity` working (CID = GID) while dramatically
+* reducing the font program size.
+*
+* Composite glyph dependencies are resolved automatically — if a used
+* glyph references component glyphs, those components are retained too.
+*
+* The `newToOldGid` array contains the used glyph IDs in sorted order.
+* Since glyph IDs are not renumbered, each "new" GID equals the
+* original GID (identity mapping for the used glyphs).
+*
+* @param fontData      The raw TTF font file bytes.
+* @param usedGlyphIds  Set of glyph IDs that are actually used.
+* @returns A {@link SubsetResult} with the subsetted font bytes and
+*          identity glyph-ID mappings for the used glyphs.
+* @internal
+*/
+function subsetJs(fontData, usedGlyphIds) {
+	const allGids = new Set(usedGlyphIds);
+	allGids.add(0);
+	const subsetFontData = subsetTtf(fontData, allGids);
+	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: subsetFontData,
+		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 subsetJs(fontData, new Set([0]));
+	if (wasmSubsetReady) return subsetWithWasm(fontData, usedGlyphIds);
+	return subsetJs(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
+export { subsetFont as i, computeSubsetTag as n, fontSubset_exports as r, buildSubsetCmap as t };
+//# sourceMappingURL=fontSubset-ZpLoOZ2e.mjs.map