pdf-codec 1.6.0 → 1.7.0

package/dist/cff.cjs

@@ -0,0 +1,158 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sfnt = require("./sfnt.cjs");
+//#region src/cff.ts
+const CFF_ESCAPED_OPERATOR_BASE = 1200;
+const CFF_DICT_OP_CHARSET = 15;
+const CFF_DICT_OP_CHARSTRINGS = 17;
+const CFF_DICT_OP_PRIVATE = 18;
+const CFF_DICT_OP_SUBRS = 19;
+const CFF_DICT_OP_ROS = 1230;
+const INDEX_COUNT_SIZE = 2;
+const INDEX_OFF_SIZE_SIZE = 1;
+const MIN_OFF_SIZE = 1;
+const MAX_OFF_SIZE = 4;
+const DICT_OPERATOR_MAX = 21;
+const DICT_OPERATOR_ESCAPE = 12;
+const DICT_OPERAND_INT16 = 28;
+const DICT_OPERAND_INT32 = 29;
+const DICT_OPERAND_REAL = 30;
+const DICT_OPERAND_SMALL_FIRST = 32;
+const DICT_OPERAND_SMALL_LAST = 246;
+const DICT_OPERAND_MEDIUM_FIRST = 247;
+const DICT_OPERAND_MEDIUM_LAST = 250;
+const DICT_OPERAND_NEGATIVE_MEDIUM_FIRST = 251;
+const DICT_OPERAND_NEGATIVE_MEDIUM_LAST = 254;
+const DICT_OPERAND_SMALL_BIAS = 139;
+const DICT_OPERAND_MEDIUM_BIAS = 108;
+const DICT_OPERAND_MEDIUM_FIRST_BYTE_BIAS = 247;
+const DICT_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS = 251;
+const BYTE_RADIX = 256;
+const REAL_NIBBLE_DECIMAL_POINT = 10;
+const REAL_NIBBLE_EXPONENT = 11;
+const REAL_NIBBLE_NEGATIVE_EXPONENT = 12;
+const REAL_NIBBLE_RESERVED = 13;
+const REAL_NIBBLE_MINUS = 14;
+const REAL_NIBBLE_TERMINATOR = 15;
+const NIBBLES_PER_BYTE = 2;
+const HIGH_NIBBLE_SHIFT = 4;
+const LOW_NIBBLE_MASK = 15;
+function readOffsetAt(bytes, offset, offSize) {
+	if (offSize === 1) return require_sfnt.u8(bytes, offset);
+	if (offSize === 2) return require_sfnt.u16(bytes, offset);
+	if (offSize === 3) return require_sfnt.u24(bytes, offset);
+	return require_sfnt.u32(bytes, offset);
+}
+function readCffIndex(bytes, offset) {
+	if (!require_sfnt.hasBytes(bytes, offset, INDEX_COUNT_SIZE)) return;
+	const count = require_sfnt.u16(bytes, offset);
+	if (count === 0) return {
+		count: 0,
+		endOffset: offset + INDEX_COUNT_SIZE,
+		entry: () => void 0
+	};
+	if (!require_sfnt.hasBytes(bytes, offset + INDEX_COUNT_SIZE, INDEX_OFF_SIZE_SIZE)) return;
+	const offSize = require_sfnt.u8(bytes, offset + INDEX_COUNT_SIZE);
+	if (offSize < MIN_OFF_SIZE || offSize > MAX_OFF_SIZE) return;
+	const offsetArrayStart = offset + INDEX_COUNT_SIZE + INDEX_OFF_SIZE_SIZE;
+	const offsetArrayLength = (count + 1) * offSize;
+	if (!require_sfnt.hasBytes(bytes, offsetArrayStart, offsetArrayLength)) return;
+	const offsets = [];
+	for (let i = 0; i <= count; i++) offsets.push(readOffsetAt(bytes, offsetArrayStart + i * offSize, offSize));
+	if (offsets[0] !== 1) return;
+	for (let i = 1; i <= count; i++) if (offsets[i] < offsets[i - 1]) return;
+	const dataOrigin = offsetArrayStart + offsetArrayLength - 1;
+	const dataLength = offsets[count] - 1;
+	if (!require_sfnt.hasBytes(bytes, dataOrigin + 1, dataLength)) return;
+	return {
+		count,
+		endOffset: dataOrigin + 1 + dataLength,
+		entry: (index) => index < 0 || index >= count ? void 0 : bytes.subarray(dataOrigin + offsets[index], dataOrigin + offsets[index + 1])
+	};
+}
+function readRealOperand(data, start) {
+	let text = "";
+	for (let i = start; i < data.length; i++) {
+		const byte = data[i];
+		for (let n = 0; n < NIBBLES_PER_BYTE; n++) {
+			const nibble = n === 0 ? byte >> HIGH_NIBBLE_SHIFT : byte & LOW_NIBBLE_MASK;
+			if (nibble === REAL_NIBBLE_TERMINATOR) return {
+				value: Number(text),
+				endOffset: i + 1
+			};
+			if (nibble === REAL_NIBBLE_RESERVED) return;
+			if (nibble <= 9) text += String(nibble);
+			else if (nibble === REAL_NIBBLE_DECIMAL_POINT) text += ".";
+			else if (nibble === REAL_NIBBLE_EXPONENT) text += "E";
+			else if (nibble === REAL_NIBBLE_NEGATIVE_EXPONENT) text += "E-";
+			else if (nibble === REAL_NIBBLE_MINUS) text += "-";
+		}
+	}
+}
+function parseCffDict(data) {
+	const dict = /* @__PURE__ */ new Map();
+	let operands = [];
+	let i = 0;
+	while (i < data.length) {
+		const b0 = data[i];
+		if (b0 <= DICT_OPERATOR_MAX) {
+			let operator = b0;
+			i += 1;
+			if (b0 === DICT_OPERATOR_ESCAPE) {
+				if (i >= data.length) return;
+				operator = CFF_ESCAPED_OPERATOR_BASE + data[i];
+				i += 1;
+			}
+			dict.set(operator, operands);
+			operands = [];
+			continue;
+		}
+		if (b0 === DICT_OPERAND_INT16) {
+			if (!require_sfnt.hasBytes(data, i + 1, 2)) return;
+			const raw = require_sfnt.u16(data, i + 1);
+			operands.push(raw >= 32768 ? raw - 65536 : raw);
+			i += 3;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_INT32) {
+			if (!require_sfnt.hasBytes(data, i + 1, 4)) return;
+			operands.push(require_sfnt.u32(data, i + 1) | 0);
+			i += 5;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_REAL) {
+			const real = readRealOperand(data, i + 1);
+			if (real === void 0) return;
+			operands.push(real.value);
+			i = real.endOffset;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_SMALL_FIRST && b0 <= DICT_OPERAND_SMALL_LAST) {
+			operands.push(b0 - DICT_OPERAND_SMALL_BIAS);
+			i += 1;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_MEDIUM_FIRST && b0 <= DICT_OPERAND_MEDIUM_LAST) {
+			if (!require_sfnt.hasBytes(data, i + 1, 1)) return;
+			operands.push((b0 - DICT_OPERAND_MEDIUM_FIRST_BYTE_BIAS) * BYTE_RADIX + require_sfnt.u8(data, i + 1) + DICT_OPERAND_MEDIUM_BIAS);
+			i += 2;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_NEGATIVE_MEDIUM_FIRST && b0 <= DICT_OPERAND_NEGATIVE_MEDIUM_LAST) {
+			if (!require_sfnt.hasBytes(data, i + 1, 1)) return;
+			operands.push(-(b0 - DICT_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS) * BYTE_RADIX - require_sfnt.u8(data, i + 1) - DICT_OPERAND_MEDIUM_BIAS);
+			i += 2;
+			continue;
+		}
+		return;
+	}
+	return dict;
+}
+//#endregion
+exports.CFF_DICT_OP_CHARSET = CFF_DICT_OP_CHARSET;
+exports.CFF_DICT_OP_CHARSTRINGS = CFF_DICT_OP_CHARSTRINGS;
+exports.CFF_DICT_OP_PRIVATE = CFF_DICT_OP_PRIVATE;
+exports.CFF_DICT_OP_ROS = CFF_DICT_OP_ROS;
+exports.CFF_DICT_OP_SUBRS = CFF_DICT_OP_SUBRS;
+exports.CFF_ESCAPED_OPERATOR_BASE = CFF_ESCAPED_OPERATOR_BASE;
+exports.parseCffDict = parseCffDict;
+exports.readCffIndex = readCffIndex;

