pdf-codec 1.6.0 → 1.7.0

package/dist/image/jbig2-text.d.cts

@@ -0,0 +1,58 @@
+import { ArithContexts, MqDecoder } from "./jbig2-arith.cjs";
+import { Jbig2Bitmap, Jbig2CombinationOperator } from "./jbig2-bitmap.cjs";
+import { Jbig2AtPixel } from "./jbig2-generic.cjs";
+//#region src/image/jbig2-text.d.ts
+interface Jbig2ReferenceCorner {
+  readonly right: boolean;
+  readonly bottom: boolean;
+}
+declare function referenceCornerFromCode(code: number): Jbig2ReferenceCorner | undefined;
+declare function symbolCodeLength(symbolCount: number): number;
+interface TextArithContexts {
+  readonly iadh: ArithContexts;
+  readonly iadw: ArithContexts;
+  readonly iaex: ArithContexts;
+  readonly iaai: ArithContexts;
+  readonly iadt: ArithContexts;
+  readonly iafs: ArithContexts;
+  readonly iads: ArithContexts;
+  readonly iait: ArithContexts;
+  readonly iari: ArithContexts;
+  readonly iardw: ArithContexts;
+  readonly iardh: ArithContexts;
+  readonly iardx: ArithContexts;
+  readonly iardy: ArithContexts;
+  readonly iaid: ArithContexts;
+  readonly generic: ArithContexts;
+  readonly refinement: ArithContexts;
+}
+declare function createTextArithContexts(genericTemplate: number, refinementTemplate: number, symbolIdBits: number): TextArithContexts;
+interface TextRegionParams {
+  readonly width: number;
+  readonly height: number;
+  readonly instanceCount: number;
+  readonly stripSize: number;
+  readonly symbols: readonly Jbig2Bitmap[];
+  readonly defaultPixel: number;
+  readonly combinationOperator: Jbig2CombinationOperator;
+  readonly transposed: boolean;
+  readonly referenceCorner: Jbig2ReferenceCorner;
+  readonly dsOffset: number;
+  readonly refine: boolean;
+  readonly refinementTemplate: number;
+  readonly refinementAt: readonly Jbig2AtPixel[];
+}
+declare function decodeTextRegion(params: TextRegionParams, mq: MqDecoder, contexts: TextArithContexts, symbolIdBits: number): Jbig2Bitmap;
+interface SymbolDictionaryParams {
+  readonly template: number;
+  readonly at: readonly Jbig2AtPixel[];
+  readonly refinementAggregate: boolean;
+  readonly refinementTemplate: number;
+  readonly refinementAt: readonly Jbig2AtPixel[];
+  readonly newSymbolCount: number;
+  readonly exportedSymbolCount: number;
+  readonly inputSymbols: readonly Jbig2Bitmap[];
+}
+declare function decodeSymbolDictionary(params: SymbolDictionaryParams, mq: MqDecoder, contexts: TextArithContexts, symbolIdBits: number): readonly Jbig2Bitmap[];
+//#endregion
+export { Jbig2ReferenceCorner, SymbolDictionaryParams, TextArithContexts, TextRegionParams, createTextArithContexts, decodeSymbolDictionary, decodeTextRegion, referenceCornerFromCode, symbolCodeLength };

package/dist/image/jbig2-text.d.ts

