modern-pdf-lib 0.26.0 → 0.28.0

package/dist/pngEmbed-CTn9IeNB.cjs

@@ -1,563 +0,0 @@
-const require_rolldown_runtime = require('./rolldown-runtime-CKhH4XqG.cjs');
-let fflate = require("fflate");
-
-//#region src/assets/image/pngEmbed.ts
-/**
-* @module assets/image/pngEmbed
-*
-* PNG decoding and embedding for PDF image XObjects.
-*
-* Parses a PNG file to extract dimensions, color type, bit depth, and
-* pixel data.  Produces the data needed for a PDF image XObject
-* dictionary with the appropriate `/ColorSpace`, `/BitsPerComponent`,
-* `/Filter`, and `/SMask` entries.
-*
-* Handles all standard PNG color types:
-* - Type 0: Grayscale
-* - Type 2: RGB (Truecolor)
-* - Type 3: Indexed (Palette)
-* - Type 4: Grayscale + Alpha
-* - Type 6: RGBA (Truecolor + Alpha)
-*
-* For images with alpha channels (types 4 and 6), the alpha channel
-* is separated into a /SMask soft-mask image.
-*
-* WASM-accelerated decoding is supported with a JS fallback.
-*
-* No Buffer — uses Uint8Array exclusively.
-* No fs — no file system access.
-* No require() — ESM import only.
-*/
-var pngEmbed_exports = /* @__PURE__ */ require_rolldown_runtime.__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 Promise.resolve().then(() => require("./loader-DYCH3n7d.cjs")).then((n) => n.loader_exports);
-			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
-*/
-function decompressZlib(compressed) {
-	return (0, fflate.unzlibSync)(compressed);
-}
-/**
-* 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
-*/
-function compressForPdf(data) {
-	return (0, fflate.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 The embedding result with all data needed for a PDF image XObject.
-*
-* @example
-* ```ts
-* const pngBytes = await readFile('photo.png');
-* const result = 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.
-* ```
-*/
-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
-*/
-function embedIndexedPng(ihdr, idatData, palette, transparency) {
-	if (!palette) throw new Error("Invalid PNG: indexed color type requires PLTE chunk");
-	if (!transparency || transparency.length === 0) return {
-		width: ihdr.width,
-		height: ihdr.height,
-		bitsPerComponent: 8,
-		colorSpace: "Indexed",
-		palette,
-		imageData: idatData,
-		filter: "FlateDecode",
-		hasTransparency: false,
-		decodeParms: {
-			predictor: 15,
-			columns: ihdr.width,
-			colors: 1,
-			bitsPerComponent: 8
-		}
-	};
-	const decompressed = decompressZlib(idatData);
-	const bpp = bytesPerPixel(ihdr.colorType, ihdr.bitDepth);
-	const pixels = reconstructFilters(decompressed, ihdr.width, ihdr.height, bpp);
-	const imageData = compressForPdf(pixels);
-	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;
-	}
-	const smaskData = compressForPdf(alpha);
-	return {
-		width: ihdr.width,
-		height: ihdr.height,
-		bitsPerComponent: 8,
-		colorSpace: "Indexed",
-		palette,
-		imageData,
-		filter: "FlateDecode",
-		smaskData,
-		smaskBitsPerComponent: 8,
-		hasTransparency: true
-	};
-}
-/**
-* Embed a direct (Grayscale or RGB) PNG without alpha.
-* @internal
-*/
-function embedDirectPng(ihdr, idatData, transparency) {
-	const colorSpace = ihdr.colorType === PngColorType.Grayscale ? "DeviceGray" : "DeviceRGB";
-	const colors = ihdr.colorType === PngColorType.Grayscale ? 1 : 3;
-	if (!transparency || transparency.length === 0) return {
-		width: ihdr.width,
-		height: ihdr.height,
-		bitsPerComponent: ihdr.bitDepth,
-		colorSpace,
-		imageData: idatData,
-		filter: "FlateDecode",
-		hasTransparency: false,
-		decodeParms: {
-			predictor: 15,
-			columns: ihdr.width,
-			colors,
-			bitsPerComponent: ihdr.bitDepth
-		}
-	};
-	const decompressed = decompressZlib(idatData);
-	const bpp = bytesPerPixel(ihdr.colorType, ihdr.bitDepth);
-	const pixels = reconstructFilters(decompressed, ihdr.width, ihdr.height, bpp);
-	const imageData = compressForPdf(pixels);
-	let smaskData;
-	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 = 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 = compressForPdf(alpha);
-	}
-	return {
-		width: ihdr.width,
-		height: ihdr.height,
-		bitsPerComponent: ihdr.bitDepth,
-		colorSpace,
-		imageData,
-		filter: "FlateDecode",
-		smaskData,
-		smaskBitsPerComponent: smaskData ? 8 : void 0,
-		hasTransparency: true
-	};
-}
-/**
-* Full decompression path for PNGs that need alpha separation,
-* de-interlacing, or bit-depth normalization.
-* @internal
-*/
-function embedComplexPng(ihdr, idatData, palette, transparency) {
-	const decompressed = 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 = compressForPdf(rgb);
-			smaskData = compressForPdf(alpha);
-			colorSpace = "DeviceRGB";
-			bitsPerComponent = 8;
-			break;
-		}
-		case PngColorType.GrayscaleAlpha: {
-			const { gray, alpha } = separateGrayscaleAlpha(pixels, ihdr.width, ihdr.height);
-			imageData = compressForPdf(gray);
-			smaskData = compressForPdf(alpha);
-			colorSpace = "DeviceGray";
-			bitsPerComponent = 8;
-			break;
-		}
-		case PngColorType.Grayscale:
-			imageData = compressForPdf(pixels);
-			colorSpace = "DeviceGray";
-			break;
-		case PngColorType.RGB:
-			imageData = compressForPdf(pixels);
-			colorSpace = "DeviceRGB";
-			break;
-		case PngColorType.Indexed:
-			if (!palette) throw new Error("Invalid PNG: indexed color type requires PLTE chunk");
-			imageData = 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
-Object.defineProperty(exports, 'embedPng', {
-  enumerable: true,
-  get: function () {
-    return embedPng;
-  }
-});
-Object.defineProperty(exports, 'pngEmbed_exports', {
-  enumerable: true,
-  get: function () {
-    return pngEmbed_exports;
-  }
-});
-//# sourceMappingURL=pngEmbed-CTn9IeNB.cjs.map

package/dist/rolldown-runtime-CKhH4XqG.cjs

@@ -1,24 +0,0 @@
-//#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;
-  }
-});