package/dist/cff.d.cts

@@ -0,0 +1,17 @@
+//#region src/cff.d.ts
+interface CffIndex {
+  readonly count: number;
+  readonly endOffset: number;
+  entry(index: number): Uint8Array<ArrayBuffer> | undefined;
+}
+type CffDict = ReadonlyMap<number, readonly number[]>;
+declare const CFF_ESCAPED_OPERATOR_BASE = 1200;
+declare const CFF_DICT_OP_CHARSET = 15;
+declare const CFF_DICT_OP_CHARSTRINGS = 17;
+declare const CFF_DICT_OP_PRIVATE = 18;
+declare const CFF_DICT_OP_SUBRS = 19;
+declare const CFF_DICT_OP_ROS: number;
+declare function readCffIndex(bytes: Uint8Array<ArrayBuffer>, offset: number): CffIndex | undefined;
+declare function parseCffDict(data: Uint8Array<ArrayBuffer>): CffDict | undefined;
+//#endregion
+export { CFF_DICT_OP_CHARSET, CFF_DICT_OP_CHARSTRINGS, CFF_DICT_OP_PRIVATE, CFF_DICT_OP_ROS, CFF_DICT_OP_SUBRS, CFF_ESCAPED_OPERATOR_BASE, CffDict, CffIndex, parseCffDict, readCffIndex };

