pdf-parser.js 4.6.0 → 4.7.0

package/README.md

@@ -264,7 +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.
+- **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 remain 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. **What no longer follows from that boundary is generation loss on a pdf-to-pdf round trip**: `LayoutImageAsset.original` (the layout twin of `document-schema.js`'s `ContentImageOriginal`, landed through the #975-scorecard schema change it named) carries a source's own JBIG2/JPX compressed stream beside the decoded canonical, captured at read time together with the decoded `/JBIG2Globals` segments a symbol-dictionary stream needs, and the writer re-embeds those bytes verbatim under their own filter — the decoded canonical never reaches the file at all for such an image, a source soft mask still re-emits as a generated `/SMask`, and the round trip pays zero generation loss for exactly the two filters this package cannot re-encode.
 - **`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/codec.d.cts

@@ -253,6 +253,14 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
     base64: z.ZodString;
     widthPx: z.ZodNumber;
     heightPx: z.ZodNumber;
+    original: z.ZodOptional<z.ZodObject<{
+      filter: z.ZodEnum<{
+        jbig2: "jbig2";
+        jpeg2000: "jpeg2000";
+      }>;
+      base64: z.ZodString;
+      jbig2GlobalsBase64: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
   }, z.core.$strip>>;
   destinations: z.ZodOptional<z.ZodArray<z.ZodObject<{
     name: z.ZodString;

package/dist/codec.d.ts

@@ -253,6 +253,14 @@ declare const pdfCodec: z.ZodCodec<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Arr
     base64: z.ZodString;
     widthPx: z.ZodNumber;
     heightPx: z.ZodNumber;
+    original: z.ZodOptional<z.ZodObject<{
+      filter: z.ZodEnum<{
+        jbig2: "jbig2";
+        jpeg2000: "jpeg2000";
+      }>;
+      base64: z.ZodString;
+      jbig2GlobalsBase64: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
   }, z.core.$strip>>;
   destinations: z.ZodOptional<z.ZodArray<z.ZodObject<{
     name: z.ZodString;

package/dist/filters.cjs

@@ -10,6 +10,7 @@ function decodeStream(raw, dict, sink, resolve) {
 	const filters = filterNames(dict);
 	const parms = decodeParmsList(dict, filters.length);
 	let bytes = raw;
+	let jbig2;
 	for (let i = 0; i < filters.length; i++) {
 		const filter = filters[i];
 		const parm = parms[i];
@@ -27,7 +28,11 @@ function decodeStream(raw, dict, sink, resolve) {
 				bytes,
 				remainingFilter: "JBIG2Decode"
 			};
-			bytes = decoded;
+			jbig2 = {
+				encoded: bytes,
+				globals: decoded.globals
+			};
+			bytes = decoded.bytes;
 		} else if (filter === "DCTDecode" || filter === "DCT") return {
 			bytes,
 			remainingFilter: "DCTDecode"
@@ -48,7 +53,10 @@ function decodeStream(raw, dict, sink, resolve) {
 			};
 		}
 	}
-	return { bytes };
+	return jbig2 === void 0 ? { bytes } : {
+		bytes,
+		jbig2
+	};
 }
 function applyPredictorIfPresent(data, parm, sink) {
 	return require_predictors.applyPredictor(data, require_predictors.readPredictorParams(parm), sink);
@@ -94,7 +102,10 @@ function jbig2Decode(data, parm, dict, sink, resolve) {
 				});
 			}
 		});
-		return Uint8Array.from(image.bytes, (byte) => byte ^ 255);
+		return {
+			bytes: Uint8Array.from(image.bytes, (byte) => byte ^ 255),
+			globals
+		};
 	} catch (error) {
 		sink({
 			code: "pdf/jbig2-undecodable",

package/dist/filters.d.cts

@@ -4,6 +4,10 @@ import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.cjs";
 interface DecodedStream {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly remainingFilter?: string;
+  readonly jbig2?: {
+    readonly encoded: Uint8Array<ArrayBuffer>;
+    readonly globals?: Uint8Array<ArrayBuffer>;
+  };
 }
 type PdfIndirectResolver = (obj: PdfObject | undefined) => PdfObject | undefined;
 declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink, resolve?: PdfIndirectResolver): DecodedStream;

package/dist/filters.d.ts

@@ -4,6 +4,10 @@ import { n as PdfDict, r as PdfObject } from "./objects-B7HdMeWS.js";
 interface DecodedStream {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly remainingFilter?: string;
+  readonly jbig2?: {
+    readonly encoded: Uint8Array<ArrayBuffer>;
+    readonly globals?: Uint8Array<ArrayBuffer>;
+  };
 }
 type PdfIndirectResolver = (obj: PdfObject | undefined) => PdfObject | undefined;
 declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink, resolve?: PdfIndirectResolver): DecodedStream;

package/dist/filters.js

@@ -9,6 +9,7 @@ function decodeStream(raw, dict, sink, resolve) {
 	const filters = filterNames(dict);
 	const parms = decodeParmsList(dict, filters.length);
 	let bytes = raw;
+	let jbig2;
 	for (let i = 0; i < filters.length; i++) {
 		const filter = filters[i];
 		const parm = parms[i];
@@ -26,7 +27,11 @@ function decodeStream(raw, dict, sink, resolve) {
 				bytes,
 				remainingFilter: "JBIG2Decode"
 			};
-			bytes = decoded;
+			jbig2 = {
+				encoded: bytes,
+				globals: decoded.globals
+			};
+			bytes = decoded.bytes;
 		} else if (filter === "DCTDecode" || filter === "DCT") return {
 			bytes,
 			remainingFilter: "DCTDecode"
@@ -47,7 +52,10 @@ function decodeStream(raw, dict, sink, resolve) {
 			};
 		}
 	}
-	return { bytes };
+	return jbig2 === void 0 ? { bytes } : {
+		bytes,
+		jbig2
+	};
 }
 function applyPredictorIfPresent(data, parm, sink) {
 	return applyPredictor(data, readPredictorParams(parm), sink);
@@ -93,7 +101,10 @@ function jbig2Decode(data, parm, dict, sink, resolve) {
 				});
 			}
 		});
-		return Uint8Array.from(image.bytes, (byte) => byte ^ 255);
+		return {
+			bytes: Uint8Array.from(image.bytes, (byte) => byte ^ 255),
+			globals
+		};
 	} catch (error) {
 		sink({
 			code: "pdf/jbig2-undecodable",

package/dist/images-read.cjs

@@ -249,7 +249,11 @@ function readJpeg2000Image(dict, raw, resolver, sink) {
 		format: "png",
 		bytes: (0, byte_codec.encodePng)(withAlpha),
 		widthPx: image.width,
-		heightPx: image.height
+		heightPx: image.height,
+		original: {
+			filter: "jpeg2000",
+			bytes: raw
+		}
 	};
 }
 function readImageXObject(dict, raw, resolver, sink) {
@@ -262,6 +266,11 @@ function readImageXObject(dict, raw, resolver, sink) {
 		return;
 	}
 	const decoded = require_filters.decodeStream(raw, dict, sink, (obj) => resolver.resolve(obj));
+	const jbig2Original = decoded.jbig2 === void 0 ? void 0 : {
+		filter: "jbig2",
+		bytes: decoded.jbig2.encoded,
+		...decoded.jbig2.globals !== void 0 ? { globalsBytes: decoded.jbig2.globals } : {}
+	};
 	if (decoded.remainingFilter === "DCTDecode") {
 		let info;
 		try {
@@ -323,7 +332,8 @@ function readImageXObject(dict, raw, resolver, sink) {
 		format: "png",
 		bytes: (0, byte_codec.encodePng)(withAlpha),
 		widthPx: width,
-		heightPx: height
+		heightPx: height,
+		...jbig2Original !== void 0 ? { original: jbig2Original } : {}
 	};
 }
 //#endregion

package/dist/images-read.d.cts

@@ -7,6 +7,11 @@ interface ExtractedPdfImage {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly widthPx: number;
   readonly heightPx: number;
+  readonly original?: {
+    readonly filter: "jbig2" | "jpeg2000";
+    readonly bytes: Uint8Array<ArrayBuffer>;
+    readonly globalsBytes?: Uint8Array<ArrayBuffer>;
+  };
 }
 declare function readImageXObject(dict: PdfDict, raw: Uint8Array<ArrayBuffer>, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): ExtractedPdfImage | undefined;
 //#endregion

package/dist/images-read.d.ts

@@ -7,6 +7,11 @@ interface ExtractedPdfImage {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly widthPx: number;
   readonly heightPx: number;
+  readonly original?: {
+    readonly filter: "jbig2" | "jpeg2000";
+    readonly bytes: Uint8Array<ArrayBuffer>;
+    readonly globalsBytes?: Uint8Array<ArrayBuffer>;
+  };
 }
 declare function readImageXObject(dict: PdfDict, raw: Uint8Array<ArrayBuffer>, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): ExtractedPdfImage | undefined;
 //#endregion

package/dist/images-read.js

@@ -248,7 +248,11 @@ function readJpeg2000Image(dict, raw, resolver, sink) {
 		format: "png",
 		bytes: encodePng(withAlpha),
 		widthPx: image.width,
-		heightPx: image.height
+		heightPx: image.height,
+		original: {
+			filter: "jpeg2000",
+			bytes: raw
+		}
 	};
 }
 function readImageXObject(dict, raw, resolver, sink) {
@@ -261,6 +265,11 @@ function readImageXObject(dict, raw, resolver, sink) {
 		return;
 	}
 	const decoded = decodeStream(raw, dict, sink, (obj) => resolver.resolve(obj));
+	const jbig2Original = decoded.jbig2 === void 0 ? void 0 : {
+		filter: "jbig2",
+		bytes: decoded.jbig2.encoded,
+		...decoded.jbig2.globals !== void 0 ? { globalsBytes: decoded.jbig2.globals } : {}
+	};
 	if (decoded.remainingFilter === "DCTDecode") {
 		let info;
 		try {
@@ -322,7 +331,8 @@ function readImageXObject(dict, raw, resolver, sink) {
 		format: "png",
 		bytes: encodePng(withAlpha),
 		widthPx: width,
-		heightPx: height
+		heightPx: height,
+		...jbig2Original !== void 0 ? { original: jbig2Original } : {}
 	};
 }
 //#endregion

package/dist/layout.cjs

@@ -178,7 +178,12 @@ const LayoutImageAssetSchema = zod.z.object({
 	format: zod.z.enum(["png", "jpeg"]),
 	base64: zod.z.string(),
 	widthPx: zod.z.number().int().positive(),
-	heightPx: zod.z.number().int().positive()
+	heightPx: zod.z.number().int().positive(),
+	original: zod.z.object({
+		filter: zod.z.enum(["jbig2", "jpeg2000"]),
+		base64: zod.z.string(),
+		jbig2GlobalsBase64: zod.z.string().optional()
+	}).optional()
 });
 const LayoutDestinationTargetSchema = zod.z.object({
 	kind: zod.z.enum([

package/dist/layout.d.cts

@@ -675,6 +675,14 @@ declare const LayoutImageAssetSchema: z.ZodObject<{
   base64: z.ZodString;
   widthPx: z.ZodNumber;
   heightPx: z.ZodNumber;
+  original: z.ZodOptional<z.ZodObject<{
+    filter: z.ZodEnum<{
+      jbig2: "jbig2";
+      jpeg2000: "jpeg2000";
+    }>;
+    base64: z.ZodString;
+    jbig2GlobalsBase64: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
 }, z.core.$strip>;
 type LayoutImageAsset = z.infer<typeof LayoutImageAssetSchema>;
 declare const LayoutDestinationTargetSchema: z.ZodObject<{
@@ -1016,6 +1024,14 @@ declare const LayoutDocumentSchema: z.ZodObject<{
     base64: z.ZodString;
     widthPx: z.ZodNumber;
     heightPx: z.ZodNumber;
+    original: z.ZodOptional<z.ZodObject<{
+      filter: z.ZodEnum<{
+        jbig2: "jbig2";
+        jpeg2000: "jpeg2000";
+      }>;
+      base64: z.ZodString;
+      jbig2GlobalsBase64: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
   }, z.core.$strip>>;
   destinations: z.ZodOptional<z.ZodArray<z.ZodObject<{
     name: z.ZodString;

package/dist/layout.d.ts

@@ -675,6 +675,14 @@ declare const LayoutImageAssetSchema: z.ZodObject<{
   base64: z.ZodString;
   widthPx: z.ZodNumber;
   heightPx: z.ZodNumber;
+  original: z.ZodOptional<z.ZodObject<{
+    filter: z.ZodEnum<{
+      jbig2: "jbig2";
+      jpeg2000: "jpeg2000";
+    }>;
+    base64: z.ZodString;
+    jbig2GlobalsBase64: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
 }, z.core.$strip>;
 type LayoutImageAsset = z.infer<typeof LayoutImageAssetSchema>;
 declare const LayoutDestinationTargetSchema: z.ZodObject<{
@@ -1016,6 +1024,14 @@ declare const LayoutDocumentSchema: z.ZodObject<{
     base64: z.ZodString;
     widthPx: z.ZodNumber;
     heightPx: z.ZodNumber;
+    original: z.ZodOptional<z.ZodObject<{
+      filter: z.ZodEnum<{
+        jbig2: "jbig2";
+        jpeg2000: "jpeg2000";
+      }>;
+      base64: z.ZodString;
+      jbig2GlobalsBase64: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
   }, z.core.$strip>>;
   destinations: z.ZodOptional<z.ZodArray<z.ZodObject<{
     name: z.ZodString;

package/dist/layout.js

@@ -177,7 +177,12 @@ const LayoutImageAssetSchema = z.object({
 	format: z.enum(["png", "jpeg"]),
 	base64: z.string(),
 	widthPx: z.number().int().positive(),
-	heightPx: z.number().int().positive()
+	heightPx: z.number().int().positive(),
+	original: z.object({
+		filter: z.enum(["jbig2", "jpeg2000"]),
+		base64: z.string(),
+		jbig2GlobalsBase64: z.string().optional()
+	}).optional()
 });
 const LayoutDestinationTargetSchema = z.object({
 	kind: z.enum([

package/dist/read.cjs

@@ -497,13 +497,18 @@ function imagePlacementFrom(matrix) {
 		rotationDeg: rotationDeg !== 0 ? rotationDeg : void 0
 	};
 }
-function registerExtractedImage(format, bytes, widthPx, heightPx, images) {
+function registerExtractedImage(format, bytes, widthPx, heightPx, images, original) {
 	const imageId = `img${require_bytes_crc32.crc32(bytes).toString(16)}`;
 	if (!(imageId in images)) images[imageId] = {
 		format,
 		base64: require_util_base64.bytesToBase64(bytes),
 		widthPx,
-		heightPx
+		heightPx,
+		...original !== void 0 ? { original: {
+			filter: original.filter,
+			base64: require_util_base64.bytesToBase64(original.bytes),
+			...original.globalsBytes !== void 0 ? { jbig2GlobalsBase64: require_util_base64.bytesToBase64(original.globalsBytes) } : {}
+		} } : {}
 	};
 	return imageId;
 }
@@ -514,7 +519,7 @@ function resolveCachedImageId(dict, raw, images, cache, resolver, sink) {
 		cache.set(dict, null);
 		return;
 	}
-	const imageId = registerExtractedImage(decoded.format, decoded.bytes, decoded.widthPx, decoded.heightPx, images);
+	const imageId = registerExtractedImage(decoded.format, decoded.bytes, decoded.widthPx, decoded.heightPx, images, decoded.original);
 	cache.set(dict, imageId);
 	return imageId;
 }
@@ -536,7 +541,7 @@ function convertInlineImage(item, pageMatrix, images, resolver, sink) {
 	if (decoded === void 0) return;
 	return {
 		kind: "image",
-		imageId: registerExtractedImage(decoded.format, decoded.bytes, decoded.widthPx, decoded.heightPx, images),
+		imageId: registerExtractedImage(decoded.format, decoded.bytes, decoded.widthPx, decoded.heightPx, images, decoded.original),
 		...imagePlacementFrom(require_matrix.multiplyMatrices(item.matrix, pageMatrix)),
 		...item.layerName !== void 0 ? { layer: item.layerName } : {}
 	};

package/dist/read.js

@@ -496,13 +496,18 @@ function imagePlacementFrom(matrix) {
 		rotationDeg: rotationDeg !== 0 ? rotationDeg : void 0
 	};
 }
-function registerExtractedImage(format, bytes, widthPx, heightPx, images) {
+function registerExtractedImage(format, bytes, widthPx, heightPx, images, original) {
 	const imageId = `img${crc32(bytes).toString(16)}`;
 	if (!(imageId in images)) images[imageId] = {
 		format,
 		base64: bytesToBase64(bytes),
 		widthPx,
-		heightPx
+		heightPx,
+		...original !== void 0 ? { original: {
+			filter: original.filter,
+			base64: bytesToBase64(original.bytes),
+			...original.globalsBytes !== void 0 ? { jbig2GlobalsBase64: bytesToBase64(original.globalsBytes) } : {}
+		} } : {}
 	};
 	return imageId;
 }
@@ -513,7 +518,7 @@ function resolveCachedImageId(dict, raw, images, cache, resolver, sink) {
 		cache.set(dict, null);
 		return;
 	}
-	const imageId = registerExtractedImage(decoded.format, decoded.bytes, decoded.widthPx, decoded.heightPx, images);
+	const imageId = registerExtractedImage(decoded.format, decoded.bytes, decoded.widthPx, decoded.heightPx, images, decoded.original);
 	cache.set(dict, imageId);
 	return imageId;
 }
@@ -535,7 +540,7 @@ function convertInlineImage(item, pageMatrix, images, resolver, sink) {
 	if (decoded === void 0) return;
 	return {
 		kind: "image",
-		imageId: registerExtractedImage(decoded.format, decoded.bytes, decoded.widthPx, decoded.heightPx, images),
+		imageId: registerExtractedImage(decoded.format, decoded.bytes, decoded.widthPx, decoded.heightPx, images, decoded.original),
 		...imagePlacementFrom(multiplyMatrices(item.matrix, pageMatrix)),
 		...item.layerName !== void 0 ? { layer: item.layerName } : {}
 	};

package/dist/write.cjs

@@ -206,7 +206,28 @@ function preparePngImage(bytes, compress) {
 		}
 	};
 }
+function preparePassthroughImage(asset, compress) {
+	if (asset.original === void 0) throw new Error("preparePassthroughImage: asset carries no original stream");
+	const png = preparePngImage(require_util_base64.base64ToBytes(asset.base64), compress);
+	const entries = /* @__PURE__ */ new Map([
+		["Type", require_objects.pdfName("XObject")],
+		["Subtype", require_objects.pdfName("Image")],
+		["Width", require_objects.pdfNum(asset.widthPx)],
+		["Height", require_objects.pdfNum(asset.heightPx)],
+		["Filter", require_objects.pdfName(asset.original.filter === "jbig2" ? "JBIG2Decode" : "JPXDecode")]
+	]);
+	if (asset.original.filter === "jbig2") {
+		entries.set("ColorSpace", require_objects.pdfName("DeviceGray"));
+		entries.set("BitsPerComponent", require_objects.pdfNum(1));
+	}
+	return {
+		dict: require_objects.pdfDict(entries),
+		raw: require_util_base64.base64ToBytes(asset.original.base64),
+		...png.alpha !== void 0 ? { alpha: png.alpha } : {}
+	};
+}
 function prepareImage(asset, compress) {
+	if (asset.original !== void 0) return preparePassthroughImage(asset, compress);
 	const bytes = require_util_base64.base64ToBytes(asset.base64);
 	return asset.format === "jpeg" ? prepareJpegImage(bytes) : preparePngImage(bytes, compress);
 }
@@ -361,9 +382,13 @@ function writePdf(doc, options = {}) {
 		const prepared = prepareImage(asset, compress);
 		const imageNum = nextObjNum++;
 		const smaskNum = prepared.alpha === void 0 ? void 0 : nextObjNum++;
+		const globalsBase64 = asset.original?.filter === "jbig2" ? asset.original.jbig2GlobalsBase64 : void 0;
+		const globalsNum = globalsBase64 !== void 0 ? nextObjNum++ : void 0;
 		imageAllocs.set(imageId, {
 			imageNum,
 			smaskNum,
+			globalsNum,
+			globalsBase64,
 			resourceName: `Im${index + 1}`,
 			prepared
 		});
@@ -708,6 +733,14 @@ function writePdf(doc, options = {}) {
 				value: require_objects.pdfStream(alloc.prepared.alpha.dict, alloc.prepared.alpha.raw)
 			});
 		}
+		if (alloc.globalsNum !== void 0 && alloc.globalsBase64 !== void 0) {
+			const globalsRaw = require_util_base64.base64ToBytes(alloc.globalsBase64);
+			alloc.prepared.dict.entries.set("DecodeParms", require_objects.pdfDict({ JBIG2Globals: require_objects.pdfRef(alloc.globalsNum, 0) }));
+			objects.push({
+				num: alloc.globalsNum,
+				value: require_objects.pdfStream(require_objects.pdfDict(compress ? /* @__PURE__ */ new Map([["Filter", require_objects.pdfName("FlateDecode")]]) : /* @__PURE__ */ new Map()), compress ? require_bytes_flate.deflate(globalsRaw) : globalsRaw)
+			});
+		}
 		objects.push({
 			num: alloc.imageNum,
 			value: require_objects.pdfStream(alloc.prepared.dict, alloc.prepared.raw)

package/dist/write.js

@@ -205,7 +205,28 @@ function preparePngImage(bytes, compress) {
 		}
 	};
 }
+function preparePassthroughImage(asset, compress) {
+	if (asset.original === void 0) throw new Error("preparePassthroughImage: asset carries no original stream");
+	const png = preparePngImage(base64ToBytes(asset.base64), compress);
+	const entries = /* @__PURE__ */ new Map([
+		["Type", pdfName("XObject")],
+		["Subtype", pdfName("Image")],
+		["Width", pdfNum(asset.widthPx)],
+		["Height", pdfNum(asset.heightPx)],
+		["Filter", pdfName(asset.original.filter === "jbig2" ? "JBIG2Decode" : "JPXDecode")]
+	]);
+	if (asset.original.filter === "jbig2") {
+		entries.set("ColorSpace", pdfName("DeviceGray"));
+		entries.set("BitsPerComponent", pdfNum(1));
+	}
+	return {
+		dict: pdfDict(entries),
+		raw: base64ToBytes(asset.original.base64),
+		...png.alpha !== void 0 ? { alpha: png.alpha } : {}
+	};
+}
 function prepareImage(asset, compress) {
+	if (asset.original !== void 0) return preparePassthroughImage(asset, compress);
 	const bytes = base64ToBytes(asset.base64);
 	return asset.format === "jpeg" ? prepareJpegImage(bytes) : preparePngImage(bytes, compress);
 }
@@ -360,9 +381,13 @@ function writePdf(doc, options = {}) {
 		const prepared = prepareImage(asset, compress);
 		const imageNum = nextObjNum++;
 		const smaskNum = prepared.alpha === void 0 ? void 0 : nextObjNum++;
+		const globalsBase64 = asset.original?.filter === "jbig2" ? asset.original.jbig2GlobalsBase64 : void 0;
+		const globalsNum = globalsBase64 !== void 0 ? nextObjNum++ : void 0;
 		imageAllocs.set(imageId, {
 			imageNum,
 			smaskNum,
+			globalsNum,
+			globalsBase64,
 			resourceName: `Im${index + 1}`,
 			prepared
 		});
@@ -707,6 +732,14 @@ function writePdf(doc, options = {}) {
 				value: pdfStream(alloc.prepared.alpha.dict, alloc.prepared.alpha.raw)
 			});
 		}
+		if (alloc.globalsNum !== void 0 && alloc.globalsBase64 !== void 0) {
+			const globalsRaw = base64ToBytes(alloc.globalsBase64);
+			alloc.prepared.dict.entries.set("DecodeParms", pdfDict({ JBIG2Globals: pdfRef(alloc.globalsNum, 0) }));
+			objects.push({
+				num: alloc.globalsNum,
+				value: pdfStream(pdfDict(compress ? /* @__PURE__ */ new Map([["Filter", pdfName("FlateDecode")]]) : /* @__PURE__ */ new Map()), compress ? deflate(globalsRaw) : globalsRaw)
+			});
+		}
 		objects.push({
 			num: alloc.imageNum,
 			value: pdfStream(alloc.prepared.dict, alloc.prepared.raw)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdf-parser.js",
-  "version": "4.6.0",
+  "version": "4.7.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": {
@@ -72,8 +72,8 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "byte-codec": "1.4.2",
-    "document-schema.js": "7.10.0",
+    "byte-codec": "1.5.0",
+    "document-schema.js": "7.11.0",
     "fflate": "0.8.3",
     "zod": "4.4.3"
   },