reamkit 1.25.1 → 1.26.0

package/dist/esm/pdf-reader/jbig2.js

@@ -0,0 +1,2597 @@
+import { decodeCcitt } from "./ccitt.js";
+//#region src/pdf-reader/jbig2.ts
+function makeBitmap(width, height, fill = 0) {
+	const data = new Uint8Array(width * height);
+	if (fill) data.fill(1);
+	return {
+		width,
+		height,
+		data
+	};
+}
+/**
+* §E.1 Table E.1 — the MQ-coder's probability estimation state machine, as
+* `[Qe, NMPS, NLPS, SWITCH]` per state. The same table drives JPEG 2000.
+*/
+var QE = [
+	[
+		22017,
+		1,
+		1,
+		1
+	],
+	[
+		13313,
+		2,
+		6,
+		0
+	],
+	[
+		6145,
+		3,
+		9,
+		0
+	],
+	[
+		2753,
+		4,
+		12,
+		0
+	],
+	[
+		1313,
+		5,
+		29,
+		0
+	],
+	[
+		545,
+		38,
+		33,
+		0
+	],
+	[
+		22017,
+		7,
+		6,
+		1
+	],
+	[
+		21505,
+		8,
+		14,
+		0
+	],
+	[
+		18433,
+		9,
+		14,
+		0
+	],
+	[
+		14337,
+		10,
+		14,
+		0
+	],
+	[
+		12289,
+		11,
+		17,
+		0
+	],
+	[
+		9217,
+		12,
+		18,
+		0
+	],
+	[
+		7169,
+		13,
+		20,
+		0
+	],
+	[
+		5633,
+		29,
+		21,
+		0
+	],
+	[
+		22017,
+		15,
+		14,
+		1
+	],
+	[
+		21505,
+		16,
+		14,
+		0
+	],
+	[
+		20737,
+		17,
+		15,
+		0
+	],
+	[
+		18433,
+		18,
+		16,
+		0
+	],
+	[
+		14337,
+		19,
+		17,
+		0
+	],
+	[
+		13313,
+		20,
+		18,
+		0
+	],
+	[
+		12289,
+		21,
+		19,
+		0
+	],
+	[
+		10241,
+		22,
+		19,
+		0
+	],
+	[
+		9217,
+		23,
+		20,
+		0
+	],
+	[
+		8705,
+		24,
+		21,
+		0
+	],
+	[
+		7169,
+		25,
+		22,
+		0
+	],
+	[
+		6145,
+		26,
+		23,
+		0
+	],
+	[
+		5633,
+		27,
+		24,
+		0
+	],
+	[
+		5121,
+		28,
+		25,
+		0
+	],
+	[
+		4609,
+		29,
+		26,
+		0
+	],
+	[
+		4353,
+		30,
+		27,
+		0
+	],
+	[
+		2753,
+		31,
+		28,
+		0
+	],
+	[
+		2497,
+		32,
+		29,
+		0
+	],
+	[
+		2209,
+		33,
+		30,
+		0
+	],
+	[
+		1313,
+		34,
+		31,
+		0
+	],
+	[
+		1089,
+		35,
+		32,
+		0
+	],
+	[
+		673,
+		36,
+		33,
+		0
+	],
+	[
+		545,
+		37,
+		34,
+		0
+	],
+	[
+		321,
+		38,
+		35,
+		0
+	],
+	[
+		273,
+		39,
+		36,
+		0
+	],
+	[
+		133,
+		40,
+		37,
+		0
+	],
+	[
+		73,
+		41,
+		38,
+		0
+	],
+	[
+		37,
+		42,
+		39,
+		0
+	],
+	[
+		21,
+		43,
+		40,
+		0
+	],
+	[
+		9,
+		44,
+		41,
+		0
+	],
+	[
+		5,
+		45,
+		42,
+		0
+	],
+	[
+		1,
+		45,
+		43,
+		0
+	],
+	[
+		22017,
+		46,
+		46,
+		0
+	]
+];
+/** §E.3.5 — a fresh set of `size` contexts, all at state 0 with MPS 0. */
+function newContexts(size) {
+	return {
+		i: new Uint8Array(size),
+		mps: new Uint8Array(size)
+	};
+}
+/**
+* §E.3 — the MQ arithmetic decoder.
+*
+* Written as a class with the spec's own register names (`c`, `a`, `ct`)
+* because the procedures below are transcribed from its flow charts, and a
+* renaming makes them impossible to check against it.
+*/
+var MQDecoder = class {
+	data;
+	bp;
+	end;
+	c = 0;
+	a = 0;
+	ct = 0;
+	constructor(data, start = 0, end = data.length) {
+		this.data = data;
+		this.bp = start;
+		this.end = end;
+		this.c = this.byteAt(this.bp) << 16 >>> 0;
+		this.byteIn();
+		this.c = this.c << 7 >>> 0;
+		this.ct -= 7;
+		this.a = 32768;
+	}
+	byteAt(i) {
+		return i < this.end ? this.data[i] ?? 255 : 255;
+	}
+	/** BYTEIN (§E.3.4) — 0xFF is the marker escape, so it feeds a shorter byte. */
+	byteIn() {
+		if (this.byteAt(this.bp) === 255) if (this.byteAt(this.bp + 1) > 143) {
+			this.c = this.c + 65280 >>> 0;
+			this.ct = 8;
+		} else {
+			this.bp++;
+			this.c = this.c + (this.byteAt(this.bp) << 9) >>> 0;
+			this.ct = 7;
+		}
+		else {
+			this.bp++;
+			this.c = this.c + (this.byteAt(this.bp) << 8) >>> 0;
+			this.ct = 8;
+		}
+	}
+	/**
+	* DECODE (§E.3.2) — one bit in context `k`.
+	*
+	* @param cx The context set the caller keeps for this decoding procedure.
+	* @param k  Which context within it.
+	*/
+	decode(cx, k) {
+		let i = cx.i[k] ?? 0;
+		let mps = cx.mps[k] ?? 0;
+		const [qe, nmps, nlps, sw] = QE[i] ?? QE[0];
+		let d;
+		this.a = this.a - qe & 65535;
+		if ((this.c >>> 16 & 65535) < qe) if (this.a < qe) {
+			this.a = qe;
+			d = mps;
+			i = nmps;
+		} else {
+			this.a = qe;
+			d = 1 - mps;
+			if (sw === 1) mps = 1 - mps;
+			i = nlps;
+		}
+		else {
+			this.c = this.c - (qe << 16) >>> 0;
+			if ((this.a & 32768) !== 0) return mps;
+			if (this.a < qe) {
+				d = 1 - mps;
+				if (sw === 1) mps = 1 - mps;
+				i = nlps;
+			} else {
+				d = mps;
+				i = nmps;
+			}
+		}
+		do {
+			if (this.ct === 0) this.byteIn();
+			this.a = this.a << 1 & 65535;
+			this.c = this.c << 1 >>> 0;
+			this.ct--;
+		} while ((this.a & 32768) === 0);
+		cx.i[k] = i;
+		cx.mps[k] = mps;
+		return d;
+	}
+};
+/** The nominal AT positions per template (§6.2.5.3 figures 8-11). */
+var NOMINAL_AT = [
+	[
+		{
+			x: 3,
+			y: -1
+		},
+		{
+			x: -3,
+			y: -1
+		},
+		{
+			x: 2,
+			y: -2
+		},
+		{
+			x: -2,
+			y: -2
+		}
+	],
+	[{
+		x: 3,
+		y: -1
+	}],
+	[{
+		x: 2,
+		y: -1
+	}],
+	[{
+		x: 2,
+		y: -1
+	}]
+];
+/**
+* §6.2.5.7 — decode a generic region with the arithmetic coder.
+*
+* The context for a pixel is the pattern of already-decoded neighbours the
+* template names, read MSB first in the order the figures give. `TPGDON` adds a
+* per-row bit that says "this row is the same as the one above", which is what
+* makes a page of white space nearly free.
+*
+* @param mq       The decoder, positioned at the region's data.
+* @param cx       The 2^16 generic contexts (shared across a segment's regions).
+* @param width    Region width in pixels.
+* @param height   Region height in pixels.
+* @param template Which of the four templates (0-3).
+* @param at       The adaptive pixels, one for templates 1-3 and four for 0.
+* @param tpgdon   Whether typical prediction is on.
+* @param skip     A bitmap of pixels to leave white without decoding (halftone).
+*/
+function decodeGenericRegion(mq, cx, width, height, template, at, tpgdon, skip) {
+	const bmp = makeBitmap(width, height);
+	const px = (x, y) => x < 0 || x >= width || y < 0 ? 0 : bmp.data[y * width + x] ?? 0;
+	const TPGD_CX = [
+		39717,
+		1941,
+		229,
+		405
+	];
+	let ltp = 0;
+	for (let y = 0; y < height; y++) {
+		if (tpgdon) {
+			ltp ^= mq.decode(cx, TPGD_CX[template] ?? 0);
+			if (ltp === 1) {
+				if (y > 0) bmp.data.copyWithin(y * width, (y - 1) * width, y * width);
+				continue;
+			}
+		}
+		for (let x = 0; x < width; x++) {
+			if (skip && skip.data[y * width + x] === 1) continue;
+			let ctx;
+			const a = at;
+			switch (template) {
+				case 0:
+					ctx = px(x - 1, y) << 0 | px(x - 2, y) << 1 | px(x - 3, y) << 2 | px(x - 4, y) << 3 | px(x + (a[0]?.x ?? 3), y + (a[0]?.y ?? -1)) << 4 | px(x + 2, y - 1) << 5 | px(x + 1, y - 1) << 6 | px(x, y - 1) << 7 | px(x - 1, y - 1) << 8 | px(x - 2, y - 1) << 9 | px(x + (a[1]?.x ?? -3), y + (a[1]?.y ?? -1)) << 10 | px(x + (a[2]?.x ?? 2), y + (a[2]?.y ?? -2)) << 11 | px(x + 1, y - 2) << 12 | px(x, y - 2) << 13 | px(x - 1, y - 2) << 14 | px(x + (a[3]?.x ?? -2), y + (a[3]?.y ?? -2)) << 15;
+					break;
+				case 1:
+					ctx = px(x - 1, y) << 0 | px(x - 2, y) << 1 | px(x - 3, y) << 2 | px(x + (a[0]?.x ?? 3), y + (a[0]?.y ?? -1)) << 3 | px(x + 2, y - 1) << 4 | px(x + 1, y - 1) << 5 | px(x, y - 1) << 6 | px(x - 1, y - 1) << 7 | px(x - 2, y - 1) << 8 | px(x + 2, y - 2) << 9 | px(x + 1, y - 2) << 10 | px(x, y - 2) << 11 | px(x - 1, y - 2) << 12;
+					break;
+				case 2:
+					ctx = px(x - 1, y) << 0 | px(x - 2, y) << 1 | px(x + (a[0]?.x ?? 2), y + (a[0]?.y ?? -1)) << 2 | px(x + 1, y - 1) << 3 | px(x, y - 1) << 4 | px(x - 1, y - 1) << 5 | px(x - 2, y - 1) << 6 | px(x + 1, y - 2) << 7 | px(x, y - 2) << 8 | px(x - 1, y - 2) << 9;
+					break;
+				default:
+					ctx = px(x - 1, y) << 0 | px(x - 2, y) << 1 | px(x - 3, y) << 2 | px(x - 4, y) << 3 | px(x + (a[0]?.x ?? 2), y + (a[0]?.y ?? -1)) << 4 | px(x + 1, y - 1) << 5 | px(x, y - 1) << 6 | px(x - 1, y - 1) << 7 | px(x - 2, y - 1) << 8 | px(x - 3, y - 1) << 9;
+					break;
+			}
+			bmp.data[y * width + x] = mq.decode(cx, ctx);
+		}
+	}
+	return bmp;
+}
+/** The nominal refinement AT positions (§6.3.5.3). */
+var NOMINAL_AT_REFINE = [{
+	x: -1,
+	y: -1
+}, {
+	x: -1,
+	y: -1
+}];
+/**
+* §6.3.5.6 — refine `reference` into a bitmap of `width` × `height`.
+*
+* Refinement codes a bitmap against one already decoded — the same glyph at a
+* lower resolution, or the same region in a previous pass — so only where they
+* differ costs anything.
+*
+* @param dx Where the reference sits relative to the region (GRREFERENCEDX).
+* @param dy Likewise, vertically.
+*/
+/**
+* §6.3.5.3 figures 12-14 — the refinement templates, as the pixels they read
+* and the ORDER they read them in: every pixel of the bitmap being coded, then
+* every pixel of the reference, most significant bit first. Template 0 takes an
+* adaptive pixel in each list; template 1 is fixed.
+*/
+var REFINE_TEMPLATE = [{
+	coding: [
+		{
+			x: 0,
+			y: -1
+		},
+		{
+			x: 1,
+			y: -1
+		},
+		{
+			x: -1,
+			y: 0
+		}
+	],
+	reference: [
+		{
+			x: 0,
+			y: -1
+		},
+		{
+			x: 1,
+			y: -1
+		},
+		{
+			x: -1,
+			y: 0
+		},
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: 1,
+			y: 0
+		},
+		{
+			x: -1,
+			y: 1
+		},
+		{
+			x: 0,
+			y: 1
+		},
+		{
+			x: 1,
+			y: 1
+		}
+	]
+}, {
+	coding: [
+		{
+			x: -1,
+			y: -1
+		},
+		{
+			x: 0,
+			y: -1
+		},
+		{
+			x: 1,
+			y: -1
+		},
+		{
+			x: -1,
+			y: 0
+		}
+	],
+	reference: [
+		{
+			x: 0,
+			y: -1
+		},
+		{
+			x: -1,
+			y: 0
+		},
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: 1,
+			y: 0
+		},
+		{
+			x: 0,
+			y: 1
+		},
+		{
+			x: 1,
+			y: 1
+		}
+	]
+}];
+/** §6.3.5.6 — the context the TPGRON bit is read in, per template. */
+var REFINE_TPGR_CX = [32, 8];
+/**
+* §6.3.5.6 — refine `reference` into a bitmap of `width` × `height`.
+*
+* Refinement codes a bitmap against one already decoded — the same glyph at a
+* lower resolution, or the same region in an earlier pass — so only where the
+* two differ costs anything.
+*
+* @param dx Where the reference sits relative to the region (GRREFERENCEDX).
+* @param dy Likewise, vertically.
+*/
+function decodeRefinement(mq, cx, width, height, template, reference, dx, dy, at, tpgron) {
+	const bmp = makeBitmap(width, height);
+	const t = REFINE_TEMPLATE[template === 0 ? 0 : 1];
+	const coding = template === 0 ? [...t.coding, at[0] ?? NOMINAL_AT_REFINE[0]] : t.coding;
+	const ref = template === 0 ? [...t.reference, at[1] ?? NOMINAL_AT_REFINE[1]] : t.reference;
+	const px = (x, y) => x < 0 || x >= width || y < 0 || y >= height ? 0 : bmp.data[y * width + x] ?? 0;
+	const rf = (x, y) => {
+		const rx = x - dx;
+		const ry = y - dy;
+		return rx < 0 || rx >= reference.width || ry < 0 || ry >= reference.height ? 0 : reference.data[ry * reference.width + rx] ?? 0;
+	};
+	let ltp = 0;
+	for (let y = 0; y < height; y++) {
+		if (tpgron) ltp ^= mq.decode(cx, REFINE_TPGR_CX[template === 0 ? 0 : 1]);
+		for (let x = 0; x < width; x++) {
+			if (ltp === 1) {
+				const s = rf(x - 1, y - 1) + rf(x, y - 1) + rf(x + 1, y - 1) + rf(x - 1, y) + rf(x, y) + rf(x + 1, y) + rf(x - 1, y + 1) + rf(x, y + 1) + rf(x + 1, y + 1);
+				if (s === 0 || s === 9) {
+					bmp.data[y * width + x] = s === 9 ? 1 : 0;
+					continue;
+				}
+			}
+			let ctx = 0;
+			for (const p of coding) ctx = ctx << 1 | px(x + p.x, y + p.y);
+			for (const p of ref) ctx = ctx << 1 | rf(x + p.x, y + p.y);
+			bmp.data[y * width + x] = mq.decode(cx, ctx);
+		}
+	}
+	return bmp;
+}
+/**
+* §B.3 — assign a prefix code to every line from its length, shortest first,
+* which is the canonical Huffman assignment and needs no code lengths stored.
+*/
+function buildHuffTable(lines) {
+	const used = lines.filter((l) => l.prefLen > 0);
+	const maxLen = Math.max(0, ...used.map((l) => l.prefLen));
+	const countOf = new Array(maxLen + 1).fill(0);
+	for (const l of used) countOf[l.prefLen] = (countOf[l.prefLen] ?? 0) + 1;
+	const firstCode = new Array(maxLen + 2).fill(0);
+	for (let len = 1; len <= maxLen; len++) firstCode[len] = firstCode[len - 1] + (countOf[len - 1] ?? 0) << 1;
+	const next = [...firstCode];
+	const out = [];
+	for (let len = 1; len <= maxLen; len++) for (const l of used) {
+		if (l.prefLen !== len) continue;
+		out.push({
+			...l,
+			code: next[len]
+		});
+		next[len]++;
+	}
+	return { lines: out };
+}
+/** A most-significant-bit-first reader over a segment's data. */
+var BitReader = class {
+	pos = 0;
+	bit = 0;
+	constructor(d) {
+		this.d = d;
+	}
+	read() {
+		if (this.pos >= this.d.length) return 0;
+		const v = (this.d[this.pos] ?? 0) >> 7 - this.bit & 1;
+		if (++this.bit === 8) {
+			this.bit = 0;
+			this.pos++;
+		}
+		return v;
+	}
+	readBits(n) {
+		let v = 0;
+		for (let i = 0; i < n; i++) v = v * 2 + this.read();
+		return v;
+	}
+	align() {
+		if (this.bit !== 0) {
+			this.bit = 0;
+			this.pos++;
+		}
+	}
+	get bytePos() {
+		return this.pos;
+	}
+	skipTo(byte) {
+		this.pos = byte;
+		this.bit = 0;
+	}
+};
+/** §B.4 — read one value through a table, or OOB where the table has one. */
+function huffDecode(r, t) {
+	let code = 0;
+	let len = 0;
+	for (let guard = 0; guard < 32; guard++) {
+		code = code << 1 | r.read();
+		len++;
+		for (const line of t.lines) {
+			if (line.prefLen !== len || line.code !== code) continue;
+			if (line.kind === "oob") return OOB;
+			if (line.rangeLen === 32) {
+				const v = r.readBits(32);
+				return line.kind === "lower" ? line.rangeLow - v : line.rangeLow + v;
+			}
+			const v = r.readBits(line.rangeLen);
+			return line.kind === "lower" ? line.rangeLow - v : line.rangeLow + v;
+		}
+	}
+	return OOB;
+}
+/**
+* §B.5 Tables B.1–B.15 — the standard tables, as `[prefLen, rangeLen,
+* rangeLow]` with `'lower'` and `'oob'` on the two lines that need them.
+*
+* They are transcribed rather than derived, and the corpus is what checks
+* them: a table off by one line decodes rubble, and the suite says so at once.
+*/
+var STANDARD_TABLES = [
+	[
+		{
+			prefLen: 1,
+			rangeLen: 4,
+			rangeLow: 0
+		},
+		{
+			prefLen: 2,
+			rangeLen: 8,
+			rangeLow: 16
+		},
+		{
+			prefLen: 3,
+			rangeLen: 16,
+			rangeLow: 272
+		},
+		{
+			prefLen: 3,
+			rangeLen: 32,
+			rangeLow: 65808
+		}
+	],
+	[
+		{
+			prefLen: 1,
+			rangeLen: 0,
+			rangeLow: 0
+		},
+		{
+			prefLen: 2,
+			rangeLen: 0,
+			rangeLow: 1
+		},
+		{
+			prefLen: 3,
+			rangeLen: 0,
+			rangeLow: 2
+		},
+		{
+			prefLen: 4,
+			rangeLen: 3,
+			rangeLow: 3
+		},
+		{
+			prefLen: 5,
+			rangeLen: 6,
+			rangeLow: 11
+		},
+		{
+			prefLen: 6,
+			rangeLen: 32,
+			rangeLow: 75
+		},
+		{
+			prefLen: 6,
+			rangeLen: 0,
+			rangeLow: 0,
+			kind: "oob"
+		}
+	],
+	[
+		{
+			prefLen: 8,
+			rangeLen: 8,
+			rangeLow: -256
+		},
+		{
+			prefLen: 1,
+			rangeLen: 0,
+			rangeLow: 0
+		},
+		{
+			prefLen: 2,
+			rangeLen: 0,
+			rangeLow: 1
+		},
+		{
+			prefLen: 3,
+			rangeLen: 0,
+			rangeLow: 2
+		},
+		{
+			prefLen: 4,
+			rangeLen: 3,
+			rangeLow: 3
+		},
+		{
+			prefLen: 5,
+			rangeLen: 6,
+			rangeLow: 11
+		},
+		{
+			prefLen: 8,
+			rangeLen: 32,
+			rangeLow: -257,
+			kind: "lower"
+		},
+		{
+			prefLen: 7,
+			rangeLen: 32,
+			rangeLow: 75
+		},
+		{
+			prefLen: 6,
+			rangeLen: 0,
+			rangeLow: 0,
+			kind: "oob"
+		}
+	],
+	[
+		{
+			prefLen: 1,
+			rangeLen: 0,
+			rangeLow: 1
+		},
+		{
+			prefLen: 2,
+			rangeLen: 0,
+			rangeLow: 2
+		},
+		{
+			prefLen: 3,
+			rangeLen: 0,
+			rangeLow: 3
+		},
+		{
+			prefLen: 4,
+			rangeLen: 3,
+			rangeLow: 4
+		},
+		{
+			prefLen: 5,
+			rangeLen: 6,
+			rangeLow: 12
+		},
+		{
+			prefLen: 5,
+			rangeLen: 32,
+			rangeLow: 76
+		}
+	],
+	[
+		{
+			prefLen: 7,
+			rangeLen: 8,
+			rangeLow: -255
+		},
+		{
+			prefLen: 1,
+			rangeLen: 0,
+			rangeLow: 1
+		},
+		{
+			prefLen: 2,
+			rangeLen: 0,
+			rangeLow: 2
+		},
+		{
+			prefLen: 3,
+			rangeLen: 0,
+			rangeLow: 3
+		},
+		{
+			prefLen: 4,
+			rangeLen: 3,
+			rangeLow: 4
+		},
+		{
+			prefLen: 5,
+			rangeLen: 6,
+			rangeLow: 12
+		},
+		{
+			prefLen: 7,
+			rangeLen: 32,
+			rangeLow: -256,
+			kind: "lower"
+		},
+		{
+			prefLen: 6,
+			rangeLen: 32,
+			rangeLow: 76
+		}
+	],
+	[
+		{
+			prefLen: 5,
+			rangeLen: 10,
+			rangeLow: -2048
+		},
+		{
+			prefLen: 4,
+			rangeLen: 9,
+			rangeLow: -1024
+		},
+		{
+			prefLen: 4,
+			rangeLen: 8,
+			rangeLow: -512
+		},
+		{
+			prefLen: 4,
+			rangeLen: 7,
+			rangeLow: -256
+		},
+		{
+			prefLen: 5,
+			rangeLen: 6,
+			rangeLow: -128
+		},
+		{
+			prefLen: 5,
+			rangeLen: 5,
+			rangeLow: -64
+		},
+		{
+			prefLen: 4,
+			rangeLen: 5,
+			rangeLow: -32
+		},
+		{
+			prefLen: 2,
+			rangeLen: 7,
+			rangeLow: 0
+		},
+		{
+			prefLen: 3,
+			rangeLen: 7,
+			rangeLow: 128
+		},
+		{
+			prefLen: 3,
+			rangeLen: 8,
+			rangeLow: 256
+		},
+		{
+			prefLen: 4,
+			rangeLen: 9,
+			rangeLow: 512
+		},
+		{
+			prefLen: 4,
+			rangeLen: 10,
+			rangeLow: 1024
+		},
+		{
+			prefLen: 6,
+			rangeLen: 32,
+			rangeLow: -2049,
+			kind: "lower"
+		},
+		{
+			prefLen: 6,
+			rangeLen: 32,
+			rangeLow: 2048
+		}
+	],
+	[
+		{
+			prefLen: 4,
+			rangeLen: 9,
+			rangeLow: -1024
+		},
+		{
+			prefLen: 3,
+			rangeLen: 8,
+			rangeLow: -512
+		},
+		{
+			prefLen: 4,
+			rangeLen: 7,
+			rangeLow: -256
+		},
+		{
+			prefLen: 5,
+			rangeLen: 6,
+			rangeLow: -128
+		},
+		{
+			prefLen: 5,
+			rangeLen: 5,
+			rangeLow: -64
+		},
+		{
+			prefLen: 4,
+			rangeLen: 5,
+			rangeLow: -32
+		},
+		{
+			prefLen: 4,
+			rangeLen: 9,
+			rangeLow: 0
+		},
+		{
+			prefLen: 5,
+			rangeLen: 10,
+			rangeLow: 512
+		},
+		{
+			prefLen: 3,
+			rangeLen: 10,
+			rangeLow: 1536
+		},
+		{
+			prefLen: 5,
+			rangeLen: 32,
+			rangeLow: -1025,
+			kind: "lower"
+		},
+		{
+			prefLen: 5,
+			rangeLen: 32,
+			rangeLow: 2560
+		}
+	],
+	[
+		{
+			prefLen: 8,
+			rangeLen: 3,
+			rangeLow: -15
+		},
+		{
+			prefLen: 9,
+			rangeLen: 1,
+			rangeLow: -7
+		},
+		{
+			prefLen: 8,
+			rangeLen: 1,
+			rangeLow: -5
+		},
+		{
+			prefLen: 9,
+			rangeLen: 0,
+			rangeLow: -3
+		},
+		{
+			prefLen: 7,
+			rangeLen: 0,
+			rangeLow: -2
+		},
+		{
+			prefLen: 4,
+			rangeLen: 0,
+			rangeLow: -1
+		},
+		{
+			prefLen: 2,
+			rangeLen: 1,
+			rangeLow: 0
+		},
+		{
+			prefLen: 5,
+			rangeLen: 0,
+			rangeLow: 2
+		},
+		{
+			prefLen: 6,
+			rangeLen: 0,
+			rangeLow: 3
+		},
+		{
+			prefLen: 3,
+			rangeLen: 4,
+			rangeLow: 4
+		},
+		{
+			prefLen: 6,
+			rangeLen: 1,
+			rangeLow: 20
+		},
+		{
+			prefLen: 4,
+			rangeLen: 4,
+			rangeLow: 22
+		},
+		{
+			prefLen: 4,
+			rangeLen: 5,
+			rangeLow: 38
+		},
+		{
+			prefLen: 5,
+			rangeLen: 6,
+			rangeLow: 70
+		},
+		{
+			prefLen: 5,
+			rangeLen: 7,
+			rangeLow: 134
+		},
+		{
+			prefLen: 6,
+			rangeLen: 7,
+			rangeLow: 262
+		},
+		{
+			prefLen: 7,
+			rangeLen: 8,
+			rangeLow: 390
+		},
+		{
+			prefLen: 6,
+			rangeLen: 10,
+			rangeLow: 646
+		},
+		{
+			prefLen: 9,
+			rangeLen: 32,
+			rangeLow: -16,
+			kind: "lower"
+		},
+		{
+			prefLen: 9,
+			rangeLen: 32,
+			rangeLow: 1670
+		},
+		{
+			prefLen: 2,
+			rangeLen: 0,
+			rangeLow: 0,
+			kind: "oob"
+		}
+	],
+	[
+		{
+			prefLen: 8,
+			rangeLen: 4,
+			rangeLow: -31
+		},
+		{
+			prefLen: 9,
+			rangeLen: 2,
+			rangeLow: -15
+		},
+		{
+			prefLen: 8,
+			rangeLen: 2,
+			rangeLow: -11
+		},
+		{
+			prefLen: 9,
+			rangeLen: 1,
+			rangeLow: -7
+		},
+		{
+			prefLen: 7,
+			rangeLen: 1,
+			rangeLow: -5
+		},
+		{
+			prefLen: 4,
+			rangeLen: 1,
+			rangeLow: -3
+		},
+		{
+			prefLen: 3,
+			rangeLen: 1,
+			rangeLow: -1
+		},
+		{
+			prefLen: 3,
+			rangeLen: 1,
+			rangeLow: 1
+		},
+		{
+			prefLen: 5,
+			rangeLen: 1,
+			rangeLow: 3
+		},
+		{
+			prefLen: 6,
+			rangeLen: 1,
+			rangeLow: 5
+		},
+		{
+			prefLen: 3,
+			rangeLen: 5,
+			rangeLow: 7
+		},
+		{
+			prefLen: 6,
+			rangeLen: 2,
+			rangeLow: 39
+		},
+		{
+			prefLen: 4,
+			rangeLen: 5,
+			rangeLow: 43
+		},
+		{
+			prefLen: 4,
+			rangeLen: 6,
+			rangeLow: 75
+		},
+		{
+			prefLen: 5,
+			rangeLen: 7,
+			rangeLow: 139
+		},
+		{
+			prefLen: 5,
+			rangeLen: 8,
+			rangeLow: 267
+		},
+		{
+			prefLen: 6,
+			rangeLen: 8,
+			rangeLow: 523
+		},
+		{
+			prefLen: 7,
+			rangeLen: 9,
+			rangeLow: 779
+		},
+		{
+			prefLen: 6,
+			rangeLen: 11,
+			rangeLow: 1291
+		},
+		{
+			prefLen: 9,
+			rangeLen: 32,
+			rangeLow: -32,
+			kind: "lower"
+		},
+		{
+			prefLen: 9,
+			rangeLen: 32,
+			rangeLow: 3339
+		},
+		{
+			prefLen: 2,
+			rangeLen: 0,
+			rangeLow: 0,
+			kind: "oob"
+		}
+	],
+	[
+		{
+			prefLen: 7,
+			rangeLen: 4,
+			rangeLow: -21
+		},
+		{
+			prefLen: 8,
+			rangeLen: 0,
+			rangeLow: -5
+		},
+		{
+			prefLen: 7,
+			rangeLen: 0,
+			rangeLow: -4
+		},
+		{
+			prefLen: 5,
+			rangeLen: 0,
+			rangeLow: -3
+		},
+		{
+			prefLen: 2,
+			rangeLen: 2,
+			rangeLow: -2
+		},
+		{
+			prefLen: 5,
+			rangeLen: 0,
+			rangeLow: 2
+		},
+		{
+			prefLen: 6,
+			rangeLen: 0,
+			rangeLow: 3
+		},
+		{
+			prefLen: 7,
+			rangeLen: 0,
+			rangeLow: 4
+		},
+		{
+			prefLen: 8,
+			rangeLen: 0,
+			rangeLow: 5
+		},
+		{
+			prefLen: 2,
+			rangeLen: 6,
+			rangeLow: 6
+		},
+		{
+			prefLen: 5,
+			rangeLen: 5,
+			rangeLow: 70
+		},
+		{
+			prefLen: 6,
+			rangeLen: 5,
+			rangeLow: 102
+		},
+		{
+			prefLen: 7,
+			rangeLen: 6,
+			rangeLow: 134
+		},
+		{
+			prefLen: 8,
+			rangeLen: 7,
+			rangeLow: 198
+		},
+		{
+			prefLen: 8,
+			rangeLen: 8,
+			rangeLow: 326
+		},
+		{
+			prefLen: 8,
+			rangeLen: 9,
+			rangeLow: 582
+		},
+		{
+			prefLen: 8,
+			rangeLen: 10,
+			rangeLow: 1094
+		},
+		{
+			prefLen: 7,
+			rangeLen: 11,
+			rangeLow: 2118
+		},
+		{
+			prefLen: 8,
+			rangeLen: 32,
+			rangeLow: -22,
+			kind: "lower"
+		},
+		{
+			prefLen: 8,
+			rangeLen: 32,
+			rangeLow: 4166
+		},
+		{
+			prefLen: 2,
+			rangeLen: 0,
+			rangeLow: 0,
+			kind: "oob"
+		}
+	],
+	[
+		{
+			prefLen: 1,
+			rangeLen: 0,
+			rangeLow: 1
+		},
+		{
+			prefLen: 2,
+			rangeLen: 1,
+			rangeLow: 2
+		},
+		{
+			prefLen: 4,
+			rangeLen: 0,
+			rangeLow: 4
+		},
+		{
+			prefLen: 4,
+			rangeLen: 1,
+			rangeLow: 5
+		},
+		{
+			prefLen: 5,
+			rangeLen: 1,
+			rangeLow: 7
+		},
+		{
+			prefLen: 5,
+			rangeLen: 2,
+			rangeLow: 9
+		},
+		{
+			prefLen: 6,
+			rangeLen: 2,
+			rangeLow: 13
+		},
+		{
+			prefLen: 7,
+			rangeLen: 2,
+			rangeLow: 17
+		},
+		{
+			prefLen: 7,
+			rangeLen: 3,
+			rangeLow: 21
+		},
+		{
+			prefLen: 7,
+			rangeLen: 4,
+			rangeLow: 29
+		},
+		{
+			prefLen: 7,
+			rangeLen: 5,
+			rangeLow: 45
+		},
+		{
+			prefLen: 7,
+			rangeLen: 6,
+			rangeLow: 77
+		},
+		{
+			prefLen: 7,
+			rangeLen: 32,
+			rangeLow: 141
+		}
+	],
+	[
+		{
+			prefLen: 1,
+			rangeLen: 0,
+			rangeLow: 1
+		},
+		{
+			prefLen: 2,
+			rangeLen: 0,
+			rangeLow: 2
+		},
+		{
+			prefLen: 3,
+			rangeLen: 1,
+			rangeLow: 3
+		},
+		{
+			prefLen: 5,
+			rangeLen: 0,
+			rangeLow: 5
+		},
+		{
+			prefLen: 5,
+			rangeLen: 1,
+			rangeLow: 6
+		},
+		{
+			prefLen: 6,
+			rangeLen: 1,
+			rangeLow: 8
+		},
+		{
+			prefLen: 7,
+			rangeLen: 0,
+			rangeLow: 10
+		},
+		{
+			prefLen: 7,
+			rangeLen: 1,
+			rangeLow: 11
+		},
+		{
+			prefLen: 7,
+			rangeLen: 2,
+			rangeLow: 13
+		},
+		{
+			prefLen: 7,
+			rangeLen: 3,
+			rangeLow: 17
+		},
+		{
+			prefLen: 7,
+			rangeLen: 4,
+			rangeLow: 25
+		},
+		{
+			prefLen: 8,
+			rangeLen: 5,
+			rangeLow: 41
+		},
+		{
+			prefLen: 8,
+			rangeLen: 32,
+			rangeLow: 73
+		}
+	],
+	[
+		{
+			prefLen: 1,
+			rangeLen: 0,
+			rangeLow: 1
+		},
+		{
+			prefLen: 3,
+			rangeLen: 0,
+			rangeLow: 2
+		},
+		{
+			prefLen: 4,
+			rangeLen: 0,
+			rangeLow: 3
+		},
+		{
+			prefLen: 5,
+			rangeLen: 0,
+			rangeLow: 4
+		},
+		{
+			prefLen: 4,
+			rangeLen: 1,
+			rangeLow: 5
+		},
+		{
+			prefLen: 3,
+			rangeLen: 3,
+			rangeLow: 7
+		},
+		{
+			prefLen: 6,
+			rangeLen: 1,
+			rangeLow: 15
+		},
+		{
+			prefLen: 6,
+			rangeLen: 2,
+			rangeLow: 17
+		},
+		{
+			prefLen: 6,
+			rangeLen: 3,
+			rangeLow: 21
+		},
+		{
+			prefLen: 6,
+			rangeLen: 4,
+			rangeLow: 29
+		},
+		{
+			prefLen: 6,
+			rangeLen: 5,
+			rangeLow: 45
+		},
+		{
+			prefLen: 7,
+			rangeLen: 6,
+			rangeLow: 77
+		},
+		{
+			prefLen: 7,
+			rangeLen: 32,
+			rangeLow: 141
+		}
+	],
+	[
+		{
+			prefLen: 3,
+			rangeLen: 0,
+			rangeLow: -2
+		},
+		{
+			prefLen: 3,
+			rangeLen: 0,
+			rangeLow: -1
+		},
+		{
+			prefLen: 1,
+			rangeLen: 0,
+			rangeLow: 0
+		},
+		{
+			prefLen: 3,
+			rangeLen: 0,
+			rangeLow: 1
+		},
+		{
+			prefLen: 3,
+			rangeLen: 0,
+			rangeLow: 2
+		}
+	],
+	[
+		{
+			prefLen: 7,
+			rangeLen: 4,
+			rangeLow: -24
+		},
+		{
+			prefLen: 6,
+			rangeLen: 2,
+			rangeLow: -8
+		},
+		{
+			prefLen: 5,
+			rangeLen: 1,
+			rangeLow: -4
+		},
+		{
+			prefLen: 4,
+			rangeLen: 0,
+			rangeLow: -2
+		},
+		{
+			prefLen: 3,
+			rangeLen: 0,
+			rangeLow: -1
+		},
+		{
+			prefLen: 1,
+			rangeLen: 0,
+			rangeLow: 0
+		},
+		{
+			prefLen: 3,
+			rangeLen: 0,
+			rangeLow: 1
+		},
+		{
+			prefLen: 4,
+			rangeLen: 0,
+			rangeLow: 2
+		},
+		{
+			prefLen: 5,
+			rangeLen: 1,
+			rangeLow: 3
+		},
+		{
+			prefLen: 6,
+			rangeLen: 2,
+			rangeLow: 5
+		},
+		{
+			prefLen: 7,
+			rangeLen: 4,
+			rangeLow: 9
+		},
+		{
+			prefLen: 7,
+			rangeLen: 32,
+			rangeLow: -25,
+			kind: "lower"
+		},
+		{
+			prefLen: 7,
+			rangeLen: 32,
+			rangeLow: 25
+		}
+	]
+];
+/** Table B.n, ready to read with. */
+function standardTable(n) {
+	return buildHuffTable(STANDARD_TABLES[n - 1] ?? STANDARD_TABLES[0]);
+}
+/** §B.2 — a custom table, from a type-53 segment. */
+function parseCustomTable(data) {
+	const r = new Reader(data);
+	const flags = r.u8();
+	const oob = (flags & 1) !== 0;
+	const prefLenSize = (flags >> 1 & 7) + 1;
+	const rangeLenSize = (flags >> 4 & 7) + 1;
+	const low = r.u32() | 0;
+	const high = r.u32() | 0;
+	const bits = new BitReader(data.subarray(r.pos));
+	const lines = [];
+	let cur = low;
+	while (cur < high) {
+		const prefLen = bits.readBits(prefLenSize);
+		const rangeLen = bits.readBits(rangeLenSize);
+		lines.push({
+			prefLen,
+			rangeLen,
+			rangeLow: cur
+		});
+		cur += 1 << rangeLen;
+		if (lines.length > 4096) break;
+	}
+	lines.push({
+		prefLen: bits.readBits(prefLenSize),
+		rangeLen: 32,
+		rangeLow: low - 1,
+		kind: "lower"
+	});
+	lines.push({
+		prefLen: bits.readBits(prefLenSize),
+		rangeLen: 32,
+		rangeLow: high
+	});
+	if (oob) lines.push({
+		prefLen: bits.readBits(prefLenSize),
+		rangeLen: 0,
+		rangeLow: 0,
+		kind: "oob"
+	});
+	return buildHuffTable(lines);
+}
+/** §A.2 returns this instead of a number when the coder signals out-of-band. */
+var OOB = Symbol("OOB");
+/**
+* §A.2 — the integer decoding procedure.
+*
+* Every count, coordinate and delta in a symbol dictionary or text region comes
+* through here: a sign bit, then a prefix that says how many magnitude bits
+* follow and what to add to them. The context is a walk down a binary tree of
+* the bits read so far, which is why each kind of integer (IADH, IADW, IADT …)
+* needs a context set of its own.
+*/
+var IntDecoder = class {
+	cx = newContexts(512);
+	constructor(mq) {
+		this.mq = mq;
+	}
+	decode() {
+		let prev = 1;
+		const bit = () => {
+			const b = this.mq.decode(this.cx, prev);
+			prev = prev < 256 ? prev << 1 | b : ((prev << 1 | b) & 511 | 256) >>> 0;
+			return b;
+		};
+		const sign = bit();
+		const FIELDS = [
+			[2, 0],
+			[4, 4],
+			[6, 20],
+			[8, 84],
+			[12, 340],
+			[32, 4436]
+		];
+		let level = 0;
+		while (level < 5 && bit() === 1) level++;
+		const [n, offset] = FIELDS[level];
+		let v = 0;
+		for (let i = 0; i < n; i++) v = v << 1 | bit();
+		v += offset;
+		if (sign === 0) return v;
+		return v === 0 ? OOB : -v;
+	}
+};
+/** §A.3 — the symbol ID decoder, a fixed-width code down its own context tree. */
+var IdDecoder = class {
+	cx;
+	constructor(mq, codeLen) {
+		this.mq = mq;
+		this.codeLen = codeLen;
+		this.cx = newContexts(1 << codeLen + 1);
+	}
+	decode() {
+		let prev = 1;
+		for (let i = 0; i < this.codeLen; i++) prev = prev << 1 | this.mq.decode(this.cx, prev);
+		return prev - (1 << this.codeLen);
+	}
+};
+/** How a text region places each instance against the point it names (§6.4.5). */
+var Corner = /* @__PURE__ */ function(Corner) {
+	Corner[Corner["BottomLeft"] = 0] = "BottomLeft";
+	Corner[Corner["TopLeft"] = 1] = "TopLeft";
+	Corner[Corner["BottomRight"] = 2] = "BottomRight";
+	Corner[Corner["TopRight"] = 3] = "TopRight";
+	return Corner;
+}(Corner || {});
+/**
+* §6.4.5 — draw a text region: a run of strips, each holding instances of the
+* symbols in `symbols`, placed by running coordinates rather than absolute ones.
+*
+* This is what JBIG2 is for. A scanned page is not stored as pixels but as "the
+* shape called 37, here; the shape called 12, four pixels on" — so the letter
+* "e" costs its bitmap once and a few bits per occurrence after that.
+*/
+function decodeTextRegion(mq, symbols, p, stripsLog) {
+	const bmp = makeBitmap(p.width, p.height, p.defPixel);
+	const strips = 1 << stripsLog;
+	const codeLen = Math.max(1, Math.ceil(Math.log2(Math.max(symbols.length, 1))));
+	const iadt = new IntDecoder(mq);
+	const iafs = new IntDecoder(mq);
+	const iads = new IntDecoder(mq);
+	const iait = new IntDecoder(mq);
+	const iari = new IntDecoder(mq);
+	const iardw = new IntDecoder(mq);
+	const iardh = new IntDecoder(mq);
+	const iardx = new IntDecoder(mq);
+	const iardy = new IntDecoder(mq);
+	const iaid = new IdDecoder(mq, codeLen);
+	const refineCx = newContexts(8192);
+	const num = (v) => v === OOB ? 0 : v;
+	let stripT = -num(iadt.decode()) * strips;
+	let firstS = 0;
+	let placed = 0;
+	while (placed < p.instances) {
+		stripT += num(iadt.decode()) * strips;
+		firstS += num(iafs.decode());
+		let curS = firstS;
+		for (;;) {
+			const t = strips === 1 ? 0 : num(iait.decode());
+			const tt = stripT + t;
+			let sym = symbols[iaid.decode()] ?? makeBitmap(1, 1);
+			if (p.refine && num(iari.decode()) !== 0) {
+				const rdw = num(iardw.decode());
+				const rdh = num(iardh.decode());
+				const rdx = num(iardx.decode());
+				const rdy = num(iardy.decode());
+				const w = sym.width + rdw;
+				const h = sym.height + rdh;
+				if (w > 0 && h > 0 && w < 16384 && h < 16384) sym = decodeRefinement(mq, refineCx, w, h, p.rTemplate, sym, (rdw >> 1) + rdx, (rdh >> 1) + rdy, p.rAt, false);
+			}
+			const sw = sym.width;
+			const sh = sym.height;
+			let x;
+			let y;
+			if (p.transposed) {
+				x = tt;
+				y = curS;
+				if (p.refCorner === Corner.BottomLeft || p.refCorner === Corner.BottomRight) {}
+				if (p.refCorner === Corner.TopRight || p.refCorner === Corner.BottomRight) x = tt - sw + 1;
+			} else {
+				x = curS;
+				y = tt;
+				if (p.refCorner === Corner.BottomLeft || p.refCorner === Corner.BottomRight) y = tt - sh + 1;
+			}
+			compose(bmp, sym, x, y, p.combOp);
+			curS += (p.transposed ? sh : sw) - 1;
+			placed++;
+			if (placed >= p.instances) break;
+			const ids = iads.decode();
+			if (ids === OOB) break;
+			curS += ids + p.dsOffset;
+		}
+	}
+	return bmp;
+}
+/**
+* §6.5 — decode a symbol dictionary: the shapes a text region will place.
+*
+* Shapes come in HEIGHT CLASSES, tallest dimension first: one delta says how
+* much taller this class is than the last, then a run of widths within it, each
+* ending when the width decoder signals out-of-band.
+*
+* @param input The symbols this dictionary inherits from the ones it refers to.
+*/
+function decodeSymbolDictionary(mq, input, newCount, exportCount, template, at, refAgg, rTemplate, rAt) {
+	const iadh = new IntDecoder(mq);
+	const iadw = new IntDecoder(mq);
+	const iaex = new IntDecoder(mq);
+	const iaai = new IntDecoder(mq);
+	const iardx = new IntDecoder(mq);
+	const iardy = new IntDecoder(mq);
+	const genericCx = newContexts(65536);
+	const refineCx = newContexts(8192);
+	const newSymbols = [];
+	const num = (v) => v === OOB ? 0 : v;
+	let height = 0;
+	let guard = 0;
+	while (newSymbols.length < newCount && guard++ < 1e4) {
+		height += num(iadh.decode());
+		let width = 0;
+		for (;;) {
+			const dw = iadw.decode();
+			if (dw === OOB) break;
+			width += dw;
+			if (newSymbols.length >= newCount) break;
+			if (width <= 0 || height <= 0 || width > 16384 || height > 16384) {
+				newSymbols.push(makeBitmap(1, 1));
+				continue;
+			}
+			if (!refAgg) newSymbols.push(decodeGenericRegion(mq, genericCx, width, height, template, at, false));
+			else {
+				const instances = num(iaai.decode());
+				if (instances === 1) {
+					const all = [...input, ...newSymbols];
+					const id = new IdDecoder(mq, Math.max(1, Math.ceil(Math.log2(Math.max(all.length + newCount, 1))))).decode();
+					const rdx = num(iardx.decode());
+					const rdy = num(iardy.decode());
+					newSymbols.push(decodeRefinement(mq, refineCx, width, height, rTemplate, all[id] ?? makeBitmap(1, 1), rdx, rdy, rAt, false));
+				} else {
+					const all = [...input, ...newSymbols];
+					newSymbols.push(decodeTextRegion(mq, all, {
+						width,
+						height,
+						instances,
+						stripT: 0,
+						refCorner: Corner.TopLeft,
+						transposed: false,
+						combOp: 0,
+						defPixel: 0,
+						dsOffset: 0,
+						refine: true,
+						rTemplate,
+						rAt
+					}, 0));
+				}
+			}
+		}
+	}
+	const all = [...input, ...newSymbols];
+	const exported = [];
+	let i = 0;
+	let exporting = false;
+	let steps = 0;
+	while (i < all.length && exported.length < exportCount && steps++ < 1e4) {
+		const run = num(iaex.decode());
+		if (exporting) for (let k = 0; k < run && i + k < all.length; k++) exported.push(all[i + k]);
+		i += run;
+		exporting = !exporting;
+		if (run === 0 && steps > all.length * 2 + 4) break;
+	}
+	return exported.length > 0 ? exported : newSymbols;
+}
+/**
+* §7.4.3.1.7 — the symbol ID codes, which are themselves Huffman-coded.
+*
+* A run of 35 four-bit lengths builds a table of RUN codes; those then say how
+* long each symbol's own code is, with three of them meaning "repeat the last
+* length", "repeat zero" and "repeat zero many times" — the same trick
+* DEFLATE uses, for the same reason: most symbols share a length.
+*/
+function readSymbolIdTable(bits, count) {
+	const runLines = [];
+	for (let i = 0; i < 35; i++) runLines.push({
+		prefLen: bits.readBits(4),
+		rangeLen: 0,
+		rangeLow: i
+	});
+	const runTable = buildHuffTable(runLines);
+	const lengths = new Array(count).fill(0);
+	let prev = 0;
+	for (let i = 0; i < count;) {
+		const code = huffDecode(bits, runTable);
+		if (code === OOB) break;
+		if (code < 32) {
+			lengths[i++] = code;
+			prev = code;
+		} else if (code === 32) {
+			const n = bits.readBits(2) + 3;
+			for (let k = 0; k < n && i < count; k++) lengths[i++] = prev;
+		} else if (code === 33) {
+			const n = bits.readBits(3) + 3;
+			for (let k = 0; k < n && i < count; k++) lengths[i++] = 0;
+		} else {
+			const n = bits.readBits(7) + 11;
+			for (let k = 0; k < n && i < count; k++) lengths[i++] = 0;
+		}
+	}
+	bits.align();
+	return buildHuffTable(lengths.map((prefLen, i) => ({
+		prefLen,
+		rangeLen: 0,
+		rangeLow: i
+	})));
+}
+/**
+* §6.4 — a Huffman-coded text region, the same placement walk as the
+* arithmetic one with every number read through a table instead.
+*/
+function decodeTextRegionHuff(bits, data, symbols, p, stripsLog, t) {
+	const bmp = makeBitmap(p.width, p.height, p.defPixel);
+	const strips = 1 << stripsLog;
+	const refineCx = newContexts(8192);
+	const num = (v) => v === OOB ? 0 : v;
+	let stripT = -num(huffDecode(bits, t.dt)) * strips;
+	let firstS = 0;
+	let placed = 0;
+	let guard = 0;
+	while (placed < p.instances && guard++ < 1e5) {
+		stripT += num(huffDecode(bits, t.dt)) * strips;
+		firstS += num(huffDecode(bits, t.fs));
+		let curS = firstS;
+		for (;;) {
+			const tOff = strips === 1 ? 0 : bits.readBits(stripsLog);
+			let sym = symbols[num(huffDecode(bits, t.symbolIds))] ?? makeBitmap(1, 1);
+			if (p.refine && bits.read() !== 0) {
+				const rdw = num(huffDecode(bits, t.rdw));
+				const rdh = num(huffDecode(bits, t.rdh));
+				const rdx = num(huffDecode(bits, t.rdx));
+				const rdy = num(huffDecode(bits, t.rdy));
+				const size = num(huffDecode(bits, t.rsize));
+				bits.align();
+				const w = sym.width + rdw;
+				const h = sym.height + rdh;
+				const start = bits.bytePos;
+				if (w > 0 && h > 0 && w < 16384 && h < 16384) sym = decodeRefinement(new MQDecoder(data.subarray(start)), refineCx, w, h, p.rTemplate, sym, (rdw >> 1) + rdx, (rdh >> 1) + rdy, p.rAt, false);
+				bits.skipTo(start + size);
+			}
+			const sw = sym.width;
+			const sh = sym.height;
+			const tt = stripT + tOff;
+			let x;
+			let y;
+			if (p.transposed) {
+				x = tt;
+				y = curS;
+				if (p.refCorner === Corner.TopRight || p.refCorner === Corner.BottomRight) x = tt - sw + 1;
+			} else {
+				x = curS;
+				y = tt;
+				if (p.refCorner === Corner.BottomLeft || p.refCorner === Corner.BottomRight) y = tt - sh + 1;
+			}
+			compose(bmp, sym, x, y, p.combOp);
+			curS += (p.transposed ? sh : sw) - 1;
+			placed++;
+			if (placed >= p.instances) break;
+			const ids = huffDecode(bits, t.ds);
+			if (ids === OOB) break;
+			curS += ids + p.dsOffset;
+		}
+	}
+	return bmp;
+}
+/**
+* §6.5.9 — a Huffman-coded symbol dictionary.
+*
+* The shapes of a height class are not coded one by one: their widths are read
+* first, then the whole class arrives as ONE collective bitmap, which is cut
+* apart by those widths. That is why a Huffman dictionary needs a size field
+* the arithmetic one does not.
+*/
+function decodeSymbolDictionaryHuff(bits, data, input, newCount, exportCount, dh, dw, bmSize) {
+	const newSymbols = [];
+	const num = (v) => v === OOB ? 0 : v;
+	let height = 0;
+	let guard = 0;
+	while (newSymbols.length < newCount && guard++ < 1e4) {
+		height += num(huffDecode(bits, dh));
+		if (height <= 0 || height > 16384) break;
+		let width = 0;
+		let totalWidth = 0;
+		const widths = [];
+		for (;;) {
+			const d = huffDecode(bits, dw);
+			if (d === OOB) break;
+			width += d;
+			if (width <= 0 || width > 16384 || newSymbols.length + widths.length >= newCount + 1) break;
+			widths.push(width);
+			totalWidth += width;
+		}
+		if (widths.length === 0) continue;
+		const size = num(huffDecode(bits, bmSize));
+		bits.align();
+		const start = bits.bytePos;
+		let collective;
+		if (size === 0) {
+			collective = makeBitmap(totalWidth, height);
+			const rowBytes = totalWidth + 7 >> 3;
+			for (let y = 0; y < height; y++) for (let x = 0; x < totalWidth; x++) {
+				const b = data[start + y * rowBytes + (x >> 3)] ?? 0;
+				collective.data[y * totalWidth + x] = b >> 7 - (x & 7) & 1;
+			}
+			bits.skipTo(start + rowBytes * height);
+		} else {
+			const packed = decodeCcitt(data.subarray(start, start + size), {
+				k: -1,
+				columns: totalWidth,
+				rows: height,
+				byteAlign: false
+			});
+			collective = makeBitmap(totalWidth, height);
+			if (packed) {
+				const rowBytes = totalWidth + 7 >> 3;
+				for (let y = 0; y < height; y++) for (let x = 0; x < totalWidth; x++) collective.data[y * totalWidth + x] = packed[y * rowBytes + (x >> 3)] >> 7 - (x & 7) & 1;
+			}
+			bits.skipTo(start + size);
+		}
+		let at = 0;
+		for (const w of widths) {
+			const cell = makeBitmap(w, height);
+			for (let y = 0; y < height; y++) for (let x = 0; x < w; x++) cell.data[y * w + x] = collective.data[y * totalWidth + at + x] ?? 0;
+			newSymbols.push(cell);
+			at += w;
+		}
+	}
+	const all = [...input, ...newSymbols];
+	const exTable = standardTable(1);
+	const exported = [];
+	let i = 0;
+	let exporting = false;
+	let steps = 0;
+	while (i < all.length && exported.length < exportCount && steps++ < 1e4) {
+		const run = num(huffDecode(bits, exTable));
+		if (exporting) for (let k = 0; k < run && i + k < all.length; k++) exported.push(all[i + k]);
+		i += run;
+		exporting = !exporting;
+		if (run === 0 && steps > all.length * 2 + 4) break;
+	}
+	return exported.length > 0 ? exported : newSymbols;
+}
+/**
+* §6.7 — a pattern dictionary: the cells a halftone region tiles a picture out
+* of, from all-white through all-black.
+*
+* They are coded as ONE wide generic region — every pattern side by side — and
+* cut apart afterwards, which is why the first adaptive pixel sits a whole
+* pattern-width back: it makes each cell predict from the one before it.
+*/
+function decodePatternDictionary(data, mmr, template, pw, ph, grayMax) {
+	const count = grayMax + 1;
+	const width = count * pw;
+	let collective;
+	if (mmr) {
+		const packed = decodeCcitt(data, {
+			k: -1,
+			columns: width,
+			rows: ph,
+			byteAlign: false
+		});
+		if (!packed) return [];
+		collective = makeBitmap(width, ph);
+		const rowBytes = width + 7 >> 3;
+		for (let y = 0; y < ph; y++) for (let x = 0; x < width; x++) collective.data[y * width + x] = packed[y * rowBytes + (x >> 3)] >> 7 - (x & 7) & 1;
+	} else collective = decodeGenericRegion(new MQDecoder(data), newContexts(65536), width, ph, template, [
+		{
+			x: -pw,
+			y: 0
+		},
+		{
+			x: -3,
+			y: -1
+		},
+		{
+			x: 2,
+			y: -2
+		},
+		{
+			x: -2,
+			y: -2
+		}
+	], false);
+	const out = [];
+	for (let i = 0; i < count; i++) {
+		const cell = makeBitmap(pw, ph);
+		for (let y = 0; y < ph; y++) for (let x = 0; x < pw; x++) cell.data[y * pw + x] = collective.data[y * width + i * pw + x] ?? 0;
+		out.push(cell);
+	}
+	return out;
+}
+/**
+* §C.5 — the grey-scale image a halftone region is built from: one bitmap per
+* BIT of the value, most significant first, Gray-coded so neighbouring levels
+* differ in one plane and the planes stay smooth enough to code well.
+*/
+function decodeGrayScale(mq, data, mmr, template, at, width, height, bits, skip) {
+	const cx = newContexts(65536);
+	const planes = new Array(bits);
+	let mmrOffset = 0;
+	const decoder = mq ?? new MQDecoder(data);
+	for (let j = bits - 1; j >= 0; j--) if (mmr) {
+		const packed = decodeCcitt(data.subarray(mmrOffset), {
+			k: -1,
+			columns: width,
+			rows: height,
+			byteAlign: false
+		});
+		const plane = makeBitmap(width, height);
+		if (packed) {
+			const rowBytes = width + 7 >> 3;
+			for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) plane.data[y * width + x] = packed[y * rowBytes + (x >> 3)] >> 7 - (x & 7) & 1;
+			mmrOffset += packed.length;
+		}
+		planes[j] = plane;
+	} else planes[j] = decodeGenericRegion(decoder, cx, width, height, template, at, false, skip);
+	const values = new Array(width * height).fill(0);
+	for (let i = 0; i < width * height; i++) {
+		let bit = planes[bits - 1]?.data[i] ?? 0;
+		let v = bit;
+		for (let j = bits - 2; j >= 0; j--) {
+			bit ^= planes[j]?.data[i] ?? 0;
+			v = v * 2 + bit;
+		}
+		values[i] = v;
+	}
+	return values;
+}
+var Reader = class {
+	pos = 0;
+	constructor(d) {
+		this.d = d;
+	}
+	u8() {
+		return this.d[this.pos++] ?? 0;
+	}
+	u16() {
+		return this.u8() << 8 | this.u8();
+	}
+	u32() {
+		return (this.u8() << 24 | this.u16() << 8 | this.u8()) >>> 0;
+	}
+	i8() {
+		const v = this.u8();
+		return v > 127 ? v - 256 : v;
+	}
+	get done() {
+		return this.pos >= this.d.length;
+	}
+};
+/** §7.2 — walk the segment headers of an embedded (PDF) JBIG2 stream. */
+function parseSegments(data) {
+	const r = new Reader(data);
+	const out = [];
+	while (r.pos + 11 <= data.length) {
+		const number = r.u32();
+		const flags = r.u8();
+		const type = flags & 63;
+		const pageSize = (flags & 64) !== 0 ? 4 : 1;
+		let count = r.u8() >> 5;
+		if (count === 7) {
+			r.pos--;
+			count = r.u32() & 536870911;
+			r.pos += Math.ceil((count + 1) / 8);
+		}
+		const refSize = number <= 256 ? 1 : number <= 65536 ? 2 : 4;
+		const referred = [];
+		for (let i = 0; i < count; i++) referred.push(refSize === 1 ? r.u8() : refSize === 2 ? r.u16() : r.u32());
+		const page = pageSize === 1 ? r.u8() : r.u32();
+		const length = r.u32();
+		const start = r.pos;
+		const end = length === 4294967295 ? data.length : Math.min(data.length, start + length);
+		out.push({
+			number,
+			type,
+			referred,
+			page,
+			start,
+			end
+		});
+		if (end <= start && length !== 0) break;
+		r.pos = end;
+		if (length === 4294967295) break;
+	}
+	return out;
+}
+function readRegionInfo(r) {
+	return {
+		width: r.u32(),
+		height: r.u32(),
+		x: r.u32(),
+		y: r.u32(),
+		combOp: r.u8() & 7
+	};
+}
+/** §6.2.5.1 / §8.2 — paint `src` onto `dst` at (x, y) under a composition op. */
+function compose(dst, src, x0, y0, op) {
+	for (let y = 0; y < src.height; y++) {
+		const dy = y0 + y;
+		if (dy < 0 || dy >= dst.height) continue;
+		for (let x = 0; x < src.width; x++) {
+			const dx = x0 + x;
+			if (dx < 0 || dx >= dst.width) continue;
+			const s = src.data[y * src.width + x] ?? 0;
+			const i = dy * dst.width + dx;
+			const d = dst.data[i] ?? 0;
+			dst.data[i] = op === 0 ? d | s : op === 1 ? d & s : op === 2 ? d ^ s : op === 3 ? d ^ s ^ 1 : s;
+		}
+	}
+}
+/**
+* Decode an embedded JBIG2 image.
+*
+* @param data    The `/JBIG2Decode` stream's own segments.
+* @param globals The `/JBIG2Globals` stream's segments, when the image names one.
+* @param width   The image's `/Width`, which the page info may not state.
+* @param height  Its `/Height`.
+* @returns A packed 1-bit-per-pixel bitmap (`rowBytes × height`, bit 1 = black,
+*   MSB first) — the same shape {@link decodeCcitt} returns — or `undefined`
+*   when nothing in the stream could be decoded.
+*/
+function decodeJbig2(data, globals, width, height) {
+	if (width <= 0 || height <= 0 || width > 65536 || height > 65536) return void 0;
+	const page = {
+		width,
+		height,
+		defPixel: 0,
+		defCombOp: 0,
+		striped: false
+	};
+	let canvas = makeBitmap(width, height);
+	const painted = { regions: 0 };
+	const buffers = /* @__PURE__ */ new Map();
+	const symbolsBySegment = /* @__PURE__ */ new Map();
+	const patternsBySegment = /* @__PURE__ */ new Map();
+	const tablesBySegment = /* @__PURE__ */ new Map();
+	const run = (bytes) => {
+		for (const seg of parseSegments(bytes)) {
+			const r = new Reader(bytes.subarray(seg.start, seg.end));
+			try {
+				if (seg.type === 48) {
+					const pw = r.u32();
+					const ph = r.u32();
+					r.u32();
+					r.u32();
+					const flags = r.u8();
+					page.defPixel = flags >> 2 & 1;
+					page.defCombOp = flags >> 3 & 3;
+					page.striped = (r.u16() & 32768) !== 0;
+					if (pw > 0 && pw !== 4294967295 && ph > 0 && ph !== 4294967295) {
+						page.width = Math.min(pw, width);
+						page.height = Math.min(ph, height);
+					}
+					canvas = makeBitmap(width, height, page.defPixel);
+					continue;
+				}
+				if (seg.type === 53) {
+					tablesBySegment.set(seg.number, parseCustomTable(bytes.subarray(seg.start, seg.end)));
+					continue;
+				}
+				if (seg.type === 16) {
+					const flags = r.u8();
+					const mmr = (flags & 1) !== 0;
+					const template = flags >> 1 & 3;
+					const pw = r.u8();
+					const ph = r.u8();
+					const grayMax = r.u32();
+					if (pw <= 0 || ph <= 0 || grayMax > 1e4) continue;
+					patternsBySegment.set(seg.number, decodePatternDictionary(bytes.subarray(seg.start + r.pos, seg.end), mmr, template, pw, ph, grayMax));
+					continue;
+				}
+				if (seg.type === 20 || seg.type === 22 || seg.type === 23) {
+					const info = readRegionInfo(r);
+					const flags = r.u8();
+					const mmr = (flags & 1) !== 0;
+					const template = flags >> 1 & 3;
+					const enableSkip = (flags & 8) !== 0;
+					const combOp = flags >> 4 & 7;
+					const defPixel = flags >> 7 & 1;
+					const gw = r.u32();
+					const gh = r.u32();
+					const gx = r.u32() | 0;
+					const gy = r.u32() | 0;
+					const rx = r.u16();
+					const ry = r.u16();
+					const patterns = seg.referred.flatMap((n) => patternsBySegment.get(n) ?? []);
+					const w = Math.min(info.width, 65536);
+					const h = Math.min(info.height, 65536);
+					if (patterns.length === 0 || w <= 0 || h <= 0) continue;
+					if (gw <= 0 || gh <= 0 || gw * gh > 1 << 24) continue;
+					const bmp = makeBitmap(w, h, defPixel);
+					const pw = patterns[0].width;
+					const ph = patterns[0].height;
+					let skip;
+					if (enableSkip) {
+						skip = makeBitmap(gw, gh);
+						for (let m = 0; m < gh; m++) for (let n = 0; n < gw; n++) {
+							const x = gx + m * ry + n * rx >> 8;
+							const y = gy + m * rx - n * ry >> 8;
+							if (x + pw <= 0 || x >= w || y + ph <= 0 || y >= h) skip.data[m * gw + n] = 1;
+						}
+					}
+					const bits = Math.max(1, Math.ceil(Math.log2(patterns.length)));
+					const gray = decodeGrayScale(void 0, bytes.subarray(seg.start + r.pos, seg.end), mmr, template, [
+						{
+							x: template <= 1 ? 3 : 2,
+							y: -1
+						},
+						{
+							x: -3,
+							y: -1
+						},
+						{
+							x: 2,
+							y: -2
+						},
+						{
+							x: -2,
+							y: -2
+						}
+					], gw, gh, bits, skip);
+					for (let m = 0; m < gh; m++) for (let n = 0; n < gw; n++) {
+						if (skip?.data[m * gw + n] === 1) continue;
+						const level = Math.min(gray[m * gw + n] ?? 0, patterns.length - 1);
+						const x = gx + m * ry + n * rx >> 8;
+						const y = gy + m * rx - n * ry >> 8;
+						compose(bmp, patterns[level], x, y, combOp);
+					}
+					if (seg.type === 20) buffers.set(seg.number, bmp);
+					else {
+						compose(canvas, bmp, info.x, info.y, info.combOp);
+						painted.regions++;
+					}
+					continue;
+				}
+				if (seg.type === 0) {
+					const flags = r.u16();
+					const huff = (flags & 1) !== 0;
+					const refAgg = (flags & 2) !== 0;
+					const template = flags >> 10 & 3;
+					const rTemplate = flags >> 12 & 1;
+					flags & 256;
+					const at = [];
+					if (!huff) {
+						const n = template === 0 ? 4 : 1;
+						for (let i = 0; i < n; i++) at.push({
+							x: r.i8(),
+							y: r.i8()
+						});
+					}
+					const rAt = [];
+					if (refAgg && rTemplate === 0) for (let i = 0; i < 2; i++) rAt.push({
+						x: r.i8(),
+						y: r.i8()
+					});
+					const exportCount = r.u32();
+					const newCount = r.u32();
+					if (newCount > 1e4) continue;
+					const inherited = seg.referred.flatMap((n) => symbolsBySegment.get(n) ?? []);
+					if (huff) {
+						const custom = seg.referred.map((n) => tablesBySegment.get(n)).filter((t) => t !== void 0);
+						let ci = 0;
+						const pick = (sel, choices) => sel === 3 ? custom[ci++] ?? standardTable(choices[0]) : standardTable(choices[sel] ?? choices[0]);
+						const dhSel = flags >> 2 & 3;
+						const dwSel = flags >> 4 & 3;
+						const bmSel = flags >> 6 & 1;
+						const bits = new BitReader(bytes.subarray(seg.start + r.pos, seg.end));
+						symbolsBySegment.set(seg.number, decodeSymbolDictionaryHuff(bits, bytes.subarray(seg.start + r.pos, seg.end), inherited, newCount, exportCount, pick(dhSel, [4, 5]), pick(dwSel, [2, 3]), bmSel === 1 ? custom[ci++] ?? standardTable(1) : standardTable(1)));
+						continue;
+					}
+					symbolsBySegment.set(seg.number, decodeSymbolDictionary(new MQDecoder(bytes.subarray(seg.start + r.pos, seg.end)), inherited, newCount, exportCount, template, at.length > 0 ? at : NOMINAL_AT[template] ?? [], refAgg, rTemplate, rAt.length > 0 ? rAt : NOMINAL_AT_REFINE));
+					continue;
+				}
+				if (seg.type === 4 || seg.type === 6 || seg.type === 7) {
+					const info = readRegionInfo(r);
+					const flags = r.u16();
+					const huff = (flags & 1) !== 0;
+					const refine = (flags & 2) !== 0;
+					const stripsLog = flags >> 2 & 3;
+					const refCorner = flags >> 4 & 3;
+					const transposed = (flags & 64) !== 0;
+					const combOp = flags >> 7 & 3;
+					const defPixel = flags >> 9 & 1;
+					let dsOffset = flags >> 10 & 31;
+					if (dsOffset > 15) dsOffset -= 32;
+					const rTemplate = flags >> 15 & 1;
+					const huffFlags = huff ? r.u16() : 0;
+					const rAt = [];
+					if (refine && rTemplate === 0) for (let i = 0; i < 2; i++) rAt.push({
+						x: r.i8(),
+						y: r.i8()
+					});
+					const instances = r.u32();
+					const symbols = seg.referred.flatMap((n) => symbolsBySegment.get(n) ?? []);
+					if (symbols.length === 0 || instances > 1e5) continue;
+					const w = Math.min(info.width, 65536);
+					const h = Math.min(info.height, 65536);
+					if (w <= 0 || h <= 0) continue;
+					const params = {
+						width: w,
+						height: h,
+						instances,
+						stripT: 0,
+						refCorner,
+						transposed,
+						combOp,
+						defPixel,
+						dsOffset,
+						refine,
+						rTemplate,
+						rAt: rAt.length > 0 ? rAt : NOMINAL_AT_REFINE
+					};
+					const body = bytes.subarray(seg.start + r.pos, seg.end);
+					let bmp;
+					if (huff) {
+						const custom = seg.referred.map((n) => tablesBySegment.get(n)).filter((t) => t !== void 0);
+						let ci = 0;
+						const pick = (sel, choices) => sel === 3 ? custom[ci++] ?? standardTable(choices[0]) : standardTable(choices[sel] ?? choices[0]);
+						const bits = new BitReader(body);
+						bmp = decodeTextRegionHuff(bits, body, symbols, params, stripsLog, {
+							fs: pick(huffFlags & 3, [6, 7]),
+							ds: pick(huffFlags >> 2 & 3, [
+								8,
+								9,
+								10
+							]),
+							dt: pick(huffFlags >> 4 & 3, [
+								11,
+								12,
+								13
+							]),
+							rdw: pick(huffFlags >> 6 & 3, [14, 15]),
+							rdh: pick(huffFlags >> 8 & 3, [14, 15]),
+							rdx: pick(huffFlags >> 10 & 3, [14, 15]),
+							rdy: pick(huffFlags >> 12 & 3, [14, 15]),
+							rsize: (huffFlags >> 14 & 1) === 1 ? custom[ci++] ?? standardTable(1) : standardTable(1),
+							symbolIds: readSymbolIdTable(bits, symbols.length)
+						});
+					} else bmp = decodeTextRegion(new MQDecoder(body), symbols, params, stripsLog);
+					if (seg.type === 4) buffers.set(seg.number, bmp);
+					else {
+						compose(canvas, bmp, info.x, info.y, info.combOp);
+						painted.regions++;
+					}
+					continue;
+				}
+				if (seg.type === 36 || seg.type === 38 || seg.type === 39) {
+					const info = readRegionInfo(r);
+					const flags = r.u8();
+					const mmr = (flags & 1) !== 0;
+					const template = flags >> 1 & 3;
+					const tpgdon = (flags & 8) !== 0;
+					const at = [];
+					if (!mmr) {
+						const n = template === 0 ? 4 : 1;
+						for (let i = 0; i < n; i++) at.push({
+							x: r.i8(),
+							y: r.i8()
+						});
+					}
+					const body = bytes.subarray(seg.start + r.pos, seg.end);
+					const w = Math.min(info.width, 65536);
+					const h = Math.min(info.height === 4294967295 ? height : info.height, 65536);
+					if (w <= 0 || h <= 0) continue;
+					let bmp;
+					if (mmr) {
+						const packed = decodeCcitt(body, {
+							k: -1,
+							columns: w,
+							rows: h,
+							byteAlign: false
+						});
+						if (!packed) continue;
+						bmp = makeBitmap(w, h);
+						const rowBytes = w + 7 >> 3;
+						for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) bmp.data[y * w + x] = packed[y * rowBytes + (x >> 3)] >> 7 - (x & 7) & 1;
+					} else bmp = decodeGenericRegion(new MQDecoder(body), newContexts(65536), w, h, template, at.length > 0 ? at : NOMINAL_AT[template] ?? [], tpgdon);
+					if (seg.type === 36) buffers.set(seg.number, bmp);
+					else {
+						compose(canvas, bmp, info.x, info.y, info.combOp);
+						painted.regions++;
+					}
+					continue;
+				}
+				if (seg.type === 40 || seg.type === 42 || seg.type === 43) {
+					const info = readRegionInfo(r);
+					const flags = r.u8();
+					const template = flags & 1;
+					const tpgron = (flags & 2) !== 0;
+					const at = [];
+					if (template === 0) for (let i = 0; i < 2; i++) at.push({
+						x: r.i8(),
+						y: r.i8()
+					});
+					const w = Math.min(info.width, 65536);
+					const h = Math.min(info.height, 65536);
+					if (w <= 0 || h <= 0) continue;
+					let ref = seg.referred.map((n) => buffers.get(n)).find((b) => b !== void 0);
+					if (!ref) {
+						const crop = makeBitmap(w, h);
+						for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+							const sx = info.x + x;
+							const sy = info.y + y;
+							crop.data[y * w + x] = sx < canvas.width && sy < canvas.height ? canvas.data[sy * canvas.width + sx] ?? 0 : 0;
+						}
+						ref = crop;
+					}
+					const bmp = decodeRefinement(new MQDecoder(bytes.subarray(seg.start + r.pos, seg.end)), newContexts(8192), w, h, template, ref, 0, 0, at.length > 0 ? at : NOMINAL_AT_REFINE, tpgron);
+					if (seg.type === 40) buffers.set(seg.number, bmp);
+					else {
+						compose(canvas, bmp, info.x, info.y, info.combOp);
+						painted.regions++;
+					}
+					continue;
+				}
+			} catch {
+				continue;
+			}
+		}
+	};
+	if (globals) run(globals);
+	run(data);
+	if (painted.regions === 0) return void 0;
+	const rowBytes = width + 7 >> 3;
+	const packed = new Uint8Array(rowBytes * height);
+	for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) if (canvas.data[y * width + x] === 1) packed[y * rowBytes + (x >> 3)] |= 128 >> (x & 7);
+	return packed;
+}
+//#endregion
+export { decodeJbig2 };