package/dist/cff.d.ts

@@ -0,0 +1,17 @@
+//#region src/cff.d.ts
+interface CffIndex {
+  readonly count: number;
+  readonly endOffset: number;
+  entry(index: number): Uint8Array<ArrayBuffer> | undefined;
+}
+type CffDict = ReadonlyMap<number, readonly number[]>;
+declare const CFF_ESCAPED_OPERATOR_BASE = 1200;
+declare const CFF_DICT_OP_CHARSET = 15;
+declare const CFF_DICT_OP_CHARSTRINGS = 17;
+declare const CFF_DICT_OP_PRIVATE = 18;
+declare const CFF_DICT_OP_SUBRS = 19;
+declare const CFF_DICT_OP_ROS: number;
+declare function readCffIndex(bytes: Uint8Array<ArrayBuffer>, offset: number): CffIndex | undefined;
+declare function parseCffDict(data: Uint8Array<ArrayBuffer>): CffDict | undefined;
+//#endregion
+export { CFF_DICT_OP_CHARSET, CFF_DICT_OP_CHARSTRINGS, CFF_DICT_OP_PRIVATE, CFF_DICT_OP_ROS, CFF_DICT_OP_SUBRS, CFF_ESCAPED_OPERATOR_BASE, CffDict, CffIndex, parseCffDict, readCffIndex };

package/dist/cff.js

