pdf-codec 1.4.2 → 1.5.0

package/dist/filters.js

@@ -1,6 +1,7 @@
 import { isAsciiWhitespace } from "./bytes/reader.js";
+import { asArray, asBool, asDict, asName, asNumber, dictGet } from "./objects.js";
 import { inflateTolerant } from "./bytes/flate.js";
-import { asArray, asDict, asName, asNumber, dictGet } from "./objects.js";
+import { decodeCcittFax } from "./image/ccitt.js";
 import { applyPredictor, readPredictorParams } from "./predictors.js";
 //#region src/filters.ts
 function decodeStream(raw, dict, sink) {
@@ -17,6 +18,7 @@ function decodeStream(raw, dict, sink) {
 		} else if (filter === "ASCII85Decode" || filter === "A85") bytes = ascii85Decode(bytes);
 		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 {
 			bytes,
 			remainingFilter: "DCTDecode"
@@ -38,6 +40,22 @@ function decodeStream(raw, dict, sink) {
 function applyPredictorIfPresent(data, parm, sink) {
 	return applyPredictor(data, readPredictorParams(parm), sink);
 }
+function ccittFaxDecode(data, parm, dict, sink) {
+	const parmGet = (key) => parm !== void 0 ? dictGet(parm, key) : void 0;
+	const rows = asNumber(parmGet("Rows")) ?? asNumber(dictGet(dict, "Height") ?? dictGet(dict, "H"));
+	return decodeCcittFax(data, {
+		k: asNumber(parmGet("K")),
+		columns: asNumber(parmGet("Columns")),
+		rows,
+		blackIs1: asBool(parmGet("BlackIs1")),
+		encodedByteAlign: asBool(parmGet("EncodedByteAlign")),
+		onWarning: (message) => sink({
+			code: "pdf/ccitt-fax-degraded",
+			severity: "warning",
+			message
+		})
+	}).bytes;
+}
 function filterNames(dict) {
 	const filterObj = dictGet(dict, "Filter") ?? dictGet(dict, "F");
 	if (filterObj === void 0) return [];

package/dist/image/ccitt.cjs

@@ -0,0 +1,488 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_writer = require("../bytes/writer.cjs");
+//#region src/image/ccitt.ts
+const WHITE_TERMINATING_AND_MAKEUP = [
+	["00110101", 0],
+	["000111", 1],
+	["0111", 2],
+	["1000", 3],
+	["1011", 4],
+	["1100", 5],
+	["1110", 6],
+	["1111", 7],
+	["10011", 8],
+	["10100", 9],
+	["00111", 10],
+	["01000", 11],
+	["001000", 12],
+	["000011", 13],
+	["110100", 14],
+	["110101", 15],
+	["101010", 16],
+	["101011", 17],
+	["0100111", 18],
+	["0001100", 19],
+	["0001000", 20],
+	["0010111", 21],
+	["0000011", 22],
+	["0000100", 23],
+	["0101000", 24],
+	["0101011", 25],
+	["0010011", 26],
+	["0100100", 27],
+	["0011000", 28],
+	["00000010", 29],
+	["00000011", 30],
+	["00011010", 31],
+	["00011011", 32],
+	["00010010", 33],
+	["00010011", 34],
+	["00010100", 35],
+	["00010101", 36],
+	["00010110", 37],
+	["00010111", 38],
+	["00101000", 39],
+	["00101001", 40],
+	["00101010", 41],
+	["00101011", 42],
+	["00101100", 43],
+	["00101101", 44],
+	["00000100", 45],
+	["00000101", 46],
+	["00001010", 47],
+	["00001011", 48],
+	["01010010", 49],
+	["01010011", 50],
+	["01010100", 51],
+	["01010101", 52],
+	["00100100", 53],
+	["00100101", 54],
+	["01011000", 55],
+	["01011001", 56],
+	["01011010", 57],
+	["01011011", 58],
+	["01001010", 59],
+	["01001011", 60],
+	["00110010", 61],
+	["00110011", 62],
+	["00110100", 63],
+	["11011", 64],
+	["10010", 128],
+	["010111", 192],
+	["0110111", 256],
+	["00110110", 320],
+	["00110111", 384],
+	["01100100", 448],
+	["01100101", 512],
+	["01101000", 576],
+	["01100111", 640],
+	["011001100", 704],
+	["011001101", 768],
+	["011010010", 832],
+	["011010011", 896],
+	["011010100", 960],
+	["011010101", 1024],
+	["011010110", 1088],
+	["011010111", 1152],
+	["011011000", 1216],
+	["011011001", 1280],
+	["011011010", 1344],
+	["011011011", 1408],
+	["010011000", 1472],
+	["010011001", 1536],
+	["010011010", 1600],
+	["011000", 1664],
+	["010011011", 1728]
+];
+const BLACK_TERMINATING_AND_MAKEUP = [
+	["0000110111", 0],
+	["010", 1],
+	["11", 2],
+	["10", 3],
+	["011", 4],
+	["0011", 5],
+	["0010", 6],
+	["00011", 7],
+	["000101", 8],
+	["000100", 9],
+	["0000100", 10],
+	["0000101", 11],
+	["0000111", 12],
+	["00000100", 13],
+	["00000111", 14],
+	["000011000", 15],
+	["0000010111", 16],
+	["0000011000", 17],
+	["0000001000", 18],
+	["00001100111", 19],
+	["00001101000", 20],
+	["00001101100", 21],
+	["00000110111", 22],
+	["00000101000", 23],
+	["00000010111", 24],
+	["00000011000", 25],
+	["000011001010", 26],
+	["000011001011", 27],
+	["000011001100", 28],
+	["000011001101", 29],
+	["000001101000", 30],
+	["000001101001", 31],
+	["000001101010", 32],
+	["000001101011", 33],
+	["000011010010", 34],
+	["000011010011", 35],
+	["000011010100", 36],
+	["000011010101", 37],
+	["000011010110", 38],
+	["000011010111", 39],
+	["000001101100", 40],
+	["000001101101", 41],
+	["000011011010", 42],
+	["000011011011", 43],
+	["000001010100", 44],
+	["000001010101", 45],
+	["000001010110", 46],
+	["000001010111", 47],
+	["000001100100", 48],
+	["000001100101", 49],
+	["000001010010", 50],
+	["000001010011", 51],
+	["000000100100", 52],
+	["000000110111", 53],
+	["000000111000", 54],
+	["000000100111", 55],
+	["000000101000", 56],
+	["000001011000", 57],
+	["000001011001", 58],
+	["000000101011", 59],
+	["000000101100", 60],
+	["000001011010", 61],
+	["000001100110", 62],
+	["000001100111", 63],
+	["0000001111", 64],
+	["000011001000", 128],
+	["000011001001", 192],
+	["000001011011", 256],
+	["000000110011", 320],
+	["000000110100", 384],
+	["000000110101", 448],
+	["0000001101100", 512],
+	["0000001101101", 576],
+	["0000001001010", 640],
+	["0000001001011", 704],
+	["0000001001100", 768],
+	["0000001001101", 832],
+	["0000001110010", 896],
+	["0000001110011", 960],
+	["0000001110100", 1024],
+	["0000001110101", 1088],
+	["0000001110110", 1152],
+	["0000001110111", 1216],
+	["0000001010010", 1280],
+	["0000001010011", 1344],
+	["0000001010100", 1408],
+	["0000001010101", 1472],
+	["0000001011010", 1536],
+	["0000001011011", 1600],
+	["0000001100100", 1664],
+	["0000001100101", 1728]
+];
+const EXTENDED_MAKEUP = [
+	["00000001000", 1792],
+	["00000001100", 1856],
+	["00000001101", 1920],
+	["000000010010", 1984],
+	["000000010011", 2048],
+	["000000010100", 2112],
+	["000000010101", 2176],
+	["000000010110", 2240],
+	["000000010111", 2304],
+	["000000011100", 2368],
+	["000000011101", 2432],
+	["000000011110", 2496],
+	["000000011111", 2560]
+];
+const TERMINATING_RUN_LIMIT = 64;
+const MAX_RUN_CODE_BITS = 14;
+const MODE_CODES = [
+	["1", {
+		kind: "vertical",
+		delta: 0
+	}],
+	["011", {
+		kind: "vertical",
+		delta: 1
+	}],
+	["010", {
+		kind: "vertical",
+		delta: -1
+	}],
+	["001", {
+		kind: "horizontal",
+		delta: 0
+	}],
+	["0001", {
+		kind: "pass",
+		delta: 0
+	}],
+	["000011", {
+		kind: "vertical",
+		delta: 2
+	}],
+	["000010", {
+		kind: "vertical",
+		delta: -2
+	}],
+	["0000011", {
+		kind: "vertical",
+		delta: 3
+	}],
+	["0000010", {
+		kind: "vertical",
+		delta: -3
+	}],
+	["0000001", {
+		kind: "extension",
+		delta: 0
+	}]
+];
+const MAX_MODE_CODE_BITS = 7;
+const EOL_MIN_ZEROS = 11;
+const MAX_FILL_ZERO_BITS = 512;
+function codeKey(bitLength, code) {
+	return bitLength * 2 ** 16 + code;
+}
+function buildCodeTable(...groups) {
+	const table = /* @__PURE__ */ new Map();
+	for (const group of groups) for (const [bits, run] of group) table.set(codeKey(bits.length, Number.parseInt(bits, 2)), run);
+	return table;
+}
+const WHITE_CODE_TABLE = buildCodeTable(WHITE_TERMINATING_AND_MAKEUP, EXTENDED_MAKEUP);
+const BLACK_CODE_TABLE = buildCodeTable(BLACK_TERMINATING_AND_MAKEUP, EXTENDED_MAKEUP);
+const MODE_CODE_TABLE = new Map(MODE_CODES.map(([bits, mode]) => [codeKey(bits.length, Number.parseInt(bits, 2)), mode]));
+const BITS_PER_BYTE = 8;
+var CcittBitReader = class {
+	data;
+	position = 0;
+	constructor(data) {
+		this.data = data;
+	}
+	get bitPosition() {
+		return this.position;
+	}
+	set bitPosition(value) {
+		this.position = value;
+	}
+	get exhausted() {
+		return this.position >= this.data.length * BITS_PER_BYTE;
+	}
+	readBit() {
+		if (this.exhausted) return -1;
+		const bit = (this.data[this.position >> 3] ?? 0) >> 7 - (this.position & 7) & 1;
+		this.position++;
+		return bit;
+	}
+	alignToByte() {
+		this.position = Math.ceil(this.position / BITS_PER_BYTE) * BITS_PER_BYTE;
+	}
+	get atZeroPadding() {
+		const remaining = this.data.length * BITS_PER_BYTE - this.position;
+		if (remaining <= 0) return true;
+		if (remaining >= BITS_PER_BYTE) return false;
+		return ((this.data[this.data.length - 1] ?? 0) & (1 << remaining) - 1) === 0;
+	}
+};
+function readSingleRunCode(reader, table) {
+	let code = 0;
+	for (let bitLength = 1; bitLength <= MAX_RUN_CODE_BITS; bitLength++) {
+		const bit = reader.readBit();
+		if (bit < 0) return;
+		code = code << 1 | bit;
+		const run = table.get(codeKey(bitLength, code));
+		if (run !== void 0) return run;
+	}
+}
+function readRunLength(reader, black) {
+	const table = black ? BLACK_CODE_TABLE : WHITE_CODE_TABLE;
+	let total = 0;
+	for (;;) {
+		const run = readSingleRunCode(reader, table);
+		if (run === void 0) return;
+		total += run;
+		if (run < TERMINATING_RUN_LIMIT) return total;
+	}
+}
+function readModeCode(reader) {
+	let code = 0;
+	for (let bitLength = 1; bitLength <= MAX_MODE_CODE_BITS; bitLength++) {
+		const bit = reader.readBit();
+		if (bit < 0) return {
+			kind: "invalid",
+			delta: 0
+		};
+		code = code << 1 | bit;
+		const mode = MODE_CODE_TABLE.get(codeKey(bitLength, code));
+		if (mode !== void 0) return mode;
+	}
+	return code === 0 ? {
+		kind: "eol-prefix",
+		delta: 0
+	} : {
+		kind: "invalid",
+		delta: 0
+	};
+}
+function tryReadEol(reader) {
+	const start = reader.bitPosition;
+	let zeros = 0;
+	for (;;) {
+		const bit = reader.readBit();
+		if (bit < 0) {
+			reader.bitPosition = start;
+			return false;
+		}
+		if (bit === 0) {
+			zeros++;
+			if (zeros > MAX_FILL_ZERO_BITS) {
+				reader.bitPosition = start;
+				return false;
+			}
+			continue;
+		}
+		if (zeros >= EOL_MIN_ZEROS) return true;
+		reader.bitPosition = start;
+		return false;
+	}
+}
+function findB1Index(reference, a0, color) {
+	let index = 0;
+	while (index < reference.length && reference[index] <= a0) index++;
+	if (index < reference.length && (index & 1) !== color) index++;
+	return index;
+}
+function elementAt(reference, index, columns) {
+	return index < reference.length ? reference[index] : columns;
+}
+function decode1dRow(reader, columns) {
+	const transitions = [];
+	let position = 0;
+	let black = false;
+	while (position < columns) {
+		const run = readRunLength(reader, black);
+		if (run === void 0) return;
+		position = Math.min(columns, position + run);
+		transitions.push(position);
+		black = !black;
+	}
+	return transitions;
+}
+function decode2dRow(reader, reference, columns) {
+	const transitions = [];
+	let a0 = -1;
+	let color = 0;
+	const maxTransitions = columns + 2;
+	while (a0 < columns) {
+		if (transitions.length > maxTransitions) return;
+		const mode = readModeCode(reader);
+		if (mode.kind === "invalid" || mode.kind === "extension") return;
+		if (mode.kind === "eol-prefix") return;
+		const b1Index = findB1Index(reference, a0, color);
+		const b1 = elementAt(reference, b1Index, columns);
+		const b2 = elementAt(reference, b1Index + 1, columns);
+		if (mode.kind === "pass") {
+			a0 = b2;
+			continue;
+		}
+		if (mode.kind === "horizontal") {
+			const start = a0 < 0 ? 0 : a0;
+			const firstRun = readRunLength(reader, color === 1);
+			if (firstRun === void 0) return;
+			const secondRun = readRunLength(reader, color !== 1);
+			if (secondRun === void 0) return;
+			const a1 = Math.min(columns, start + firstRun);
+			const a2 = Math.min(columns, a1 + secondRun);
+			transitions.push(a1, a2);
+			a0 = a2;
+			continue;
+		}
+		const a1 = Math.min(columns, Math.max(0, b1 + mode.delta));
+		transitions.push(a1);
+		a0 = a1;
+		color ^= 1;
+	}
+	return transitions;
+}
+function setBitRun(row, from, to, bit) {
+	for (let x = from; x < to; x++) {
+		const index = x >> 3;
+		const mask = 128 >> (x & 7);
+		if (bit === 1) row[index] = (row[index] ?? 0) | mask;
+		else row[index] = (row[index] ?? 0) & ~mask;
+	}
+}
+function renderRow(transitions, columns, blackBit) {
+	const row = new Uint8Array(Math.ceil(columns / 8));
+	if (blackBit === 0) row.fill(255);
+	let position = 0;
+	let black = false;
+	for (const transition of transitions) {
+		const end = Math.min(transition, columns);
+		if (black && end > position) setBitRun(row, position, end, blackBit);
+		position = Math.max(position, end);
+		black = !black;
+	}
+	return row;
+}
+const DEFAULT_COLUMNS = 1728;
+function decodeCcittFax(data, options = {}) {
+	const columns = options.columns ?? DEFAULT_COLUMNS;
+	const requestedRows = options.rows ?? 0;
+	const k = options.k ?? 0;
+	const blackBit = options.blackIs1 === true ? 1 : 0;
+	const encodedByteAlign = options.encodedByteAlign === true;
+	const warn = options.onWarning;
+	if (columns <= 0) return {
+		bytes: /* @__PURE__ */ new Uint8Array(0),
+		columns: 0,
+		rows: 0
+	};
+	const reader = new CcittBitReader(data);
+	const rows = [];
+	let reference = [];
+	let nextRowIs1d = k >= 0;
+	while (requestedRows === 0 || rows.length < requestedRows) {
+		if (encodedByteAlign) reader.alignToByte();
+		if (tryReadEol(reader)) {
+			if (k > 0) {
+				const tag = reader.readBit();
+				if (tag < 0) break;
+				nextRowIs1d = tag === 1;
+			}
+			if (tryReadEol(reader)) break;
+		}
+		if (reader.atZeroPadding) break;
+		const transitions = nextRowIs1d ? decode1dRow(reader, columns) : decode2dRow(reader, reference, columns);
+		if (transitions === void 0) {
+			if (warn !== void 0) warn(`CCITT fax data became undecodable at row ${String(rows.length)}; keeping the ${String(rows.length)} row(s) recovered so far`);
+			break;
+		}
+		rows.push(renderRow(transitions, columns, blackBit));
+		reference = transitions;
+	}
+	if (requestedRows > 0 && rows.length < requestedRows) {
+		if (warn !== void 0 && rows.length > 0) warn(`CCITT fax data ended after ${String(rows.length)} of ${String(requestedRows)} declared rows; padding the remainder white`);
+		const bytesPerRow = Math.ceil(columns / 8);
+		while (rows.length < requestedRows) {
+			const blank = new Uint8Array(bytesPerRow);
+			if (blackBit === 0) blank.fill(255);
+			rows.push(blank);
+		}
+	}
+	return {
+		bytes: require_bytes_writer.concatBytes(rows),
+		columns,
+		rows: rows.length
+	};
+}
+//#endregion
+exports.decodeCcittFax = decodeCcittFax;

package/dist/image/ccitt.d.cts

@@ -0,0 +1,17 @@
+//#region src/image/ccitt.d.ts
+interface CcittFaxOptions {
+  readonly k?: number;
+  readonly columns?: number;
+  readonly rows?: number;
+  readonly blackIs1?: boolean;
+  readonly encodedByteAlign?: boolean;
+  readonly onWarning?: (message: string) => void;
+}
+interface CcittFaxImage {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly columns: number;
+  readonly rows: number;
+}
+declare function decodeCcittFax(data: Uint8Array<ArrayBuffer>, options?: CcittFaxOptions): CcittFaxImage;
+//#endregion
+export { CcittFaxImage, CcittFaxOptions, decodeCcittFax };

package/dist/image/ccitt.d.ts

@@ -0,0 +1,17 @@
+//#region src/image/ccitt.d.ts
+interface CcittFaxOptions {
+  readonly k?: number;
+  readonly columns?: number;
+  readonly rows?: number;
+  readonly blackIs1?: boolean;
+  readonly encodedByteAlign?: boolean;
+  readonly onWarning?: (message: string) => void;
+}
+interface CcittFaxImage {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly columns: number;
+  readonly rows: number;
+}
+declare function decodeCcittFax(data: Uint8Array<ArrayBuffer>, options?: CcittFaxOptions): CcittFaxImage;
+//#endregion
+export { CcittFaxImage, CcittFaxOptions, decodeCcittFax };