@@ -0,0 +1,58 @@
+import { ArithContexts, MqDecoder } from "./jbig2-arith.js";
+import { Jbig2Bitmap, Jbig2CombinationOperator } from "./jbig2-bitmap.js";
+import { Jbig2AtPixel } from "./jbig2-generic.js";
+//#region src/image/jbig2-text.d.ts
+interface Jbig2ReferenceCorner {
+  readonly right: boolean;
+  readonly bottom: boolean;
+}
+declare function referenceCornerFromCode(code: number): Jbig2ReferenceCorner | undefined;
+declare function symbolCodeLength(symbolCount: number): number;
+interface TextArithContexts {
+  readonly iadh: ArithContexts;
+  readonly iadw: ArithContexts;
+  readonly iaex: ArithContexts;
+  readonly iaai: ArithContexts;
+  readonly iadt: ArithContexts;
+  readonly iafs: ArithContexts;
+  readonly iads: ArithContexts;
+  readonly iait: ArithContexts;
+  readonly iari: ArithContexts;
+  readonly iardw: ArithContexts;
+  readonly iardh: ArithContexts;
+  readonly iardx: ArithContexts;
+  readonly iardy: ArithContexts;
+  readonly iaid: ArithContexts;
+  readonly generic: ArithContexts;
+  readonly refinement: ArithContexts;
+}
+declare function createTextArithContexts(genericTemplate: number, refinementTemplate: number, symbolIdBits: number): TextArithContexts;
+interface TextRegionParams {
+  readonly width: number;
+  readonly height: number;
+  readonly instanceCount: number;
+  readonly stripSize: number;
+  readonly symbols: readonly Jbig2Bitmap[];
+  readonly defaultPixel: number;
+  readonly combinationOperator: Jbig2CombinationOperator;
+  readonly transposed: boolean;
+  readonly referenceCorner: Jbig2ReferenceCorner;
+  readonly dsOffset: number;
+  readonly refine: boolean;
+  readonly refinementTemplate: number;
+  readonly refinementAt: readonly Jbig2AtPixel[];
+}
+declare function decodeTextRegion(params: TextRegionParams, mq: MqDecoder, contexts: TextArithContexts, symbolIdBits: number): Jbig2Bitmap;
+interface SymbolDictionaryParams {
+  readonly template: number;
+  readonly at: readonly Jbig2AtPixel[];
+  readonly refinementAggregate: boolean;
+  readonly refinementTemplate: number;
+  readonly refinementAt: readonly Jbig2AtPixel[];
+  readonly newSymbolCount: number;
+  readonly exportedSymbolCount: number;
+  readonly inputSymbols: readonly Jbig2Bitmap[];
+}
+declare function decodeSymbolDictionary(params: SymbolDictionaryParams, mq: MqDecoder, contexts: TextArithContexts, symbolIdBits: number): readonly Jbig2Bitmap[];
+//#endregion
+export { Jbig2ReferenceCorner, SymbolDictionaryParams, TextArithContexts, TextRegionParams, createTextArithContexts, decodeSymbolDictionary, decodeTextRegion, referenceCornerFromCode, symbolCodeLength };

package/dist/image/jbig2-text.js