@@ -0,0 +1,150 @@
+import { hasBytes, u16, u24, u32, u8 } from "./sfnt.js";
+//#region src/cff.ts
+const CFF_ESCAPED_OPERATOR_BASE = 1200;
+const CFF_DICT_OP_CHARSET = 15;
+const CFF_DICT_OP_CHARSTRINGS = 17;
+const CFF_DICT_OP_PRIVATE = 18;
+const CFF_DICT_OP_SUBRS = 19;
+const CFF_DICT_OP_ROS = 1230;
+const INDEX_COUNT_SIZE = 2;
+const INDEX_OFF_SIZE_SIZE = 1;
+const MIN_OFF_SIZE = 1;
+const MAX_OFF_SIZE = 4;
+const DICT_OPERATOR_MAX = 21;
+const DICT_OPERATOR_ESCAPE = 12;
+const DICT_OPERAND_INT16 = 28;
+const DICT_OPERAND_INT32 = 29;
+const DICT_OPERAND_REAL = 30;
+const DICT_OPERAND_SMALL_FIRST = 32;
+const DICT_OPERAND_SMALL_LAST = 246;
+const DICT_OPERAND_MEDIUM_FIRST = 247;
+const DICT_OPERAND_MEDIUM_LAST = 250;
+const DICT_OPERAND_NEGATIVE_MEDIUM_FIRST = 251;
+const DICT_OPERAND_NEGATIVE_MEDIUM_LAST = 254;
+const DICT_OPERAND_SMALL_BIAS = 139;
+const DICT_OPERAND_MEDIUM_BIAS = 108;
+const DICT_OPERAND_MEDIUM_FIRST_BYTE_BIAS = 247;
+const DICT_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS = 251;
+const BYTE_RADIX = 256;
+const REAL_NIBBLE_DECIMAL_POINT = 10;
+const REAL_NIBBLE_EXPONENT = 11;
+const REAL_NIBBLE_NEGATIVE_EXPONENT = 12;
+const REAL_NIBBLE_RESERVED = 13;
+const REAL_NIBBLE_MINUS = 14;
+const REAL_NIBBLE_TERMINATOR = 15;
+const NIBBLES_PER_BYTE = 2;
+const HIGH_NIBBLE_SHIFT = 4;
+const LOW_NIBBLE_MASK = 15;
+function readOffsetAt(bytes, offset, offSize) {
+	if (offSize === 1) return u8(bytes, offset);
+	if (offSize === 2) return u16(bytes, offset);
+	if (offSize === 3) return u24(bytes, offset);
+	return u32(bytes, offset);
+}
+function readCffIndex(bytes, offset) {
+	if (!hasBytes(bytes, offset, INDEX_COUNT_SIZE)) return;
+	const count = u16(bytes, offset);
+	if (count === 0) return {
+		count: 0,
+		endOffset: offset + INDEX_COUNT_SIZE,
+		entry: () => void 0
+	};
+	if (!hasBytes(bytes, offset + INDEX_COUNT_SIZE, INDEX_OFF_SIZE_SIZE)) return;
+	const offSize = u8(bytes, offset + INDEX_COUNT_SIZE);
+	if (offSize < MIN_OFF_SIZE || offSize > MAX_OFF_SIZE) return;
+	const offsetArrayStart = offset + INDEX_COUNT_SIZE + INDEX_OFF_SIZE_SIZE;
+	const offsetArrayLength = (count + 1) * offSize;
+	if (!hasBytes(bytes, offsetArrayStart, offsetArrayLength)) return;
+	const offsets = [];
+	for (let i = 0; i <= count; i++) offsets.push(readOffsetAt(bytes, offsetArrayStart + i * offSize, offSize));
+	if (offsets[0] !== 1) return;
+	for (let i = 1; i <= count; i++) if (offsets[i] < offsets[i - 1]) return;
+	const dataOrigin = offsetArrayStart + offsetArrayLength - 1;
+	const dataLength = offsets[count] - 1;
+	if (!hasBytes(bytes, dataOrigin + 1, dataLength)) return;
+	return {
+		count,
+		endOffset: dataOrigin + 1 + dataLength,
+		entry: (index) => index < 0 || index >= count ? void 0 : bytes.subarray(dataOrigin + offsets[index], dataOrigin + offsets[index + 1])
+	};
+}
+function readRealOperand(data, start) {
+	let text = "";
+	for (let i = start; i < data.length; i++) {
+		const byte = data[i];
+		for (let n = 0; n < NIBBLES_PER_BYTE; n++) {
+			const nibble = n === 0 ? byte >> HIGH_NIBBLE_SHIFT : byte & LOW_NIBBLE_MASK;
+			if (nibble === REAL_NIBBLE_TERMINATOR) return {
+				value: Number(text),
+				endOffset: i + 1
+			};
+			if (nibble === REAL_NIBBLE_RESERVED) return;
+			if (nibble <= 9) text += String(nibble);
+			else if (nibble === REAL_NIBBLE_DECIMAL_POINT) text += ".";
+			else if (nibble === REAL_NIBBLE_EXPONENT) text += "E";
+			else if (nibble === REAL_NIBBLE_NEGATIVE_EXPONENT) text += "E-";
+			else if (nibble === REAL_NIBBLE_MINUS) text += "-";
+		}
+	}
+}
+function parseCffDict(data) {
+	const dict = /* @__PURE__ */ new Map();
+	let operands = [];
+	let i = 0;
+	while (i < data.length) {
+		const b0 = data[i];
+		if (b0 <= DICT_OPERATOR_MAX) {
+			let operator = b0;
+			i += 1;
+			if (b0 === DICT_OPERATOR_ESCAPE) {
+				if (i >= data.length) return;
+				operator = CFF_ESCAPED_OPERATOR_BASE + data[i];
+				i += 1;
+			}
+			dict.set(operator, operands);
+			operands = [];
+			continue;
+		}
+		if (b0 === DICT_OPERAND_INT16) {
+			if (!hasBytes(data, i + 1, 2)) return;
+			const raw = u16(data, i + 1);
+			operands.push(raw >= 32768 ? raw - 65536 : raw);
+			i += 3;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_INT32) {
+			if (!hasBytes(data, i + 1, 4)) return;
+			operands.push(u32(data, i + 1) | 0);
+			i += 5;
+			continue;
+		}
+		if (b0 === DICT_OPERAND_REAL) {
+			const real = readRealOperand(data, i + 1);
+			if (real === void 0) return;
+			operands.push(real.value);
+			i = real.endOffset;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_SMALL_FIRST && b0 <= DICT_OPERAND_SMALL_LAST) {
+			operands.push(b0 - DICT_OPERAND_SMALL_BIAS);
+			i += 1;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_MEDIUM_FIRST && b0 <= DICT_OPERAND_MEDIUM_LAST) {
+			if (!hasBytes(data, i + 1, 1)) return;
+			operands.push((b0 - DICT_OPERAND_MEDIUM_FIRST_BYTE_BIAS) * BYTE_RADIX + u8(data, i + 1) + DICT_OPERAND_MEDIUM_BIAS);
+			i += 2;
+			continue;
+		}
+		if (b0 >= DICT_OPERAND_NEGATIVE_MEDIUM_FIRST && b0 <= DICT_OPERAND_NEGATIVE_MEDIUM_LAST) {
+			if (!hasBytes(data, i + 1, 1)) return;
+			operands.push(-(b0 - DICT_OPERAND_NEGATIVE_MEDIUM_FIRST_BYTE_BIAS) * BYTE_RADIX - u8(data, i + 1) - DICT_OPERAND_MEDIUM_BIAS);
+			i += 2;
+			continue;
+		}
+		return;
+	}
+	return dict;
+}
+//#endregion
+export { CFF_DICT_OP_CHARSET, CFF_DICT_OP_CHARSTRINGS, CFF_DICT_OP_PRIVATE, CFF_DICT_OP_ROS, CFF_DICT_OP_SUBRS, CFF_ESCAPED_OPERATOR_BASE, parseCffDict, readCffIndex };

