modern-pdf-lib 0.9.0

package/dist/pngEmbed-DgeNWlbS.mjs

@@ -0,0 +1,525 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+
+//#region src/assets/image/pngEmbed.ts
+var pngEmbed_exports = /* @__PURE__ */ __exportAll({
+	embedPng: () => embedPng,
+	initPngWasm: () => initPngWasm
+});
+/** PNG file signature (8 bytes). */
+const PNG_SIGNATURE = new Uint8Array([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+/** Color type constants from the PNG spec. */
+var PngColorType = /* @__PURE__ */ function(PngColorType) {
+	PngColorType[PngColorType["Grayscale"] = 0] = "Grayscale";
+	PngColorType[PngColorType["RGB"] = 2] = "RGB";
+	PngColorType[PngColorType["Indexed"] = 3] = "Indexed";
+	PngColorType[PngColorType["GrayscaleAlpha"] = 4] = "GrayscaleAlpha";
+	PngColorType[PngColorType["RGBA"] = 6] = "RGBA";
+	return PngColorType;
+}(PngColorType || {});
+/**
+* Validate the PNG signature.
+*
+* @param data - The raw PNG bytes.
+* @throws If the signature does not match.
+*/
+function validatePngSignature(data) {
+	if (data.length < 8) throw new Error("PNG data too small — expected at least 8 bytes for the signature");
+	for (let i = 0; i < 8; i++) if (data[i] !== PNG_SIGNATURE[i]) throw new Error("Invalid PNG signature");
+}
+/**
+* Iterate over all chunks in a PNG file.
+*
+* @param data - The raw PNG bytes.
+* @returns An array of parsed chunks.
+*/
+function parseChunks(data) {
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const chunks = [];
+	let offset = 8;
+	while (offset < data.length) {
+		if (offset + 8 > data.length) break;
+		const length = view.getUint32(offset, false);
+		const type = String.fromCharCode(data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7]);
+		const chunkData = data.slice(offset + 8, offset + 8 + length);
+		chunks.push({
+			type,
+			data: chunkData
+		});
+		offset += 12 + length;
+		if (type === "IEND") break;
+	}
+	return chunks;
+}
+/**
+* Parse the IHDR chunk.
+*/
+function parseIhdr(chunk) {
+	if (chunk.type !== "IHDR" || chunk.data.length < 13) throw new Error("Invalid PNG: missing or malformed IHDR chunk");
+	const view = new DataView(chunk.data.buffer, chunk.data.byteOffset, chunk.data.byteLength);
+	return {
+		width: view.getUint32(0, false),
+		height: view.getUint32(4, false),
+		bitDepth: chunk.data[8],
+		colorType: chunk.data[9],
+		compressionMethod: chunk.data[10],
+		filterMethod: chunk.data[11],
+		interlaceMethod: chunk.data[12]
+	};
+}
+/**
+* Concatenate all IDAT chunk data into a single Uint8Array.
+*/
+function concatenateIdatChunks(chunks) {
+	const idatChunks = chunks.filter((c) => c.type === "IDAT");
+	if (idatChunks.length === 0) throw new Error("Invalid PNG: no IDAT chunks found");
+	const totalLength = idatChunks.reduce((sum, c) => sum + c.data.length, 0);
+	const result = new Uint8Array(totalLength);
+	let pos = 0;
+	for (const chunk of idatChunks) {
+		result.set(chunk.data, pos);
+		pos += chunk.data.length;
+	}
+	return result;
+}
+/**
+* Find the PLTE (palette) chunk data if present.
+*/
+function findPalette(chunks) {
+	return chunks.find((c) => c.type === "PLTE")?.data;
+}
+/**
+* Find the tRNS (transparency) chunk data if present.
+*/
+function findTransparency(chunks) {
+	return chunks.find((c) => c.type === "tRNS")?.data;
+}
+let pngWasmInstance;
+/**
+* Initialize the PNG decoding WASM module.
+*
+* @param wasmSource - The WASM binary, URL, or Response.
+*/
+async function initPngWasm(wasmSource) {
+	if (pngWasmInstance) 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 import("./loader-D9LTYmrX.mjs");
+			const bytes = await loadWasmModule("png");
+			result = await WebAssembly.instantiate(bytes.buffer, imports);
+		}
+		pngWasmInstance = result.instance.exports;
+	} catch {
+		pngWasmInstance = void 0;
+	}
+}
+/**
+* Decompress the zlib data from IDAT chunks.
+*
+* Uses the DecompressionStream API (available in modern browsers,
+* Node 18+, Deno) or falls back to a manual inflate.
+*
+* @internal
+*/
+async function decompressZlib(compressed) {
+	try {
+		const { unzlibSync } = await import("fflate");
+		return unzlibSync(compressed);
+	} catch {
+		if (typeof DecompressionStream !== "undefined") {
+			const ds = new DecompressionStream("deflate");
+			const writer = ds.writable.getWriter();
+			const reader = ds.readable.getReader();
+			writer.write(new Uint8Array(compressed)).catch(() => {});
+			writer.close().catch(() => {});
+			const chunks = [];
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				chunks.push(value);
+			}
+			const totalLength = chunks.reduce((sum, c) => sum + c.length, 0);
+			const result = new Uint8Array(totalLength);
+			let pos = 0;
+			for (const chunk of chunks) {
+				result.set(chunk, pos);
+				pos += chunk.length;
+			}
+			return result;
+		}
+		throw new Error("PNG decompression requires fflate library or DecompressionStream API");
+	}
+}
+/**
+* Apply PNG filter reconstruction to a decompressed scanline buffer.
+*
+* Each scanline is prefixed with a 1-byte filter type:
+* 0=None, 1=Sub, 2=Up, 3=Average, 4=Paeth
+*
+* @internal
+*/
+function reconstructFilters(decompressed, width, height, bytesPerPixel) {
+	const stride = width * bytesPerPixel;
+	const result = new Uint8Array(height * stride);
+	let srcOffset = 0;
+	let dstOffset = 0;
+	for (let y = 0; y < height; y++) {
+		const filterType = decompressed[srcOffset];
+		srcOffset++;
+		const scanline = decompressed.subarray(srcOffset, srcOffset + stride);
+		srcOffset += stride;
+		const prevLine = y > 0 ? result.subarray((y - 1) * stride, y * stride) : new Uint8Array(stride);
+		for (let x = 0; x < stride; x++) {
+			const raw = scanline[x];
+			const a = x >= bytesPerPixel ? result[dstOffset + x - bytesPerPixel] : 0;
+			const b = prevLine[x];
+			const c = x >= bytesPerPixel && y > 0 ? result[(y - 1) * stride + x - bytesPerPixel] : 0;
+			let reconstructed;
+			switch (filterType) {
+				case 0:
+					reconstructed = raw;
+					break;
+				case 1:
+					reconstructed = raw + a & 255;
+					break;
+				case 2:
+					reconstructed = raw + b & 255;
+					break;
+				case 3:
+					reconstructed = raw + Math.floor((a + b) / 2) & 255;
+					break;
+				case 4:
+					reconstructed = raw + paethPredictor(a, b, c) & 255;
+					break;
+				default: throw new Error(`Unknown PNG filter type: ${filterType}`);
+			}
+			result[dstOffset + x] = reconstructed;
+		}
+		dstOffset += stride;
+	}
+	return result;
+}
+/**
+* Paeth predictor function.
+* @internal
+*/
+function paethPredictor(a, b, c) {
+	const p = a + b - c;
+	const pa = Math.abs(p - a);
+	const pb = Math.abs(p - b);
+	const pc = Math.abs(p - c);
+	if (pa <= pb && pa <= pc) return a;
+	if (pb <= pc) return b;
+	return c;
+}
+/**
+* Compute the bytes per pixel for a given color type and bit depth.
+* @internal
+*/
+function bytesPerPixel(colorType, bitDepth) {
+	const channels = colorType === PngColorType.Grayscale ? 1 : colorType === PngColorType.RGB ? 3 : colorType === PngColorType.Indexed ? 1 : colorType === PngColorType.GrayscaleAlpha ? 2 : colorType === PngColorType.RGBA ? 4 : 1;
+	return Math.max(1, Math.ceil(channels * bitDepth / 8));
+}
+/**
+* Separate RGBA pixels into RGB data + alpha mask.
+* @internal
+*/
+function separateRgba(pixels, width, height) {
+	const pixelCount = width * height;
+	const rgb = new Uint8Array(pixelCount * 3);
+	const alpha = new Uint8Array(pixelCount);
+	for (let i = 0; i < pixelCount; i++) {
+		const srcIdx = i * 4;
+		const dstIdx = i * 3;
+		rgb[dstIdx] = pixels[srcIdx];
+		rgb[dstIdx + 1] = pixels[srcIdx + 1];
+		rgb[dstIdx + 2] = pixels[srcIdx + 2];
+		alpha[i] = pixels[srcIdx + 3];
+	}
+	return {
+		rgb,
+		alpha
+	};
+}
+/**
+* Separate Grayscale+Alpha pixels into gray data + alpha mask.
+* @internal
+*/
+function separateGrayscaleAlpha(pixels, width, height) {
+	const pixelCount = width * height;
+	const gray = new Uint8Array(pixelCount);
+	const alpha = new Uint8Array(pixelCount);
+	for (let i = 0; i < pixelCount; i++) {
+		gray[i] = pixels[i * 2];
+		alpha[i] = pixels[i * 2 + 1];
+	}
+	return {
+		gray,
+		alpha
+	};
+}
+/**
+* Compress data using deflate for FlateDecode.
+* @internal
+*/
+async function compressForPdf(data) {
+	const { deflateSync } = await import("fflate");
+	return deflateSync(data, { level: 6 });
+}
+/**
+* Embed a PNG image for use as a PDF image XObject.
+*
+* Parses the PNG file, decodes pixel data, separates alpha channels,
+* and produces all the data needed for the PDF image XObject
+* dictionary.
+*
+* @param pngData - The raw PNG file as a Uint8Array.
+* @returns A promise resolving to the embedding result.
+*
+* @example
+* ```ts
+* const pngBytes = await readFile('photo.png');
+* const result = await embedPng(pngBytes);
+*
+* // Create image XObject with:
+* //   /Width result.width
+* //   /Height result.height
+* //   /ColorSpace result.colorSpace
+* //   /BitsPerComponent result.bitsPerComponent
+* //   /Filter /FlateDecode
+* //   stream: result.imageData
+* //
+* // If result.smaskData is defined, create a second XObject for the SMask.
+* ```
+*/
+async function embedPng(pngData) {
+	validatePngSignature(pngData);
+	const chunks = parseChunks(pngData);
+	if (chunks.length === 0) throw new Error("Invalid PNG: no chunks found");
+	const ihdr = parseIhdr(chunks[0]);
+	const idatData = concatenateIdatChunks(chunks);
+	const palette = findPalette(chunks);
+	const transparency = findTransparency(chunks);
+	const hasAlpha = ihdr.colorType === PngColorType.GrayscaleAlpha || ihdr.colorType === PngColorType.RGBA;
+	const isInterlaced = ihdr.interlaceMethod !== 0;
+	if (ihdr.colorType === PngColorType.Indexed && !isInterlaced && ihdr.bitDepth === 8) return embedIndexedPng(ihdr, idatData, palette, transparency);
+	if (!hasAlpha && !isInterlaced && ihdr.bitDepth === 8) return embedDirectPng(ihdr, idatData, transparency);
+	return embedComplexPng(ihdr, idatData, palette, transparency);
+}
+/**
+* Embed an indexed (palette-based) PNG.
+* @internal
+*/
+async function embedIndexedPng(ihdr, idatData, palette, transparency) {
+	if (!palette) throw new Error("Invalid PNG: indexed color type requires PLTE chunk");
+	const decompressed = await decompressZlib(idatData);
+	const bpp = bytesPerPixel(ihdr.colorType, ihdr.bitDepth);
+	const pixels = reconstructFilters(decompressed, ihdr.width, ihdr.height, bpp);
+	const imageData = await compressForPdf(pixels);
+	let smaskData;
+	if (transparency && transparency.length > 0) {
+		const pixelCount = ihdr.width * ihdr.height;
+		const alpha = new Uint8Array(pixelCount);
+		for (let i = 0; i < pixelCount; i++) {
+			const paletteIndex = pixels[i];
+			alpha[i] = paletteIndex < transparency.length ? transparency[paletteIndex] : 255;
+		}
+		smaskData = await compressForPdf(alpha);
+	}
+	return {
+		width: ihdr.width,
+		height: ihdr.height,
+		bitsPerComponent: 8,
+		colorSpace: "Indexed",
+		palette,
+		imageData,
+		filter: "FlateDecode",
+		smaskData,
+		smaskBitsPerComponent: smaskData ? 8 : void 0,
+		hasTransparency: transparency !== void 0 && transparency.length > 0
+	};
+}
+/**
+* Embed a direct (Grayscale or RGB) PNG without alpha.
+* @internal
+*/
+async function embedDirectPng(ihdr, idatData, transparency) {
+	const decompressed = await decompressZlib(idatData);
+	const bpp = bytesPerPixel(ihdr.colorType, ihdr.bitDepth);
+	const pixels = reconstructFilters(decompressed, ihdr.width, ihdr.height, bpp);
+	const imageData = await compressForPdf(pixels);
+	const colorSpace = ihdr.colorType === PngColorType.Grayscale ? "DeviceGray" : "DeviceRGB";
+	let smaskData;
+	if (transparency && transparency.length > 0) {
+		const pixelCount = ihdr.width * ihdr.height;
+		const alpha = new Uint8Array(pixelCount);
+		alpha.fill(255);
+		if (ihdr.colorType === PngColorType.Grayscale && transparency.length >= 2) {
+			const trnsGray = transparency[0] << 8 | transparency[1];
+			for (let i = 0; i < pixelCount; i++) if (pixels[i] === trnsGray) alpha[i] = 0;
+			smaskData = await compressForPdf(alpha);
+		} else if (ihdr.colorType === PngColorType.RGB && transparency.length >= 6) {
+			const trnsR = transparency[0] << 8 | transparency[1];
+			const trnsG = transparency[2] << 8 | transparency[3];
+			const trnsB = transparency[4] << 8 | transparency[5];
+			for (let i = 0; i < pixelCount; i++) {
+				const idx = i * 3;
+				if (pixels[idx] === trnsR && pixels[idx + 1] === trnsG && pixels[idx + 2] === trnsB) alpha[i] = 0;
+			}
+			smaskData = await compressForPdf(alpha);
+		}
+	}
+	return {
+		width: ihdr.width,
+		height: ihdr.height,
+		bitsPerComponent: ihdr.bitDepth,
+		colorSpace,
+		imageData,
+		filter: "FlateDecode",
+		smaskData,
+		smaskBitsPerComponent: smaskData ? 8 : void 0,
+		hasTransparency: transparency !== void 0 && transparency.length > 0
+	};
+}
+/**
+* Full decompression path for PNGs that need alpha separation,
+* de-interlacing, or bit-depth normalization.
+* @internal
+*/
+async function embedComplexPng(ihdr, idatData, palette, transparency) {
+	const decompressed = await decompressZlib(idatData);
+	const bpp = bytesPerPixel(ihdr.colorType, ihdr.bitDepth);
+	let pixels;
+	if (ihdr.interlaceMethod !== 0) {
+		const startingRow = [
+			0,
+			0,
+			4,
+			0,
+			2,
+			0,
+			1
+		];
+		const startingCol = [
+			0,
+			4,
+			0,
+			2,
+			0,
+			1,
+			0
+		];
+		const rowStride = [
+			8,
+			8,
+			8,
+			4,
+			4,
+			2,
+			2
+		];
+		const colStride = [
+			8,
+			8,
+			4,
+			4,
+			2,
+			2,
+			1
+		];
+		const stride = ihdr.width * bpp;
+		const finalPixels = new Uint8Array(ihdr.height * stride);
+		let srcOffset = 0;
+		for (let pass = 0; pass < 7; pass++) {
+			const startRow = startingRow[pass];
+			const startCol = startingCol[pass];
+			const rStride = rowStride[pass];
+			const cStride = colStride[pass];
+			const passWidth = ihdr.width <= startCol ? 0 : Math.ceil((ihdr.width - startCol) / cStride);
+			const passHeight = ihdr.height <= startRow ? 0 : Math.ceil((ihdr.height - startRow) / rStride);
+			if (passWidth === 0 || passHeight === 0) continue;
+			const passDataLength = passHeight * (1 + passWidth * bpp);
+			const passData = decompressed.subarray(srcOffset, srcOffset + passDataLength);
+			srcOffset += passDataLength;
+			const passPixels = reconstructFilters(passData, passWidth, passHeight, bpp);
+			for (let py = 0; py < passHeight; py++) {
+				const finalY = startRow + py * rStride;
+				for (let px = 0; px < passWidth; px++) {
+					const finalX = startCol + px * cStride;
+					const srcIdx = (py * passWidth + px) * bpp;
+					const dstIdx = finalY * stride + finalX * bpp;
+					for (let b = 0; b < bpp; b++) finalPixels[dstIdx + b] = passPixels[srcIdx + b];
+				}
+			}
+		}
+		pixels = finalPixels;
+	} else pixels = reconstructFilters(decompressed, ihdr.width, ihdr.height, bpp);
+	let imageData;
+	let smaskData;
+	let colorSpace;
+	let bitsPerComponent = ihdr.bitDepth;
+	switch (ihdr.colorType) {
+		case PngColorType.RGBA: {
+			const { rgb, alpha } = separateRgba(pixels, ihdr.width, ihdr.height);
+			imageData = await compressForPdf(rgb);
+			smaskData = await compressForPdf(alpha);
+			colorSpace = "DeviceRGB";
+			bitsPerComponent = 8;
+			break;
+		}
+		case PngColorType.GrayscaleAlpha: {
+			const { gray, alpha } = separateGrayscaleAlpha(pixels, ihdr.width, ihdr.height);
+			imageData = await compressForPdf(gray);
+			smaskData = await compressForPdf(alpha);
+			colorSpace = "DeviceGray";
+			bitsPerComponent = 8;
+			break;
+		}
+		case PngColorType.Grayscale:
+			imageData = await compressForPdf(pixels);
+			colorSpace = "DeviceGray";
+			break;
+		case PngColorType.RGB:
+			imageData = await compressForPdf(pixels);
+			colorSpace = "DeviceRGB";
+			break;
+		case PngColorType.Indexed:
+			if (!palette) throw new Error("Invalid PNG: indexed color type requires PLTE chunk");
+			imageData = await compressForPdf(pixels);
+			colorSpace = "Indexed";
+			bitsPerComponent = ihdr.bitDepth;
+			break;
+		default: throw new Error(`Unsupported PNG color type: ${ihdr.colorType}`);
+	}
+	return {
+		width: ihdr.width,
+		height: ihdr.height,
+		bitsPerComponent,
+		colorSpace,
+		palette: ihdr.colorType === PngColorType.Indexed ? palette : void 0,
+		imageData,
+		filter: "FlateDecode",
+		smaskData,
+		smaskBitsPerComponent: smaskData ? 8 : void 0,
+		hasTransparency: smaskData !== void 0 || transparency !== void 0 && transparency.length > 0
+	};
+}
+
+//#endregion
+export { pngEmbed_exports as n, embedPng as t };
+//# sourceMappingURL=pngEmbed-DgeNWlbS.mjs.map