@@ -0,0 +1,170 @@
+import { createArithContexts, createIntegerContexts, createSymbolIdContexts, decodeInteger, decodeSymbolId } from "./jbig2-arith.js";
+import { Jbig2ParseError, Jbig2UnsupportedError } from "./jbig2-errors.js";
+import { combineBitmap, createBitmap } from "./jbig2-bitmap.js";
+import { GENERIC_CONTEXT_BITS, REFINEMENT_CONTEXT_BITS, decodeGenericRegion, decodeRefinementRegion } from "./jbig2-generic.js";
+//#region src/image/jbig2-text.ts
+const REFERENCE_CORNERS = [
+	{
+		right: false,
+		bottom: true
+	},
+	{
+		right: false,
+		bottom: false
+	},
+	{
+		right: true,
+		bottom: true
+	},
+	{
+		right: true,
+		bottom: false
+	}
+];
+function referenceCornerFromCode(code) {
+	return REFERENCE_CORNERS[code];
+}
+function symbolCodeLength(symbolCount) {
+	let bits = 1;
+	while (1 << bits < symbolCount) bits++;
+	return bits;
+}
+function createTextArithContexts(genericTemplate, refinementTemplate, symbolIdBits) {
+	return {
+		iadh: createIntegerContexts(),
+		iadw: createIntegerContexts(),
+		iaex: createIntegerContexts(),
+		iaai: createIntegerContexts(),
+		iadt: createIntegerContexts(),
+		iafs: createIntegerContexts(),
+		iads: createIntegerContexts(),
+		iait: createIntegerContexts(),
+		iari: createIntegerContexts(),
+		iardw: createIntegerContexts(),
+		iardh: createIntegerContexts(),
+		iardx: createIntegerContexts(),
+		iardy: createIntegerContexts(),
+		iaid: createSymbolIdContexts(symbolIdBits),
+		generic: createArithContexts(GENERIC_CONTEXT_BITS[genericTemplate] ?? 16),
+		refinement: createArithContexts(REFINEMENT_CONTEXT_BITS[refinementTemplate] ?? 13)
+	};
+}
+function instanceTopLeft(s, t, width, height, corner, transposed) {
+	const across = transposed ? t : s;
+	const down = transposed ? s : t;
+	return {
+		x: corner.right ? across - width + 1 : across,
+		y: corner.bottom ? down - height + 1 : down
+	};
+}
+function requireInteger(value, field) {
+	if (value === void 0) throw new Jbig2ParseError(`JBIG2 ${field} decoded as out-of-band, which is not a value this field can take`);
+	return value;
+}
+function decodeTextRegion(params, mq, contexts, symbolIdBits) {
+	const region = createBitmap(params.width, params.height, params.defaultPixel);
+	let stripT = -requireInteger(decodeInteger(mq, contexts.iadt), "IADT") * params.stripSize;
+	let firstS = 0;
+	let instances = 0;
+	while (instances < params.instanceCount) {
+		stripT += requireInteger(decodeInteger(mq, contexts.iadt), "IADT") * params.stripSize;
+		firstS += requireInteger(decodeInteger(mq, contexts.iafs), "IAFS");
+		let currentS = firstS;
+		for (;;) {
+			const currentT = params.stripSize === 1 ? 0 : requireInteger(decodeInteger(mq, contexts.iait), "IAIT");
+			const t = stripT + currentT;
+			const id = decodeSymbolId(mq, contexts.iaid, symbolIdBits);
+			let symbol = params.symbols[id];
+			if (symbol === void 0) throw new Jbig2ParseError(`text region referenced symbol ${String(id)}, outside the ${String(params.symbols.length)}-symbol set its segment declares`);
+			if (params.refine && requireInteger(decodeInteger(mq, contexts.iari), "IARI") !== 0) symbol = refineInstance(symbol, params, mq, contexts);
+			const advance = (params.transposed ? symbol.height : symbol.width) - 1;
+			const advanceBefore = params.transposed ? params.referenceCorner.bottom : params.referenceCorner.right;
+			if (advanceBefore) currentS += advance;
+			const position = instanceTopLeft(currentS, t, symbol.width, symbol.height, params.referenceCorner, params.transposed);
+			combineBitmap(region, symbol, position.x, position.y, params.combinationOperator);
+			if (!advanceBefore) currentS += advance;
+			instances++;
+			if (instances > params.instanceCount) throw new Jbig2ParseError(`text region coded more symbol instances than the ${String(params.instanceCount)} its own SBNUMINSTANCES declares`);
+			const nextDelta = decodeInteger(mq, contexts.iads);
+			if (nextDelta === void 0) break;
+			currentS += nextDelta + params.dsOffset;
+		}
+	}
+	return region;
+}
+function refineInstance(symbol, params, mq, contexts) {
+	const deltaWidth = decodeInteger(mq, contexts.iardw) ?? 0;
+	const deltaHeight = decodeInteger(mq, contexts.iardh) ?? 0;
+	const deltaX = decodeInteger(mq, contexts.iardx) ?? 0;
+	const deltaY = decodeInteger(mq, contexts.iardy) ?? 0;
+	return decodeRefinementRegion(symbol.width + deltaWidth, symbol.height + deltaHeight, {
+		template: params.refinementTemplate,
+		tpgron: false,
+		at: params.refinementAt,
+		reference: symbol,
+		dx: Math.floor(deltaWidth / 2) + deltaX,
+		dy: Math.floor(deltaHeight / 2) + deltaY
+	}, mq, contexts.refinement);
+}
+function decodeSymbolDictionary(params, mq, contexts, symbolIdBits) {
+	const newSymbols = [];
+	let heightClassHeight = 0;
+	while (newSymbols.length < params.newSymbolCount) {
+		const heightDelta = decodeInteger(mq, contexts.iadh);
+		if (heightDelta === void 0) throw new Jbig2ParseError("symbol dictionary ended before all of its declared new symbols were decoded");
+		heightClassHeight += heightDelta;
+		let symbolWidth = 0;
+		for (;;) {
+			const widthDelta = decodeInteger(mq, contexts.iadw);
+			if (widthDelta === void 0) break;
+			symbolWidth += widthDelta;
+			if (newSymbols.length >= params.newSymbolCount) throw new Jbig2ParseError("symbol dictionary coded more symbols than its own SDNUMNEWSYMS declares");
+			newSymbols.push(decodeDictionarySymbol(symbolWidth, heightClassHeight, params, newSymbols, mq, contexts, symbolIdBits));
+		}
+	}
+	return exportSymbols([...params.inputSymbols, ...newSymbols], params.exportedSymbolCount, mq, contexts);
+}
+function decodeDictionarySymbol(width, height, params, newSymbols, mq, contexts, symbolIdBits) {
+	if (!params.refinementAggregate) return decodeGenericRegion(width, height, {
+		template: params.template,
+		tpgdon: false,
+		at: params.at
+	}, mq, contexts.generic);
+	const aggregateInstances = decodeInteger(mq, contexts.iaai) ?? 0;
+	if (aggregateInstances !== 1) throw new Jbig2UnsupportedError(`symbol dictionary uses aggregate coding with ${String(aggregateInstances)} instances per symbol; only the single-refinement form of T.88 6.5.8.2.2 is implemented`);
+	const available = [...params.inputSymbols, ...newSymbols];
+	const id = decodeSymbolId(mq, contexts.iaid, symbolIdBits);
+	const deltaX = decodeInteger(mq, contexts.iardx) ?? 0;
+	const deltaY = decodeInteger(mq, contexts.iardy) ?? 0;
+	const reference = available[id];
+	if (reference === void 0) throw new Jbig2ParseError(`symbol dictionary refined against symbol ${String(id)}, which it has not decoded yet`);
+	return decodeRefinementRegion(width, height, {
+		template: params.refinementTemplate,
+		tpgron: false,
+		at: params.refinementAt,
+		reference,
+		dx: deltaX,
+		dy: deltaY
+	}, mq, contexts.refinement);
+}
+function exportSymbols(allSymbols, exportedCount, mq, contexts) {
+	const exported = [];
+	const maxRuns = allSymbols.length * 2 + 1;
+	let index = 0;
+	let currentFlag = false;
+	for (let run = 0; index < allSymbols.length; run++) {
+		if (run >= maxRuns) throw new Jbig2ParseError("symbol dictionary export flags never accounted for every symbol");
+		const runLength = requireInteger(decodeInteger(mq, contexts.iaex), "IAEX");
+		if (runLength < 0 || index + runLength > allSymbols.length) throw new Jbig2ParseError(`symbol dictionary export run of ${String(runLength)} overruns its own ${String(allSymbols.length)}-symbol set`);
+		if (currentFlag) for (let i = 0; i < runLength; i++) {
+			const symbol = allSymbols[index + i];
+			if (symbol !== void 0) exported.push(symbol);
+		}
+		index += runLength;
+		currentFlag = !currentFlag;
+	}
+	if (exported.length !== exportedCount) throw new Jbig2ParseError(`symbol dictionary exported ${String(exported.length)} symbols but its own SDNUMEXSYMS declares ${String(exportedCount)}`);
+	return exported;
+}
+//#endregion
+export { createTextArithContexts, decodeSymbolDictionary, decodeTextRegion, referenceCornerFromCode, symbolCodeLength };