package/dist/filters.cjs

@@ -3,9 +3,10 @@ const require_bytes_reader = require("./bytes/reader.cjs");
 const require_objects = require("./objects.cjs");
 const require_bytes_flate = require("./bytes/flate.cjs");
 const require_image_ccitt = require("./image/ccitt.cjs");
+const require_image_jbig2 = require("./image/jbig2.cjs");
 const require_predictors = require("./predictors.cjs");
 //#region src/filters.ts
-function decodeStream(raw, dict, sink) {
+function decodeStream(raw, dict, sink, resolve) {
 	const filters = filterNames(dict);
 	const parms = decodeParmsList(dict, filters.length);
 	let bytes = raw;
@@ -20,10 +21,21 @@ function decodeStream(raw, dict, sink) {
 		else if (filter === "ASCIIHexDecode" || filter === "AHx") bytes = asciiHexDecode(bytes);
 		else if (filter === "RunLengthDecode" || filter === "RL") bytes = runLengthDecode(bytes);
 		else if (filter === "CCITTFaxDecode" || filter === "CCF") bytes = ccittFaxDecode(bytes, parm, dict, sink);
-		else if (filter === "DCTDecode" || filter === "DCT") return {
+		else if (filter === "JBIG2Decode") {
+			const decoded = jbig2Decode(bytes, parm, dict, sink, resolve);
+			if (decoded === void 0) return {
+				bytes,
+				remainingFilter: "JBIG2Decode"
+			};
+			bytes = decoded;
+		} else if (filter === "DCTDecode" || filter === "DCT") return {
 			bytes,
 			remainingFilter: "DCTDecode"
 		};
+		else if (filter === "JPXDecode") return {
+			bytes,
+			remainingFilter: "JPXDecode"
+		};
 		else {
 			sink({
 				code: "pdf/unsupported-filter",
@@ -57,6 +69,37 @@ function ccittFaxDecode(data, parm, dict, sink) {
 		})
 	}).bytes;
 }
+function jbig2Decode(data, parm, dict, sink, resolve) {
+	const globalsObj = parm !== void 0 ? require_objects.dictGet(parm, "JBIG2Globals") : void 0;
+	const resolvedGlobals = resolve !== void 0 ? resolve(globalsObj) : globalsObj;
+	let globals;
+	if (resolvedGlobals?.kind === "stream") globals = decodeStream(resolvedGlobals.raw, resolvedGlobals.dict, sink, resolve).bytes;
+	else if (globalsObj !== void 0) sink({
+		code: "pdf/jbig2-degraded",
+		severity: "warning",
+		message: "a JBIG2Decode stream declares /JBIG2Globals but it could not be resolved to a stream; decoding without it, which will fail if the page refers to a shared symbol dictionary"
+	});
+	try {
+		const image = require_image_jbig2.decodeJbig2Embedded(data, {
+			globals,
+			width: require_objects.asNumber(require_objects.dictGet(dict, "Width") ?? require_objects.dictGet(dict, "W")),
+			height: require_objects.asNumber(require_objects.dictGet(dict, "Height") ?? require_objects.dictGet(dict, "H")),
+			onWarning: (message) => sink({
+				code: "pdf/jbig2-degraded",
+				severity: "warning",
+				message
+			})
+		});
+		return Uint8Array.from(image.bytes, (byte) => byte ^ 255);
+	} catch (error) {
+		sink({
+			code: "pdf/jbig2-undecodable",
+			severity: "warning",
+			message: `JBIG2Decode stream could not be decoded (${error instanceof Error ? error.message : String(error)}); leaving its bytes undecoded`
+		});
+		return;
+	}
+}
 function filterNames(dict) {
 	const filterObj = require_objects.dictGet(dict, "Filter") ?? require_objects.dictGet(dict, "F");
 	if (filterObj === void 0) return [];

package/dist/filters.d.cts

@@ -1,14 +1,15 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { PdfDict } from "./objects.cjs";
+import { PdfDict, PdfObject } from "./objects.cjs";
 //#region src/filters.d.ts
 interface DecodedStream {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly remainingFilter?: string;
 }
-declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink): DecodedStream;
+type PdfIndirectResolver = (obj: PdfObject | undefined) => PdfObject | undefined;
+declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink, resolve?: PdfIndirectResolver): DecodedStream;
 declare function lzwDecode(data: Uint8Array<ArrayBuffer>, earlyChange: boolean, sink: PdfDiagnosticSink): Uint8Array<ArrayBuffer>;
 declare function ascii85Decode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 declare function asciiHexDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 declare function runLengthDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 //#endregion
-export { DecodedStream, ascii85Decode, asciiHexDecode, decodeStream, lzwDecode, runLengthDecode };
+export { DecodedStream, PdfIndirectResolver, ascii85Decode, asciiHexDecode, decodeStream, lzwDecode, runLengthDecode };

package/dist/filters.d.ts

@@ -1,14 +1,15 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { PdfDict } from "./objects.js";
+import { PdfDict, PdfObject } from "./objects.js";
 //#region src/filters.d.ts
 interface DecodedStream {
   readonly bytes: Uint8Array<ArrayBuffer>;
   readonly remainingFilter?: string;
 }
-declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink): DecodedStream;
+type PdfIndirectResolver = (obj: PdfObject | undefined) => PdfObject | undefined;
+declare function decodeStream(raw: Uint8Array<ArrayBuffer>, dict: PdfDict, sink: PdfDiagnosticSink, resolve?: PdfIndirectResolver): DecodedStream;
 declare function lzwDecode(data: Uint8Array<ArrayBuffer>, earlyChange: boolean, sink: PdfDiagnosticSink): Uint8Array<ArrayBuffer>;
 declare function ascii85Decode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 declare function asciiHexDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 declare function runLengthDecode(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 //#endregion
-export { DecodedStream, ascii85Decode, asciiHexDecode, decodeStream, lzwDecode, runLengthDecode };
+export { DecodedStream, PdfIndirectResolver, ascii85Decode, asciiHexDecode, decodeStream, lzwDecode, runLengthDecode };

package/dist/filters.js

@@ -2,9 +2,10 @@ import { isAsciiWhitespace } from "./bytes/reader.js";
 import { asArray, asBool, asDict, asName, asNumber, dictGet } from "./objects.js";
 import { inflateTolerant } from "./bytes/flate.js";
 import { decodeCcittFax } from "./image/ccitt.js";
+import { decodeJbig2Embedded } from "./image/jbig2.js";
 import { applyPredictor, readPredictorParams } from "./predictors.js";
 //#region src/filters.ts
-function decodeStream(raw, dict, sink) {
+function decodeStream(raw, dict, sink, resolve) {
 	const filters = filterNames(dict);
 	const parms = decodeParmsList(dict, filters.length);
 	let bytes = raw;
@@ -19,10 +20,21 @@ function decodeStream(raw, dict, sink) {
 		else if (filter === "ASCIIHexDecode" || filter === "AHx") bytes = asciiHexDecode(bytes);
 		else if (filter === "RunLengthDecode" || filter === "RL") bytes = runLengthDecode(bytes);
 		else if (filter === "CCITTFaxDecode" || filter === "CCF") bytes = ccittFaxDecode(bytes, parm, dict, sink);
-		else if (filter === "DCTDecode" || filter === "DCT") return {
+		else if (filter === "JBIG2Decode") {
+			const decoded = jbig2Decode(bytes, parm, dict, sink, resolve);
+			if (decoded === void 0) return {
+				bytes,
+				remainingFilter: "JBIG2Decode"
+			};
+			bytes = decoded;
+		} else if (filter === "DCTDecode" || filter === "DCT") return {
 			bytes,
 			remainingFilter: "DCTDecode"
 		};
+		else if (filter === "JPXDecode") return {
+			bytes,
+			remainingFilter: "JPXDecode"
+		};
 		else {
 			sink({
 				code: "pdf/unsupported-filter",
@@ -56,6 +68,37 @@ function ccittFaxDecode(data, parm, dict, sink) {
 		})
 	}).bytes;
 }
+function jbig2Decode(data, parm, dict, sink, resolve) {
+	const globalsObj = parm !== void 0 ? dictGet(parm, "JBIG2Globals") : void 0;
+	const resolvedGlobals = resolve !== void 0 ? resolve(globalsObj) : globalsObj;
+	let globals;
+	if (resolvedGlobals?.kind === "stream") globals = decodeStream(resolvedGlobals.raw, resolvedGlobals.dict, sink, resolve).bytes;
+	else if (globalsObj !== void 0) sink({
+		code: "pdf/jbig2-degraded",
+		severity: "warning",
+		message: "a JBIG2Decode stream declares /JBIG2Globals but it could not be resolved to a stream; decoding without it, which will fail if the page refers to a shared symbol dictionary"
+	});
+	try {
+		const image = decodeJbig2Embedded(data, {
+			globals,
+			width: asNumber(dictGet(dict, "Width") ?? dictGet(dict, "W")),
+			height: asNumber(dictGet(dict, "Height") ?? dictGet(dict, "H")),
+			onWarning: (message) => sink({
+				code: "pdf/jbig2-degraded",
+				severity: "warning",
+				message
+			})
+		});
+		return Uint8Array.from(image.bytes, (byte) => byte ^ 255);
+	} catch (error) {
+		sink({
+			code: "pdf/jbig2-undecodable",
+			severity: "warning",
+			message: `JBIG2Decode stream could not be decoded (${error instanceof Error ? error.message : String(error)}); leaving its bytes undecoded`
+		});
+		return;
+	}
+}
 function filterNames(dict) {
 	const filterObj = dictGet(dict, "Filter") ?? dictGet(dict, "F");
 	if (filterObj === void 0) return [];

package/dist/formula.d.cts

@@ -1,4 +1,4 @@
-import { t as MathBox } from "./math-types-Ba8qAf1p.cjs";
+import { t as MathBox } from "./math-types-YSQUTviw.cjs";
 //#region src/formula.d.ts
 interface PositionedFormula {
   readonly pageIndex: number;

package/dist/formula.d.ts

@@ -1,4 +1,4 @@
-import { t as MathBox } from "./math-types-Ba8qAf1p.js";
+import { t as MathBox } from "./math-types-YSQUTviw.js";
 //#region src/formula.d.ts
 interface PositionedFormula {
   readonly pageIndex: number;

package/dist/glyf.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sfnt = require("./sfnt.cjs");
+const require_glyph_bounds = require("./glyph-bounds.cjs");
 //#region src/glyf.ts
 const LOCA_SHORT_ENTRY_SIZE = 2;
 const LOCA_LONG_ENTRY_SIZE = 4;
@@ -21,6 +22,9 @@ const WE_HAVE_A_SCALE = 8;
 const MORE_COMPONENTS = 32;
 const WE_HAVE_AN_X_AND_Y_SCALE = 64;
 const WE_HAVE_A_TWO_BY_TWO = 128;
+const SCALED_COMPONENT_OFFSET = 2048;
+const UNSCALED_COMPONENT_OFFSET = 4096;
+const MAX_COMPOSITE_DEPTH = 5;
 const COMPONENT_RECORD_HEADER_SIZE = 4;
 function signedByte(value) {
 	return value >= 128 ? value - 256 : value;
@@ -88,6 +92,31 @@ function readComponents(glyph) {
 		if ((flags & MORE_COMPONENTS) === 0) return components;
 	}
 }
+function placeComponentBounds(bounds, component) {
+	const [a, b, c, d] = component.transform ?? [
+		1,
+		0,
+		0,
+		1
+	];
+	const corners = [
+		[bounds.xMin, bounds.yMin],
+		[bounds.xMax, bounds.yMin],
+		[bounds.xMin, bounds.yMax],
+		[bounds.xMax, bounds.yMax]
+	];
+	const xs = corners.map(([x, y]) => a * x + c * y);
+	const ys = corners.map(([x, y]) => b * x + d * y);
+	const scaledOffset = (component.flags & SCALED_COMPONENT_OFFSET) !== 0 && (component.flags & UNSCALED_COMPONENT_OFFSET) === 0;
+	const dx = scaledOffset ? a * component.argument1 + c * component.argument2 : component.argument1;
+	const dy = scaledOffset ? b * component.argument1 + d * component.argument2 : component.argument2;
+	return {
+		xMin: Math.min(...xs) + dx,
+		yMin: Math.min(...ys) + dy,
+		xMax: Math.max(...xs) + dx,
+		yMax: Math.max(...ys) + dy
+	};
+}
 function parseGlyf(font, options) {
 	const glyfBytes = require_sfnt.sfntTableBytes(font, "glyf");
 	const loca = parseLoca(font, options);
@@ -110,16 +139,43 @@ function parseGlyf(font, options) {
 			yMax: require_sfnt.i16(glyph, 8)
 		};
 	};
+	const compositeComponents = (glyphId) => {
+		const header = glyphHeader(glyphId);
+		if (header === void 0 || header.numberOfContours >= 0) return;
+		const glyph = glyphBytes(glyphId);
+		return glyph === void 0 ? void 0 : readComponents(glyph);
+	};
+	const resolveInkBounds = (glyphId, depth) => {
+		const header = glyphHeader(glyphId);
+		if (header === void 0) return;
+		if (header.numberOfContours >= 0) return {
+			xMin: header.xMin,
+			yMin: header.yMin,
+			xMax: header.xMax,
+			yMax: header.yMax
+		};
+		if (depth >= MAX_COMPOSITE_DEPTH) return;
+		const components = compositeComponents(glyphId);
+		if (components === void 0) return;
+		let bounds;
+		for (const component of components) {
+			if (!component.argsAreXyValues) return;
+			const componentBytes = glyphBytes(component.glyphIndex);
+			if (componentBytes === void 0) return;
+			if (componentBytes.length === 0) continue;
+			const componentBounds = resolveInkBounds(component.glyphIndex, depth + 1);
+			if (componentBounds === void 0) return;
+			const placed = placeComponentBounds(componentBounds, component);
+			bounds = bounds === void 0 ? placed : require_glyph_bounds.unionGlyphInkBounds(bounds, placed);
+		}
+		return bounds;
+	};
 	return {
 		numGlyphs: options.numGlyphs,
 		glyphBytes,
 		glyphHeader,
-		compositeComponents(glyphId) {
-			const header = glyphHeader(glyphId);
-			if (header === void 0 || header.numberOfContours >= 0) return;
-			const glyph = glyphBytes(glyphId);
-			return glyph === void 0 ? void 0 : readComponents(glyph);
-		}
+		compositeComponents,
+		glyphInkBounds: (glyphId) => resolveInkBounds(glyphId, 0)
 	};
 }
 //#endregion

package/dist/glyf.d.cts

@@ -1,3 +1,4 @@
+import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.cjs";
 import { t as SfntFont } from "./sfnt-V08bb5ut.cjs";
 //#region src/glyf.d.ts
 interface GlyphHeader {
@@ -20,6 +21,7 @@ interface GlyfTable {
   glyphBytes(glyphId: number): Uint8Array<ArrayBuffer> | undefined;
   glyphHeader(glyphId: number): GlyphHeader | undefined;
   compositeComponents(glyphId: number): readonly CompositeComponent[] | undefined;
+  glyphInkBounds(glyphId: number): GlyphInkBounds | undefined;
 }
 interface GlyfOptions {
   readonly numGlyphs: number;

package/dist/glyf.d.ts

@@ -1,3 +1,4 @@
+import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.js";
 import { t as SfntFont } from "./sfnt-V08bb5ut.js";
 //#region src/glyf.d.ts
 interface GlyphHeader {
@@ -20,6 +21,7 @@ interface GlyfTable {
   glyphBytes(glyphId: number): Uint8Array<ArrayBuffer> | undefined;
   glyphHeader(glyphId: number): GlyphHeader | undefined;
   compositeComponents(glyphId: number): readonly CompositeComponent[] | undefined;
+  glyphInkBounds(glyphId: number): GlyphInkBounds | undefined;
 }
 interface GlyfOptions {
   readonly numGlyphs: number;