package/dist/rolldown-runtime-95iHPtFO.mjs

@@ -0,0 +1,18 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll as t };

package/dist/rolldown-runtime-CKhH4XqG.cjs

@@ -0,0 +1,24 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+
+Object.defineProperty(exports, '__exportAll', {
+  enumerable: true,
+  get: function () {
+    return __exportAll;
+  }
+});

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "modern-pdf-lib",
+  "version": "0.9.0",
+  "description": "A modern, WASM-accelerated PDF creation engine for every JavaScript runtime",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./wasm/*": "./dist/wasm/*"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist/**/*.mjs",
+    "dist/**/*.cjs",
+    "dist/**/*.d.mts",
+    "dist/**/*.d.cts",
+    "dist/**/*.d.mts.map",
+    "dist/**/*.d.cts.map",
+    "LICENSE",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsdown",
+    "build:wasm": "bash scripts/build-wasm.sh",
+    "build:all": "npm run build:wasm && npm run build",
+    "dev": "vite",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:integration": "vitest run tests/integration",
+    "test:e2e": "playwright test",
+    "test:bench": "vitest bench",
+    "lint": "eslint src/ tests/",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:api": "typedoc",
+    "validate-pdf": "tsx scripts/validate-pdf.ts",
+    "clean": "rm -rf dist coverage"
+  },
+  "dependencies": {
+    "fflate": "0.8.2"
+  },
+  "devDependencies": {
+    "typescript": "6.0.0-dev.20260227",
+    "tsdown": "0.21.0-beta.2",
+    "esbuild": "0.27.3",
+    "rollup": "4.59.0",
+    "vite": "8.0.0-beta.16",
+    "vitest": "4.1.0-beta.5",
+    "miniflare": "4.20260305.0",
+    "@playwright/test": "1.59.0-alpha-2026-02-27",
+    "vitepress": "2.0.0-alpha.16",
+    "typedoc": "0.28.17",
+    "typedoc-plugin-markdown": "4.10.0",
+    "eslint": "10.0.2",
+    "@eslint/js": "10.0.1",
+    "typescript-eslint": "8.56.2-alpha.1",
+    "prettier": "3.8.1",
+    "fast-png": "8.0.0",
+    "tsx": "4.21.0",
+    "wasm-pack": "0.14.0"
+  },
+  "keywords": [
+    "pdf",
+    "pdf-generation",
+    "wasm",
+    "typescript",
+    "esm",
+    "cloudflare-workers",
+    "streaming"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ABCrimson/modern-pdf-lib.git"
+  },
+  "homepage": "https://github.com/ABCrimson/modern-pdf-lib#readme",
+  "bugs": {
+    "url": "https://github.com/ABCrimson/modern-pdf-lib/issues"
+  }
+}