package/dist/image/jbig2.cjs

@@ -0,0 +1,333 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_image_ccitt = require("./ccitt.cjs");
+const require_image_jbig2_arith = require("./jbig2-arith.cjs");
+const require_image_jbig2_errors = require("./jbig2-errors.cjs");
+const require_image_jbig2_bitmap = require("./jbig2-bitmap.cjs");
+const require_image_jbig2_generic = require("./jbig2-generic.cjs");
+const require_image_jbig2_text = require("./jbig2-text.cjs");
+//#region src/image/jbig2.ts
+const SEGMENT_SYMBOL_DICTIONARY = 0;
+const SEGMENT_INTERMEDIATE_TEXT_REGION = 4;
+const SEGMENT_IMMEDIATE_TEXT_REGION = 6;
+const SEGMENT_IMMEDIATE_LOSSLESS_TEXT_REGION = 7;
+const SEGMENT_PATTERN_DICTIONARY = 16;
+const SEGMENT_INTERMEDIATE_HALFTONE_REGION = 20;
+const SEGMENT_IMMEDIATE_HALFTONE_REGION = 22;
+const SEGMENT_IMMEDIATE_LOSSLESS_HALFTONE_REGION = 23;
+const SEGMENT_INTERMEDIATE_GENERIC_REGION = 36;
+const SEGMENT_IMMEDIATE_GENERIC_REGION = 38;
+const SEGMENT_IMMEDIATE_LOSSLESS_GENERIC_REGION = 39;
+const SEGMENT_INTERMEDIATE_REFINEMENT_REGION = 40;
+const SEGMENT_IMMEDIATE_REFINEMENT_REGION = 42;
+const SEGMENT_IMMEDIATE_LOSSLESS_REFINEMENT_REGION = 43;
+const SEGMENT_PAGE_INFORMATION = 48;
+const SEGMENT_END_OF_PAGE = 49;
+const SEGMENT_END_OF_STRIPE = 50;
+const SEGMENT_END_OF_FILE = 51;
+const SEGMENT_PROFILES = 52;
+const SEGMENT_TABLES = 53;
+const SEGMENT_EXTENSION = 62;
+const UNKNOWN_DATA_LENGTH = 4294967295;
+const UNKNOWN_PAGE_HEIGHT = 4294967295;
+var ByteCursor = class {
+	data;
+	position;
+	constructor(data, start = 0) {
+		this.data = data;
+		this.position = start;
+	}
+	get remaining() {
+		return this.data.length - this.position;
+	}
+	uint8() {
+		const value = this.data[this.position];
+		if (value === void 0) throw new require_image_jbig2_errors.Jbig2ParseError("JBIG2 stream ended in the middle of a segment header");
+		this.position++;
+		return value;
+	}
+	uint16() {
+		return this.uint8() << 8 | this.uint8();
+	}
+	uint32() {
+		return (this.uint8() << 24 | this.uint8() << 16 | this.uint8() << 8 | this.uint8()) >>> 0;
+	}
+	int8() {
+		const value = this.uint8();
+		return value > 127 ? value - 256 : value;
+	}
+};
+function readSegmentHeader(cursor, dataLength) {
+	const number = cursor.uint32();
+	const flags = cursor.uint8();
+	const type = flags & 63;
+	const pageAssociationIsLong = (flags & 64) !== 0;
+	let referredCount = cursor.uint8() >> 5;
+	if (referredCount === 7) {
+		cursor.position -= 1;
+		referredCount = cursor.uint32() & 536870911;
+		cursor.position += Math.ceil((referredCount + 1) / 8);
+	}
+	const referredSize = number <= 256 ? 1 : number <= 65536 ? 2 : 4;
+	const referredTo = [];
+	for (let i = 0; i < referredCount; i++) referredTo.push(referredSize === 1 ? cursor.uint8() : referredSize === 2 ? cursor.uint16() : cursor.uint32());
+	const pageAssociation = pageAssociationIsLong ? cursor.uint32() : cursor.uint8();
+	const declaredLength = cursor.uint32();
+	if (declaredLength === UNKNOWN_DATA_LENGTH) throw new require_image_jbig2_errors.Jbig2UnsupportedError("JBIG2 segment declares an unknown data length (T.88 7.2.7), which this decoder does not scan for a terminator");
+	const dataStart = cursor.position;
+	const dataEnd = dataStart + declaredLength;
+	if (dataEnd > dataLength) throw new require_image_jbig2_errors.Jbig2ParseError(`JBIG2 segment ${String(number)} declares ${String(declaredLength)} bytes of data but only ${String(dataLength - dataStart)} remain`);
+	return {
+		number,
+		type,
+		referredTo,
+		pageAssociation,
+		dataStart,
+		dataEnd
+	};
+}
+function readRegionInfo(cursor) {
+	const width = cursor.uint32();
+	const height = cursor.uint32();
+	const x = cursor.uint32();
+	const y = cursor.uint32();
+	const flags = cursor.uint8();
+	const combinationOperator = require_image_jbig2_bitmap.combinationOperatorFromCode(flags & 7);
+	if (combinationOperator === void 0) throw new require_image_jbig2_errors.Jbig2ParseError(`JBIG2 region declares external combination operator ${String(flags & 7)}, outside the 0-4 range T.88 Table 12 defines`);
+	return {
+		width,
+		height,
+		x,
+		y,
+		combinationOperator
+	};
+}
+function readAtPixels(cursor, count) {
+	const at = [];
+	for (let i = 0; i < count; i++) at.push({
+		x: cursor.int8(),
+		y: cursor.int8()
+	});
+	return at;
+}
+var Jbig2Decoder = class {
+	options;
+	page;
+	exportedSymbols = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	warn(message) {
+		this.options.onWarning?.(message);
+	}
+	run(data) {
+		const cursor = new ByteCursor(data);
+		while (cursor.remaining > 0) {
+			const header = readSegmentHeader(cursor, data.length);
+			this.handleSegment(header, data);
+			cursor.position = header.dataEnd;
+		}
+	}
+	handleSegment(header, data) {
+		const cursor = new ByteCursor(data, header.dataStart);
+		switch (header.type) {
+			case SEGMENT_PAGE_INFORMATION:
+				this.readPageInformation(cursor);
+				return;
+			case SEGMENT_SYMBOL_DICTIONARY:
+				this.exportedSymbols.set(header.number, this.readSymbolDictionary(header, cursor));
+				return;
+			case SEGMENT_IMMEDIATE_GENERIC_REGION:
+			case SEGMENT_IMMEDIATE_LOSSLESS_GENERIC_REGION:
+				this.readGenericRegion(cursor, header.dataEnd);
+				return;
+			case SEGMENT_IMMEDIATE_TEXT_REGION:
+			case SEGMENT_IMMEDIATE_LOSSLESS_TEXT_REGION:
+				this.readTextRegion(header, cursor);
+				return;
+			case SEGMENT_IMMEDIATE_REFINEMENT_REGION:
+			case SEGMENT_IMMEDIATE_LOSSLESS_REFINEMENT_REGION:
+				this.readRefinementRegion(cursor, header.dataEnd);
+				return;
+			case SEGMENT_END_OF_PAGE:
+			case SEGMENT_END_OF_STRIPE:
+			case SEGMENT_END_OF_FILE:
+			case SEGMENT_PROFILES:
+			case SEGMENT_EXTENSION: return;
+			case SEGMENT_INTERMEDIATE_GENERIC_REGION:
+			case SEGMENT_INTERMEDIATE_TEXT_REGION:
+			case SEGMENT_INTERMEDIATE_REFINEMENT_REGION:
+			case SEGMENT_INTERMEDIATE_HALFTONE_REGION: throw new require_image_jbig2_errors.Jbig2UnsupportedError(`JBIG2 segment ${String(header.number)} is an intermediate region (type ${String(header.type)}), which is retained in an auxiliary buffer rather than composed onto the page; auxiliary buffers are not implemented`);
+			case SEGMENT_PATTERN_DICTIONARY:
+			case SEGMENT_IMMEDIATE_HALFTONE_REGION:
+			case SEGMENT_IMMEDIATE_LOSSLESS_HALFTONE_REGION: throw new require_image_jbig2_errors.Jbig2UnsupportedError(`JBIG2 segment ${String(header.number)} is a halftone region or pattern dictionary (type ${String(header.type)}), which is not implemented`);
+			case SEGMENT_TABLES: throw new require_image_jbig2_errors.Jbig2UnsupportedError(`JBIG2 segment ${String(header.number)} is a custom Huffman table, which only the Huffman-coded region forms use; those are not implemented`);
+			default: throw new require_image_jbig2_errors.Jbig2UnsupportedError(`JBIG2 segment ${String(header.number)} has unrecognised type ${String(header.type)}`);
+		}
+	}
+	readPageInformation(cursor) {
+		const declaredWidth = cursor.uint32();
+		const declaredHeight = cursor.uint32();
+		cursor.uint32();
+		cursor.uint32();
+		const flags = cursor.uint8();
+		cursor.uint16();
+		const width = this.options.width ?? declaredWidth;
+		const declaredOrHintedHeight = declaredHeight === UNKNOWN_PAGE_HEIGHT ? this.options.height : this.options.height ?? declaredHeight;
+		if (declaredOrHintedHeight === void 0) throw new require_image_jbig2_errors.Jbig2UnsupportedError("JBIG2 page information declares an unknown height and the caller supplied none; a striped page with no known height is not resolvable from the page segments alone");
+		const defaultPixel = flags >> 2 & 1;
+		const defaultCombinationOperator = require_image_jbig2_bitmap.combinationOperatorFromCode(flags >> 3 & 3);
+		if (defaultCombinationOperator === void 0) throw new require_image_jbig2_errors.Jbig2ParseError("JBIG2 page information declares an unrecognised default combination operator");
+		this.page = {
+			bitmap: require_image_jbig2_bitmap.createBitmap(width, declaredOrHintedHeight, defaultPixel),
+			defaultCombinationOperator,
+			combinationOperatorOverridden: (flags & 64) !== 0
+		};
+	}
+	requirePage() {
+		if (this.page === void 0) throw new require_image_jbig2_errors.Jbig2ParseError("JBIG2 stream composed a region before any page information segment declared the page");
+		return this.page;
+	}
+	compose(region, bitmap) {
+		const page = this.requirePage();
+		require_image_jbig2_bitmap.combineBitmap(page.bitmap, bitmap, region.x, region.y, page.combinationOperatorOverridden ? region.combinationOperator : page.defaultCombinationOperator);
+	}
+	readGenericRegion(cursor, dataEnd) {
+		const region = readRegionInfo(cursor);
+		const flags = cursor.uint8();
+		const mmr = (flags & 1) !== 0;
+		const template = flags >> 1 & 3;
+		const tpgdon = (flags & 8) !== 0;
+		if ((flags & 16) !== 0) throw new require_image_jbig2_errors.Jbig2UnsupportedError("JBIG2 generic region sets EXTTEMPLATE, the twelve-adaptive-pixel template of T.88 Amendment 2, which is not implemented");
+		const at = mmr ? [] : readAtPixels(cursor, template === 0 ? 4 : 1);
+		const payload = cursor.position;
+		if (mmr) {
+			const fax = require_image_ccitt.decodeCcittFax(cursor.data.subarray(payload, dataEnd), {
+				k: -1,
+				columns: region.width,
+				rows: region.height,
+				blackIs1: true,
+				onWarning: (message) => this.warn(message)
+			});
+			this.compose(region, require_image_jbig2_bitmap.unpackBitmapRows(fax.bytes, region.width, region.height));
+			return;
+		}
+		const mq = new require_image_jbig2_arith.MqDecoder(cursor.data, payload, dataEnd);
+		const contexts = require_image_jbig2_arith.createArithContexts(require_image_jbig2_generic.GENERIC_CONTEXT_BITS[template] ?? 16);
+		this.compose(region, require_image_jbig2_generic.decodeGenericRegion(region.width, region.height, {
+			template,
+			tpgdon,
+			at
+		}, mq, contexts));
+	}
+	readRefinementRegion(cursor, dataEnd) {
+		const region = readRegionInfo(cursor);
+		const flags = cursor.uint8();
+		const template = flags & 1;
+		const tpgron = (flags & 2) !== 0;
+		const at = template === 0 ? readAtPixels(cursor, 2) : [...require_image_jbig2_generic.NOMINAL_REFINEMENT_AT];
+		const page = this.requirePage();
+		const reference = require_image_jbig2_bitmap.createBitmap(region.width, region.height);
+		for (let y = 0; y < region.height; y++) for (let x = 0; x < region.width; x++) reference.data[y * region.width + x] = require_image_jbig2_bitmap.getPixel(page.bitmap, region.x + x, region.y + y);
+		const mq = new require_image_jbig2_arith.MqDecoder(cursor.data, cursor.position, dataEnd);
+		const contexts = require_image_jbig2_arith.createArithContexts(require_image_jbig2_generic.REFINEMENT_CONTEXT_BITS[template] ?? 13);
+		const refined = require_image_jbig2_generic.decodeRefinementRegion(region.width, region.height, {
+			template,
+			tpgron,
+			at,
+			reference,
+			dx: 0,
+			dy: 0
+		}, mq, contexts);
+		require_image_jbig2_bitmap.combineBitmap(page.bitmap, refined, region.x, region.y, region.combinationOperator);
+	}
+	readSymbolDictionary(header, cursor) {
+		const flags = cursor.uint16();
+		if ((flags & 1) !== 0) throw new require_image_jbig2_errors.Jbig2UnsupportedError("JBIG2 symbol dictionary is Huffman-coded (SDHUFF = 1); only the arithmetic form is implemented");
+		if ((flags & 256) !== 0 || (flags & 512) !== 0) throw new require_image_jbig2_errors.Jbig2UnsupportedError("JBIG2 symbol dictionary uses or retains a shared bitmap coding context (T.88 7.4.3.1.1 bits 8-9), which is not implemented");
+		const refinementAggregate = (flags & 2) !== 0;
+		const template = flags >> 10 & 3;
+		const refinementTemplate = flags >> 12 & 1;
+		const at = readAtPixels(cursor, template === 0 ? 4 : 1);
+		const refinementAt = refinementAggregate && refinementTemplate === 0 ? readAtPixels(cursor, 2) : [...require_image_jbig2_generic.NOMINAL_REFINEMENT_AT];
+		const exportedSymbolCount = cursor.uint32();
+		const newSymbolCount = cursor.uint32();
+		const inputSymbols = this.gatherSymbols(header.referredTo);
+		const symbolIdBits = require_image_jbig2_text.symbolCodeLength(inputSymbols.length + newSymbolCount);
+		const mq = new require_image_jbig2_arith.MqDecoder(cursor.data, cursor.position, header.dataEnd);
+		const contexts = require_image_jbig2_text.createTextArithContexts(template, refinementTemplate, symbolIdBits);
+		return require_image_jbig2_text.decodeSymbolDictionary({
+			template,
+			at,
+			refinementAggregate,
+			refinementTemplate,
+			refinementAt,
+			newSymbolCount,
+			exportedSymbolCount,
+			inputSymbols
+		}, mq, contexts, symbolIdBits);
+	}
+	readTextRegion(header, cursor) {
+		const region = readRegionInfo(cursor);
+		const flags = cursor.uint16();
+		if ((flags & 1) !== 0) throw new require_image_jbig2_errors.Jbig2UnsupportedError("JBIG2 text region is Huffman-coded (SBHUFF = 1); only the arithmetic form is implemented");
+		const refine = (flags & 2) !== 0;
+		const stripSize = 1 << (flags >> 2 & 3);
+		const referenceCorner = require_image_jbig2_text.referenceCornerFromCode(flags >> 4 & 3);
+		if (referenceCorner === void 0) throw new require_image_jbig2_errors.Jbig2ParseError("JBIG2 text region declares an unrecognised REFCORNER");
+		const transposed = (flags & 64) !== 0;
+		const combinationOperator = require_image_jbig2_bitmap.combinationOperatorFromCode(flags >> 7 & 3);
+		if (combinationOperator === void 0) throw new require_image_jbig2_errors.Jbig2ParseError("JBIG2 text region declares an unrecognised SBCOMBOP");
+		const defaultPixel = flags >> 9 & 1;
+		const dsOffset = flags << 17 >> 27 | 0;
+		const refinementTemplate = flags >> 15 & 1;
+		const refinementAt = refine && refinementTemplate === 0 ? readAtPixels(cursor, 2) : [...require_image_jbig2_generic.NOMINAL_REFINEMENT_AT];
+		const instanceCount = cursor.uint32();
+		const symbols = this.gatherSymbols(header.referredTo);
+		if (symbols.length === 0) throw new require_image_jbig2_errors.Jbig2ParseError("JBIG2 text region refers to no symbol dictionary, so it has no symbols to place");
+		const symbolIdBits = require_image_jbig2_text.symbolCodeLength(symbols.length);
+		const mq = new require_image_jbig2_arith.MqDecoder(cursor.data, cursor.position, header.dataEnd);
+		const contexts = require_image_jbig2_text.createTextArithContexts(0, refinementTemplate, symbolIdBits);
+		const params = {
+			width: region.width,
+			height: region.height,
+			instanceCount,
+			stripSize,
+			symbols,
+			defaultPixel,
+			combinationOperator,
+			transposed,
+			referenceCorner,
+			dsOffset,
+			refine,
+			refinementTemplate,
+			refinementAt
+		};
+		this.compose(region, require_image_jbig2_text.decodeTextRegion(params, mq, contexts, symbolIdBits));
+	}
+	gatherSymbols(referredTo) {
+		const symbols = [];
+		for (const segmentNumber of referredTo) {
+			const exported = this.exportedSymbols.get(segmentNumber);
+			if (exported !== void 0) symbols.push(...exported);
+		}
+		return symbols;
+	}
+	finish() {
+		const page = this.requirePage();
+		const width = this.options.width ?? page.bitmap.width;
+		const height = this.options.height ?? page.bitmap.height;
+		return {
+			bytes: require_image_jbig2_bitmap.packBitmapRows(page.bitmap, width, height),
+			width,
+			height
+		};
+	}
+};
+function decodeJbig2Embedded(data, options = {}) {
+	const decoder = new Jbig2Decoder(options);
+	if (options.globals !== void 0) decoder.run(options.globals);
+	decoder.run(data);
+	return decoder.finish();
+}
+//#endregion
+exports.decodeJbig2Embedded = decodeJbig2Embedded;

