pdf-codec 4.4.0 → 4.5.0

package/README.md

@@ -264,6 +264,7 @@ Dependency direction is strictly downward and checkable: `layout` imports only `
 - **Nothing in this codec's reader accepts, prompts for, or guesses a password.** Authenticating as owner is a permissions escalation, not a way to read a file you were already allowed to read.
 - **`writePdf` produces real, spec-conformant encryption for all four of the schemes above** (`src/encrypt-write.ts`, `WritePdfOptions.encryption`) — genuine `/O`/`/U`/`/OE`/`/UE`/`/Perms` computation per ISO 32000-2 7.6.4.4's Algorithms 3, 8, 9, and 10, a real user and (optional, defaulting to the user password) owner password, and per-`/P`-bit permission flags. Unlike the reader, the writer's own password is not scoped to empty: a genuinely non-empty user password is fully supported and round-trips against the published algorithm (see `encrypt-write.test.ts`), even though this package's own reader — scoped as above — can only ever open the result back up if the user password used to encrypt it was itself empty. Two boundaries are deliberately narrower than the full spec rather than approximated silently: a revision 2-4 (rc4-40/rc4-128/aes-128) password must be plain printable ASCII, not the full 8-bit PDFDocEncoding table, and a revision 6 (aes-256) password is Unicode-normalised with NFKC rather than the full SASLPrep/stringprep profile (prohibited-character tables and the bidirectional-text rule are not implemented). Both throw `PdfEncryptionError` for a password outside that scope rather than silently mis-encoding it into one that will not open the file it was meant to protect.
 - **`CCITTFaxDecode`, `JBIG2Decode` and `JPXDecode` images all decode for real** via hand-written decoders (`src/image/ccitt.ts` for ITU-T T.4/T.6 fax; `src/image/jbig2*.ts` for ITU-T T.88; `src/image/jpeg2000*.ts` for ISO/IEC 15444-1). JPEG images (`DCTDecode`) pass through losslessly in both directions. See [JBIG2 scope](#jbig2-scope) and [JPEG 2000 scope](#jpeg-2000-scope) for exactly what is and is not implemented.
+- **The write side re-encodes bilevel images as CCITT Group 4** (`src/image/ccitt-encode.ts`, a hand-written ITU-T T.6 encoder sharing the decoder's own code-table transcription): a grayscale image whose samples are all 0 or 255, with no soft mask, is written as `/CCITTFaxDecode` with `/K -1` whenever the G4 encoding comes out smaller than Flate over the same pixels — which for vertically coherent bilevel content (a scan's edges and text baselines) it does by an order of magnitude. Whichever encoding is smaller wins, deterministically, so decorrelated or repetitive bilevel content where Flate happens to win keeps Flate. **JBIG2 and JPEG 2000 re-encoding are permanent boundaries, not gaps**: a hand-written JBIG2 encoder is research-grade symbol-dictionary design and a JPEG 2000 encoder is the full EBCOT/wavelet stack, and re-encoding lossy JPX back is not fidelity-preserving anyway. Verbatim passthrough of a source's original JBIG2/JPX compressed bytes would need `LayoutImageAsset` and `document-schema.js`'s own `ContentImageBlock` to carry the original filter and bytes (the model normalises to decoded pixels at read time), a cross-package schema design change recorded in #975's scorecard rather than smuggled into this feature.
 - **`interpret.ts` tracks general vector paths, not just axis-aligned `re` rectangles.** `m`/`l`/`c`/`v`/`y`/`h` (and `re` itself) accumulate real subpaths — CTM-transformed line/cubic segments, open or closed — and any paint operator emits an item built from them. A recovered path matching one of three characteristic shape patterns comes back as that shape's own kind, not a generic `LayoutPath`: an axis-aligned closed four-corner subpath is a `LayoutRect`; a closed subpath of four cubic segments meeting its bounding box at cardinal points with kappa-ratio control points is a `LayoutEllipse`; an open single-straight-segment stroke-only subpath is a `LayoutLine` (tolerance: `max(1e-3pt, 1e-4 × extent)`). **These are deliberate, bounded heuristics** — a false positive changes an item's kind, never its geometry, since every detected shape reproduces its source path's own points exactly. Off-axis rotations, non-quadrant curves, polygons, and multi-subpath figures stay a `LayoutPath`.
 - **`writePdf`/`readPdf` round-trip a page's own `notes` field via a hidden `/Subtype /Text` annotation** with the `Hidden` flag set so it never renders or prints, distinguished from a genuine third-party sticky note by an internal author marker. This is a round-trip mechanism specific to this package's own writer/reader pair. `documents.js` uses this to carry pptx/odp speaker notes through PDF.
 - **STIX Two Math is a CFF-flavoured OpenType font, not TrueType/glyf** — the **entire** `CFF ` table is embedded verbatim as a single `/FontFile3` `/Subtype /CIDFontType0C` stream (a real, correct, working embedded font, just not glyph-subsetted). Everything else genuinely IS built from a targeted parse of only what's used: `cmap` resolves exactly the Unicode code points a document's formulas reference, and the emitted `/W` widths array covers only drawn glyph IDs. A CID-keyed composite font built this way needs no `/CIDToGIDMap` — per ISO 32000-1 9.7.4.2, a `/CIDFontType0` whose `/FontFile3` is a non-CID-keyed CFF program is read with CID directly indexing `CharStrings` by glyph order (CID == GID).

package/dist/image/ccitt-encode.cjs

@@ -0,0 +1,119 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_image_ccitt = require("./ccitt.cjs");
+//#region src/image/ccitt-encode.ts
+function buildRunCodes(table) {
+	const map = /* @__PURE__ */ new Map();
+	for (const [bits, run] of table) map.set(run, bits);
+	for (const [bits, run] of require_image_ccitt.EXTENDED_MAKEUP) if (!map.has(run)) map.set(run, bits);
+	return map;
+}
+const WHITE_RUN_CODES = buildRunCodes(require_image_ccitt.WHITE_TERMINATING_AND_MAKEUP);
+const BLACK_RUN_CODES = buildRunCodes(require_image_ccitt.BLACK_TERMINATING_AND_MAKEUP);
+const PASS_MODE = "0001";
+const HORIZONTAL_MODE = "001";
+const VERTICAL_MODES = /* @__PURE__ */ new Map([
+	[0, "1"],
+	[1, "011"],
+	[-1, "010"],
+	[2, "000011"],
+	[-2, "000010"],
+	[3, "0000011"],
+	[-3, "0000010"]
+]);
+const LARGEST_MAKEUP_RUN = 2560;
+const MAKEUP_GRANULARITY = 64;
+var BitWriter = class {
+	bytes = [];
+	current = 0;
+	used = 0;
+	get byteLength() {
+		return this.bytes.length;
+	}
+	writeBits(bits) {
+		for (const char of bits) {
+			this.current = this.current << 1 | (char === "1" ? 1 : 0);
+			this.used++;
+			if (this.used === 8) {
+				this.bytes.push(this.current);
+				this.current = 0;
+				this.used = 0;
+			}
+		}
+	}
+	finish() {
+		if (this.used > 0) this.bytes.push(this.current << 8 - this.used);
+		return new Uint8Array(this.bytes);
+	}
+};
+function writeRun(writer, run, white) {
+	const codes = white ? WHITE_RUN_CODES : BLACK_RUN_CODES;
+	let remaining = run;
+	while (remaining >= MAKEUP_GRANULARITY) {
+		const makeup = Math.min(remaining - remaining % MAKEUP_GRANULARITY, LARGEST_MAKEUP_RUN);
+		writer.writeBits(codes.get(makeup));
+		remaining -= makeup;
+	}
+	writer.writeBits(codes.get(remaining));
+}
+function changingElements(bitmap, rowByteOffset, columns) {
+	const changes = [];
+	let previous = 1;
+	for (let x = 0; x < columns; x++) {
+		const pixel = (bitmap[rowByteOffset + (x >> 3)] ?? 0) >> 7 - (x & 7) & 1;
+		if (pixel !== previous) {
+			changes.push(x);
+			previous = pixel;
+		}
+	}
+	return changes;
+}
+function encodeCcittFax(bitmap, options) {
+	const { columns, rows, maxBytes } = options;
+	if (columns <= 0 || rows <= 0) return /* @__PURE__ */ new Uint8Array(0);
+	const rowBytes = columns + 7 >> 3;
+	const writer = new BitWriter();
+	let reference = [];
+	for (let y = 0; y < rows; y++) {
+		const offset = y * rowBytes;
+		const current = changingElements(bitmap, offset, columns);
+		let ci = 0;
+		let ri = 0;
+		const cur = (i) => current[i] ?? columns;
+		const ref = (i) => reference[i] ?? columns;
+		let a0 = -1;
+		let white = true;
+		while (a0 < columns) {
+			if (maxBytes !== void 0 && writer.byteLength > maxBytes) return;
+			const a1 = cur(ci);
+			const a2 = cur(ci + 1);
+			while (ri < reference.length && ref(ri) <= a0) ri++;
+			let b1Index = ri;
+			if (b1Index % 2 !== (white ? 0 : 1)) b1Index++;
+			const b1 = ref(b1Index);
+			const b2 = ref(b1Index + 1);
+			if (b2 < a1) {
+				writer.writeBits(PASS_MODE);
+				a0 = b2;
+			} else {
+				const delta = a1 - b1;
+				const vertical = VERTICAL_MODES.get(delta);
+				if (vertical !== void 0) {
+					writer.writeBits(vertical);
+					a0 = a1;
+					ci++;
+				} else {
+					writer.writeBits(HORIZONTAL_MODE);
+					writeRun(writer, a1 - Math.max(a0, 0), white);
+					writeRun(writer, a2 - a1, !white);
+					a0 = a2;
+					ci += 2;
+				}
+			}
+			if (a0 < columns) white = ((bitmap[offset + (a0 >> 3)] ?? 0) >> 7 - (a0 & 7) & 1) === 1;
+		}
+		reference = current;
+	}
+	return writer.finish();
+}
+//#endregion
+exports.encodeCcittFax = encodeCcittFax;

package/dist/image/ccitt-encode.d.cts

@@ -0,0 +1,9 @@
+//#region src/image/ccitt-encode.d.ts
+interface EncodeCcittFaxOptions {
+  readonly columns: number;
+  readonly rows: number;
+  readonly maxBytes?: number;
+}
+declare function encodeCcittFax(bitmap: Uint8Array, options: EncodeCcittFaxOptions): Uint8Array<ArrayBuffer> | undefined;
+//#endregion
+export { EncodeCcittFaxOptions, encodeCcittFax };

package/dist/image/ccitt-encode.d.ts

@@ -0,0 +1,9 @@
+//#region src/image/ccitt-encode.d.ts
+interface EncodeCcittFaxOptions {
+  readonly columns: number;
+  readonly rows: number;
+  readonly maxBytes?: number;
+}
+declare function encodeCcittFax(bitmap: Uint8Array, options: EncodeCcittFaxOptions): Uint8Array<ArrayBuffer> | undefined;
+//#endregion
+export { EncodeCcittFaxOptions, encodeCcittFax };

package/dist/image/ccitt-encode.js

@@ -0,0 +1,118 @@
+import { BLACK_TERMINATING_AND_MAKEUP, EXTENDED_MAKEUP, WHITE_TERMINATING_AND_MAKEUP } from "./ccitt.js";
+//#region src/image/ccitt-encode.ts
+function buildRunCodes(table) {
+	const map = /* @__PURE__ */ new Map();
+	for (const [bits, run] of table) map.set(run, bits);
+	for (const [bits, run] of EXTENDED_MAKEUP) if (!map.has(run)) map.set(run, bits);
+	return map;
+}
+const WHITE_RUN_CODES = buildRunCodes(WHITE_TERMINATING_AND_MAKEUP);
+const BLACK_RUN_CODES = buildRunCodes(BLACK_TERMINATING_AND_MAKEUP);
+const PASS_MODE = "0001";
+const HORIZONTAL_MODE = "001";
+const VERTICAL_MODES = /* @__PURE__ */ new Map([
+	[0, "1"],
+	[1, "011"],
+	[-1, "010"],
+	[2, "000011"],
+	[-2, "000010"],
+	[3, "0000011"],
+	[-3, "0000010"]
+]);
+const LARGEST_MAKEUP_RUN = 2560;
+const MAKEUP_GRANULARITY = 64;
+var BitWriter = class {
+	bytes = [];
+	current = 0;
+	used = 0;
+	get byteLength() {
+		return this.bytes.length;
+	}
+	writeBits(bits) {
+		for (const char of bits) {
+			this.current = this.current << 1 | (char === "1" ? 1 : 0);
+			this.used++;
+			if (this.used === 8) {
+				this.bytes.push(this.current);
+				this.current = 0;
+				this.used = 0;
+			}
+		}
+	}
+	finish() {
+		if (this.used > 0) this.bytes.push(this.current << 8 - this.used);
+		return new Uint8Array(this.bytes);
+	}
+};
+function writeRun(writer, run, white) {
+	const codes = white ? WHITE_RUN_CODES : BLACK_RUN_CODES;
+	let remaining = run;
+	while (remaining >= MAKEUP_GRANULARITY) {
+		const makeup = Math.min(remaining - remaining % MAKEUP_GRANULARITY, LARGEST_MAKEUP_RUN);
+		writer.writeBits(codes.get(makeup));
+		remaining -= makeup;
+	}
+	writer.writeBits(codes.get(remaining));
+}
+function changingElements(bitmap, rowByteOffset, columns) {
+	const changes = [];
+	let previous = 1;
+	for (let x = 0; x < columns; x++) {
+		const pixel = (bitmap[rowByteOffset + (x >> 3)] ?? 0) >> 7 - (x & 7) & 1;
+		if (pixel !== previous) {
+			changes.push(x);
+			previous = pixel;
+		}
+	}
+	return changes;
+}
+function encodeCcittFax(bitmap, options) {
+	const { columns, rows, maxBytes } = options;
+	if (columns <= 0 || rows <= 0) return /* @__PURE__ */ new Uint8Array(0);
+	const rowBytes = columns + 7 >> 3;
+	const writer = new BitWriter();
+	let reference = [];
+	for (let y = 0; y < rows; y++) {
+		const offset = y * rowBytes;
+		const current = changingElements(bitmap, offset, columns);
+		let ci = 0;
+		let ri = 0;
+		const cur = (i) => current[i] ?? columns;
+		const ref = (i) => reference[i] ?? columns;
+		let a0 = -1;
+		let white = true;
+		while (a0 < columns) {
+			if (maxBytes !== void 0 && writer.byteLength > maxBytes) return;
+			const a1 = cur(ci);
+			const a2 = cur(ci + 1);
+			while (ri < reference.length && ref(ri) <= a0) ri++;
+			let b1Index = ri;
+			if (b1Index % 2 !== (white ? 0 : 1)) b1Index++;
+			const b1 = ref(b1Index);
+			const b2 = ref(b1Index + 1);
+			if (b2 < a1) {
+				writer.writeBits(PASS_MODE);
+				a0 = b2;
+			} else {
+				const delta = a1 - b1;
+				const vertical = VERTICAL_MODES.get(delta);
+				if (vertical !== void 0) {
+					writer.writeBits(vertical);
+					a0 = a1;
+					ci++;
+				} else {
+					writer.writeBits(HORIZONTAL_MODE);
+					writeRun(writer, a1 - Math.max(a0, 0), white);
+					writeRun(writer, a2 - a1, !white);
+					a0 = a2;
+					ci += 2;
+				}
+			}
+			if (a0 < columns) white = ((bitmap[offset + (a0 >> 3)] ?? 0) >> 7 - (a0 & 7) & 1) === 1;
+		}
+		reference = current;
+	}
+	return writer.finish();
+}
+//#endregion
+export { encodeCcittFax };

package/dist/image/ccitt.cjs

@@ -485,4 +485,7 @@ function decodeCcittFax(data, options = {}) {
 	};
 }
 //#endregion
+exports.BLACK_TERMINATING_AND_MAKEUP = BLACK_TERMINATING_AND_MAKEUP;
+exports.EXTENDED_MAKEUP = EXTENDED_MAKEUP;
+exports.WHITE_TERMINATING_AND_MAKEUP = WHITE_TERMINATING_AND_MAKEUP;
 exports.decodeCcittFax = decodeCcittFax;

package/dist/image/ccitt.d.cts

@@ -1,4 +1,7 @@
 //#region src/image/ccitt.d.ts
+declare const WHITE_TERMINATING_AND_MAKEUP: readonly (readonly [string, number])[];
+declare const BLACK_TERMINATING_AND_MAKEUP: readonly (readonly [string, number])[];
+declare const EXTENDED_MAKEUP: readonly (readonly [string, number])[];
 interface CcittFaxOptions {
   readonly k?: number;
   readonly columns?: number;
@@ -14,4 +17,4 @@ interface CcittFaxImage {
 }
 declare function decodeCcittFax(data: Uint8Array<ArrayBuffer>, options?: CcittFaxOptions): CcittFaxImage;
 //#endregion
-export { CcittFaxImage, CcittFaxOptions, decodeCcittFax };
+export { BLACK_TERMINATING_AND_MAKEUP, CcittFaxImage, CcittFaxOptions, EXTENDED_MAKEUP, WHITE_TERMINATING_AND_MAKEUP, decodeCcittFax };

package/dist/image/ccitt.d.ts

@@ -1,4 +1,7 @@
 //#region src/image/ccitt.d.ts
+declare const WHITE_TERMINATING_AND_MAKEUP: readonly (readonly [string, number])[];
+declare const BLACK_TERMINATING_AND_MAKEUP: readonly (readonly [string, number])[];
+declare const EXTENDED_MAKEUP: readonly (readonly [string, number])[];
 interface CcittFaxOptions {
   readonly k?: number;
   readonly columns?: number;
@@ -14,4 +17,4 @@ interface CcittFaxImage {
 }
 declare function decodeCcittFax(data: Uint8Array<ArrayBuffer>, options?: CcittFaxOptions): CcittFaxImage;
 //#endregion
-export { CcittFaxImage, CcittFaxOptions, decodeCcittFax };
+export { BLACK_TERMINATING_AND_MAKEUP, CcittFaxImage, CcittFaxOptions, EXTENDED_MAKEUP, WHITE_TERMINATING_AND_MAKEUP, decodeCcittFax };

package/dist/image/ccitt.js

@@ -484,4 +484,4 @@ function decodeCcittFax(data, options = {}) {
 	};
 }
 //#endregion
-export { decodeCcittFax };
+export { BLACK_TERMINATING_AND_MAKEUP, EXTENDED_MAKEUP, WHITE_TERMINATING_AND_MAKEUP, decodeCcittFax };

package/dist/write.cjs

@@ -12,6 +12,7 @@ const require_util_abort = require("./util/abort.cjs");
 const require_crypto_random = require("./crypto/random.cjs");
 const require_encrypt_write = require("./encrypt-write.cjs");
 const require_image_jpeg_info = require("./image/jpeg-info.cjs");
+const require_image_ccitt_encode = require("./image/ccitt-encode.cjs");
 const require_image_png_decode = require("./image/png-decode.cjs");
 const require_embedded_font = require("./embedded-font.cjs");
 const require_content_write = require("./content-write.cjs");
@@ -145,9 +146,57 @@ function pngImageDict(width, height, colorSpace, compress) {
 	if (compress) entries.set("Filter", require_objects.pdfName("FlateDecode"));
 	return require_objects.pdfDict(entries);
 }
+function packBilevel(raw) {
+	const rowBytes = raw.width + 7 >> 3;
+	const packed = new Uint8Array(rowBytes * raw.height);
+	for (let y = 0; y < raw.height; y++) for (let x = 0; x < raw.width; x++) {
+		const sample = raw.data[y * raw.width + x] ?? 0;
+		if (sample !== 0 && sample !== 255) return;
+		if (sample === 255) {
+			const index = y * rowBytes + (x >> 3);
+			packed[index] = (packed[index] ?? 0) | 128 >> (x & 7);
+		}
+	}
+	return packed;
+}
 function preparePngImage(bytes, compress) {
 	const raw = require_image_png_decode.decodePng(bytes);
 	const colorSpace = raw.channels === 1 ? "DeviceGray" : "DeviceRGB";
+	if (compress && raw.channels === 1 && raw.alpha === void 0) {
+		const bilevel = packBilevel(raw);
+		if (bilevel !== void 0) {
+			const flate = require_bytes_flate.deflate(raw.data);
+			const g4 = require_image_ccitt_encode.encodeCcittFax(bilevel, {
+				columns: raw.width,
+				rows: raw.height,
+				maxBytes: flate.length
+			});
+			if (g4 !== void 0) return {
+				dict: require_objects.pdfDict(/* @__PURE__ */ new Map([
+					["Type", require_objects.pdfName("XObject")],
+					["Subtype", require_objects.pdfName("Image")],
+					["Width", require_objects.pdfNum(raw.width)],
+					["Height", require_objects.pdfNum(raw.height)],
+					["ColorSpace", require_objects.pdfName("DeviceGray")],
+					["BitsPerComponent", require_objects.pdfNum(1)],
+					["Filter", require_objects.pdfName("CCITTFaxDecode")],
+					["DecodeParms", require_objects.pdfDict(/* @__PURE__ */ new Map([
+						["K", require_objects.pdfNum(-1)],
+						["Columns", require_objects.pdfNum(raw.width)],
+						["Rows", require_objects.pdfNum(raw.height)],
+						["BlackIs1", require_objects.pdfBool(false)]
+					]))]
+				])),
+				raw: g4,
+				alpha: void 0
+			};
+			return {
+				dict: pngImageDict(raw.width, raw.height, colorSpace, true),
+				raw: flate,
+				alpha: void 0
+			};
+		}
+	}
 	return {
 		dict: pngImageDict(raw.width, raw.height, colorSpace, compress),
 		raw: compress ? require_bytes_flate.deflate(raw.data) : raw.data,

package/dist/write.js

@@ -1,6 +1,6 @@
 import { n as widthOfCode, p as winAnsiGlyphName, t as STANDARD_METRICS } from "./afm-widths-De_QMWgC.js";
 import { NOTES_ANNOTATION_AUTHOR } from "./notes-annotation-author.js";
-import { pdfArray, pdfDict, pdfHexString, pdfLiteralString, pdfName, pdfNull, pdfNum, pdfRef, pdfStream } from "./objects.js";
+import { pdfArray, pdfBool, pdfDict, pdfHexString, pdfLiteralString, pdfName, pdfNull, pdfNum, pdfRef, pdfStream } from "./objects.js";
 import { ByteWriter, concatBytes } from "./bytes/writer.js";
 import { writeObject } from "./serialize.js";
 import { ByteReader } from "./bytes/reader.js";
@@ -11,6 +11,7 @@ import { throwIfAborted } from "./util/abort.js";
 import { randomBytes } from "./crypto/random.js";
 import { createStandardEncryptor, encryptIndirectObject } from "./encrypt-write.js";
 import { readJpegInfo } from "./image/jpeg-info.js";
+import { encodeCcittFax } from "./image/ccitt-encode.js";
 import { decodePng } from "./image/png-decode.js";
 import { collectEmbeddedGlyphs } from "./embedded-font.js";
 import { writeContentStream } from "./content-write.js";
@@ -144,9 +145,57 @@ function pngImageDict(width, height, colorSpace, compress) {
 	if (compress) entries.set("Filter", pdfName("FlateDecode"));
 	return pdfDict(entries);
 }
+function packBilevel(raw) {
+	const rowBytes = raw.width + 7 >> 3;
+	const packed = new Uint8Array(rowBytes * raw.height);
+	for (let y = 0; y < raw.height; y++) for (let x = 0; x < raw.width; x++) {
+		const sample = raw.data[y * raw.width + x] ?? 0;
+		if (sample !== 0 && sample !== 255) return;
+		if (sample === 255) {
+			const index = y * rowBytes + (x >> 3);
+			packed[index] = (packed[index] ?? 0) | 128 >> (x & 7);
+		}
+	}
+	return packed;
+}
 function preparePngImage(bytes, compress) {
 	const raw = decodePng(bytes);
 	const colorSpace = raw.channels === 1 ? "DeviceGray" : "DeviceRGB";
+	if (compress && raw.channels === 1 && raw.alpha === void 0) {
+		const bilevel = packBilevel(raw);
+		if (bilevel !== void 0) {
+			const flate = deflate(raw.data);
+			const g4 = encodeCcittFax(bilevel, {
+				columns: raw.width,
+				rows: raw.height,
+				maxBytes: flate.length
+			});
+			if (g4 !== void 0) return {
+				dict: pdfDict(/* @__PURE__ */ new Map([
+					["Type", pdfName("XObject")],
+					["Subtype", pdfName("Image")],
+					["Width", pdfNum(raw.width)],
+					["Height", pdfNum(raw.height)],
+					["ColorSpace", pdfName("DeviceGray")],
+					["BitsPerComponent", pdfNum(1)],
+					["Filter", pdfName("CCITTFaxDecode")],
+					["DecodeParms", pdfDict(/* @__PURE__ */ new Map([
+						["K", pdfNum(-1)],
+						["Columns", pdfNum(raw.width)],
+						["Rows", pdfNum(raw.height)],
+						["BlackIs1", pdfBool(false)]
+					]))]
+				])),
+				raw: g4,
+				alpha: void 0
+			};
+			return {
+				dict: pngImageDict(raw.width, raw.height, colorSpace, true),
+				raw: flate,
+				alpha: void 0
+			};
+		}
+	}
 	return {
 		dict: pngImageDict(raw.width, raw.height, colorSpace, compress),
 		raw: compress ? deflate(raw.data) : raw.data,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdf-codec",
-  "version": "4.4.0",
+  "version": "4.5.0",
   "description": "Hand-written, dependency-minimal PDF codec: parses arbitrary real-world PDFs and generates new ones, built on its own codec-owned LayoutDocument item model and Zod 4 codecs.",
   "type": "module",
   "repository": {