package/dist/image/jbig2.d.cts

@@ -0,0 +1,15 @@
+//#region src/image/jbig2.d.ts
+interface Jbig2DecodeOptions {
+  readonly globals?: Uint8Array<ArrayBuffer>;
+  readonly width?: number;
+  readonly height?: number;
+  readonly onWarning?: (message: string) => void;
+}
+interface Jbig2Image {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly width: number;
+  readonly height: number;
+}
+declare function decodeJbig2Embedded(data: Uint8Array<ArrayBuffer>, options?: Jbig2DecodeOptions): Jbig2Image;
+//#endregion
+export { Jbig2DecodeOptions, Jbig2Image, decodeJbig2Embedded };

package/dist/image/jbig2.d.ts

@@ -0,0 +1,15 @@
+//#region src/image/jbig2.d.ts
+interface Jbig2DecodeOptions {
+  readonly globals?: Uint8Array<ArrayBuffer>;
+  readonly width?: number;
+  readonly height?: number;
+  readonly onWarning?: (message: string) => void;
+}
+interface Jbig2Image {
+  readonly bytes: Uint8Array<ArrayBuffer>;
+  readonly width: number;
+  readonly height: number;
+}
+declare function decodeJbig2Embedded(data: Uint8Array<ArrayBuffer>, options?: Jbig2DecodeOptions): Jbig2Image;
+//#endregion
+export { Jbig2DecodeOptions, Jbig2Image, decodeJbig2Embedded };