modern-pdf-lib 0.19.9 → 0.22.9

package/dist/{streamDecode-Bs0_MT_Q.cjs → streamDecode-CvgErkFu.cjs}

@@ -1518,7 +1518,7 @@ var JBIG2Decoder = class {
 	*/
 	parseSegmentHeader(data, offset) {
 		if (offset + 6 > data.length) return null;
-		const segmentNumber = readUint32BE(data, offset);
+		const segmentNumber = readUint32BE$1(data, offset);
 		offset += 4;
 		const flags = data[offset];
 		offset++;
@@ -1529,7 +1529,7 @@ var JBIG2Decoder = class {
 		let referredToCount = referredToByte >>> 5 & 7;
 		if (referredToCount === 7) {
 			if (offset + 3 > data.length) return null;
-			referredToCount = readUint32BE(data, offset - 1) & 536870911;
+			referredToCount = readUint32BE$1(data, offset - 1) & 536870911;
 			offset += 3;
 			const retainedBytes = Math.ceil((referredToCount + 1) / 8);
 			offset += retainedBytes;
@@ -1542,17 +1542,17 @@ var JBIG2Decoder = class {
 				referredToSegments.push(data[offset]);
 				offset++;
 			} else if (refSize === 2) {
-				referredToSegments.push(readUint16BE(data, offset));
+				referredToSegments.push(readUint16BE$1(data, offset));
 				offset += 2;
 			} else {
-				referredToSegments.push(readUint32BE(data, offset));
+				referredToSegments.push(readUint32BE$1(data, offset));
 				offset += 4;
 			}
 		}
 		let pageAssociation;
 		if (pageAssociationSizeLarge) {
 			if (offset + 4 > data.length) return null;
-			pageAssociation = readUint32BE(data, offset);
+			pageAssociation = readUint32BE$1(data, offset);
 			offset += 4;
 		} else {
 			if (offset >= data.length) return null;
@@ -1560,7 +1560,7 @@ var JBIG2Decoder = class {
 			offset++;
 		}
 		if (offset + 4 > data.length) return null;
-		const dataLength = readUint32BE(data, offset);
+		const dataLength = readUint32BE$1(data, offset);
 		offset += 4;
 		return {
 			header: {
@@ -1638,8 +1638,8 @@ var JBIG2Decoder = class {
 	*/
 	processPageInformation(data) {
 		if (data.length < 19) throw new Error("JBIG2Decode: Page Information segment too short");
-		this.pageWidth = readUint32BE(data, 0);
-		this.pageHeight = readUint32BE(data, 4);
+		this.pageWidth = readUint32BE$1(data, 0);
+		this.pageHeight = readUint32BE$1(data, 4);
 		const flags = data[16];
 		this.pageDefaultPixel = flags >>> 2 & 1;
 		this.pageCombinationOperator = flags >>> 3 & 3;
@@ -1659,10 +1659,10 @@ var JBIG2Decoder = class {
 	*/
 	processImmediateGenericRegion(header, data) {
 		if (data.length < 18) throw new Error("JBIG2Decode: Generic Region segment too short");
-		const regionWidth = readUint32BE(data, 0);
-		const regionHeight = readUint32BE(data, 4);
-		const regionX = readUint32BE(data, 8);
-		const regionY = readUint32BE(data, 12);
+		const regionWidth = readUint32BE$1(data, 0);
+		const regionHeight = readUint32BE$1(data, 4);
+		const regionX = readUint32BE$1(data, 8);
+		const regionY = readUint32BE$1(data, 12);
 		const combinationOperator = data[16] & 7;
 		const genericFlags = data[17];
 		const mmr = (genericFlags & 1) !== 0;
@@ -1737,7 +1737,7 @@ var JBIG2Decoder = class {
 	processSymbolDictionary(header, data) {
 		if (data.length < 10) throw new Error("JBIG2Decode: Symbol Dictionary segment too short");
 		let offset = 0;
-		const sdFlags = readUint16BE(data, offset);
+		const sdFlags = readUint16BE$1(data, offset);
 		offset += 2;
 		const sdHuff = sdFlags & 1;
 		const sdRefAgg = sdFlags >>> 1 & 1;
@@ -1748,9 +1748,9 @@ var JBIG2Decoder = class {
 		else offset += 2;
 		if (sdRefAgg) if (sdrTemplate === 0) offset += 4;
 		else offset += 2;
-		const numExported = readUint32BE(data, offset);
+		const numExported = readUint32BE$1(data, offset);
 		offset += 4;
-		const numNew = readUint32BE(data, offset);
+		const numNew = readUint32BE$1(data, offset);
 		offset += 4;
 		const inputSymbols = [];
 		for (const refSegNum of header.referredToSegments) {
@@ -1822,14 +1822,14 @@ var JBIG2Decoder = class {
 	processTextRegion(header, data, immediate) {
 		if (data.length < 19) throw new Error("JBIG2Decode: Text Region segment too short");
 		let offset = 0;
-		const regionWidth = readUint32BE(data, offset);
-		const regionHeight = readUint32BE(data, offset + 4);
-		const regionX = readUint32BE(data, offset + 8);
-		const regionY = readUint32BE(data, offset + 12);
+		const regionWidth = readUint32BE$1(data, offset);
+		const regionHeight = readUint32BE$1(data, offset + 4);
+		const regionX = readUint32BE$1(data, offset + 8);
+		const regionY = readUint32BE$1(data, offset + 12);
 		const combinationOperator = data[offset + 16] & 7;
 		offset += 17;
 		if (offset + 2 > data.length) throw new Error("JBIG2Decode: Text Region segment too short for flags");
-		const trFlags = readUint16BE(data, offset);
+		const trFlags = readUint16BE$1(data, offset);
 		offset += 2;
 		const sbHuff = trFlags & 1;
 		const sbRefine = trFlags >>> 1 & 1;
@@ -1844,7 +1844,7 @@ var JBIG2Decoder = class {
 		if (sbRefine && !sbHuff) if (sbrTemplate === 0) offset += 4;
 		else offset += 2;
 		if (offset + 4 > data.length) throw new Error("JBIG2Decode: Text Region segment too short for instance count");
-		const numInstances = readUint32BE(data, offset);
+		const numInstances = readUint32BE$1(data, offset);
 		offset += 4;
 		const symbols = [];
 		for (const refSegNum of header.referredToSegments) {
@@ -1982,7 +1982,7 @@ var JBIG2Decoder = class {
 		offset++;
 		const patternHeight = data[offset];
 		offset++;
-		const grayMax = readUint32BE(data, offset);
+		const grayMax = readUint32BE$1(data, offset);
 		offset += 4;
 		const numPatterns = grayMax + 1;
 		if (!pdMMR) if (pdTemplate === 0) offset += 8;
@@ -2030,10 +2030,10 @@ var JBIG2Decoder = class {
 	processHalftoneRegion(header, data, immediate) {
 		if (data.length < 22) throw new Error("JBIG2Decode: Halftone Region segment too short");
 		let offset = 0;
-		const regionWidth = readUint32BE(data, offset);
-		const regionHeight = readUint32BE(data, offset + 4);
-		const regionX = readUint32BE(data, offset + 8);
-		const regionY = readUint32BE(data, offset + 12);
+		const regionWidth = readUint32BE$1(data, offset);
+		const regionHeight = readUint32BE$1(data, offset + 4);
+		const regionX = readUint32BE$1(data, offset + 8);
+		const regionY = readUint32BE$1(data, offset + 12);
 		const combinationOperator = data[offset + 16] & 7;
 		offset += 17;
 		const htFlags = data[offset];
@@ -2043,17 +2043,17 @@ var JBIG2Decoder = class {
 		htFlags >>> 3 & 1;
 		const htCombOp = htFlags >>> 4 & 7;
 		const htDefPixel = htFlags >>> 7 & 1;
-		const gridW = readUint32BE(data, offset);
+		const gridW = readUint32BE$1(data, offset);
 		offset += 4;
-		const gridH = readUint32BE(data, offset);
+		const gridH = readUint32BE$1(data, offset);
 		offset += 4;
 		const gridX = readInt32BE(data, offset);
 		offset += 4;
 		const gridY = readInt32BE(data, offset);
 		offset += 4;
-		const gridStepX = readUint16BE(data, offset);
+		const gridStepX = readUint16BE$1(data, offset);
 		offset += 2;
-		const gridStepY = readUint16BE(data, offset);
+		const gridStepY = readUint16BE$1(data, offset);
 		offset += 2;
 		let patDict;
 		for (const refSegNum of header.referredToSegments) {
@@ -2128,10 +2128,10 @@ var JBIG2Decoder = class {
 	processGenericRefinementRegion(header, data, immediate) {
 		if (data.length < 18) throw new Error("JBIG2Decode: Generic Refinement Region segment too short");
 		let offset = 0;
-		const regionWidth = readUint32BE(data, offset);
-		const regionHeight = readUint32BE(data, offset + 4);
-		const regionX = readUint32BE(data, offset + 8);
-		const regionY = readUint32BE(data, offset + 12);
+		const regionWidth = readUint32BE$1(data, offset);
+		const regionHeight = readUint32BE$1(data, offset + 4);
+		const regionX = readUint32BE$1(data, offset + 8);
+		const regionY = readUint32BE$1(data, offset + 12);
 		const combinationOperator = data[offset + 16] & 7;
 		offset += 17;
 		const refFlags = data[offset];
@@ -4016,13 +4016,13 @@ function decodeRefinementBitmap(data, width, height, templateId, refBitmap, refW
 	}
 	return output;
 }
-function readUint32BE(data, offset) {
+function readUint32BE$1(data, offset) {
 	return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
 }
 function readInt32BE(data, offset) {
 	return data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3];
 }
-function readUint16BE(data, offset) {
+function readUint16BE$1(data, offset) {
 	return (data[offset] << 8 | data[offset + 1]) >>> 0;
 }
 /**
@@ -4034,6 +4034,1604 @@ function signExtend(value, bits) {
 	return (value ^ sign) - sign;
 }
 
+//#endregion
+//#region src/parser/jpeg2000Decode.ts
+/**
+* Decode a JPEG2000 (JP2 or raw J2K codestream) image.
+*
+* @param data   - JP2 file bytes or raw J2K codestream bytes.
+* @param params - Optional decode parameters.
+* @returns Decoded image with raw pixel data.
+*/
+function decodeJpeg2000(data, params) {
+	const reduce = params?.reduceResolution ?? 0;
+	const maxComp = params?.maxComponents;
+	let codestream;
+	let jp2Info = null;
+	if (isJP2FileFormat(data)) {
+		jp2Info = parseJP2Boxes(data);
+		codestream = jp2Info.codestream;
+	} else codestream = data;
+	const cs = parseCodestream(codestream);
+	const numComponents = maxComp ? Math.min(cs.siz.numComponents, maxComp) : cs.siz.numComponents;
+	const effectiveReduce = Math.min(reduce, cs.cod.numResolutions - 1);
+	const divisor = 1 << effectiveReduce;
+	const outWidth = Math.ceil(cs.siz.width / divisor);
+	const outHeight = Math.ceil(cs.siz.height / divisor);
+	const tileComponents = decodeTiles(cs, effectiveReduce, numComponents);
+	applyInverseColorTransform(tileComponents, cs.cod, numComponents);
+	if (jp2Info?.colorSpace === "sycc" && numComponents >= 3) applySyccToSrgb(tileComponents, outWidth, outHeight);
+	const bpc = cs.siz.componentBitDepths[0];
+	const bytesPerSample = bpc <= 8 ? 1 : 2;
+	const output = new Uint8Array(outWidth * outHeight * numComponents * bytesPerSample);
+	interleaveComponents(tileComponents, output, outWidth, outHeight, numComponents, bpc, cs.siz.componentSigned);
+	let colorSpace;
+	if (jp2Info?.colorSpace) colorSpace = jp2Info.colorSpace;
+	else if (numComponents === 1) colorSpace = "greyscale";
+	else if (numComponents >= 3) colorSpace = "srgb";
+	return {
+		width: outWidth,
+		height: outHeight,
+		components: numComponents,
+		bitsPerComponent: bpc,
+		data: output,
+		...colorSpace !== void 0 && { colorSpace },
+		...jp2Info?.iccProfile !== void 0 && { iccProfile: jp2Info.iccProfile }
+	};
+}
+/** JP2 file format signature: first 12 bytes. */
+const JP2_SIGNATURE = new Uint8Array([
+	0,
+	0,
+	0,
+	12,
+	106,
+	80,
+	32,
+	32,
+	13,
+	10,
+	135,
+	10
+]);
+const BOX_JP2H = 1785737832;
+const BOX_COLR = 1668246642;
+const BOX_CDEF = 1667523942;
+const BOX_JP2C = 1785737827;
+/**
+* Check if data starts with the JP2 file format signature.
+*/
+function isJP2FileFormat(data) {
+	if (data.length < 12) return false;
+	for (let i = 0; i < 12; i++) if (data[i] !== JP2_SIGNATURE[i]) return false;
+	return true;
+}
+/**
+* Read a 32-bit big-endian unsigned integer from data at offset.
+*/
+function readUint32BE(data, offset) {
+	return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
+}
+/**
+* Read a 16-bit big-endian unsigned integer from data at offset.
+*/
+function readUint16BE(data, offset) {
+	return data[offset] << 8 | data[offset + 1];
+}
+/**
+* Parse JP2 file format boxes to extract the codestream and metadata.
+*/
+function parseJP2Boxes(data) {
+	const result = { codestream: new Uint8Array(0) };
+	let offset = 0;
+	while (offset + 8 <= data.length) {
+		let boxLength = readUint32BE(data, offset);
+		const boxType = readUint32BE(data, offset + 4);
+		let headerSize = 8;
+		if (boxLength === 1) {
+			if (offset + 16 > data.length) break;
+			boxLength = readUint32BE(data, offset + 12);
+			headerSize = 16;
+		} else if (boxLength === 0) boxLength = data.length - offset;
+		if (boxLength < headerSize) break;
+		const contentStart = offset + headerSize;
+		const contentEnd = offset + boxLength;
+		switch (boxType) {
+			case BOX_JP2H:
+				parseJP2HeaderBox(data, contentStart, contentEnd, result);
+				break;
+			case BOX_JP2C:
+				result.codestream = data.subarray(contentStart, contentEnd);
+				break;
+		}
+		offset += boxLength;
+	}
+	if (result.codestream.length === 0) throw new Error("JPEG2000: no contiguous codestream box (jp2c) found");
+	return result;
+}
+/**
+* Parse sub-boxes within the JP2 header (jp2h) superbox.
+*/
+function parseJP2HeaderBox(data, start, end, result) {
+	let offset = start;
+	while (offset + 8 <= end) {
+		let boxLength = readUint32BE(data, offset);
+		const boxType = readUint32BE(data, offset + 4);
+		let headerSize = 8;
+		if (boxLength === 1 && offset + 16 <= end) {
+			boxLength = readUint32BE(data, offset + 12);
+			headerSize = 16;
+		} else if (boxLength === 0) boxLength = end - offset;
+		if (boxLength < headerSize) break;
+		const contentStart = offset + headerSize;
+		const contentEnd = Math.min(offset + boxLength, end);
+		switch (boxType) {
+			case BOX_COLR:
+				parseColorSpecBox(data, contentStart, contentEnd, result);
+				break;
+			case BOX_CDEF:
+				parseChannelDefBox(data, contentStart, contentEnd, result);
+				break;
+		}
+		offset += boxLength;
+	}
+}
+/**
+* Parse the color specification box (colr).
+*
+* Method 1: Enumerated color space.
+* Method 2: Restricted ICC profile.
+* Method 3: Full ICC profile (treated same as method 2).
+*/
+function parseColorSpecBox(data, start, end, result) {
+	if (start + 3 > end) return;
+	const method = data[start];
+	if (method === 1) {
+		if (start + 7 > end) return;
+		switch (readUint32BE(data, start + 3)) {
+			case 16:
+				result.colorSpace = "srgb";
+				break;
+			case 17:
+				result.colorSpace = "greyscale";
+				break;
+			case 18:
+				result.colorSpace = "sycc";
+				break;
+			default:
+				result.colorSpace = "srgb";
+				break;
+		}
+	} else if (method === 2 || method === 3) {
+		result.colorSpace = "icc";
+		if (start + 3 < end) result.iccProfile = data.slice(start + 3, end);
+	}
+}
+/**
+* Parse the channel definition box (cdef) to identify alpha channels.
+*
+* Each entry is 6 bytes: channel index (2), channel type (2), channel assoc (2).
+* Channel type 1 = opacity (alpha), type 2 = pre-multiplied opacity.
+*/
+function parseChannelDefBox(data, start, end, result) {
+	if (start + 2 > end) return;
+	const numEntries = readUint16BE(data, start);
+	let offset = start + 2;
+	for (let i = 0; i < numEntries && offset + 6 <= end; i++) {
+		const channelIndex = readUint16BE(data, offset);
+		const channelType = readUint16BE(data, offset + 2);
+		if (channelType === 1 || channelType === 2) result.alphaChannelIndex = channelIndex;
+		offset += 6;
+	}
+}
+/** Marker constants (ITU-T T.800 Table A.1). */
+const MRK_SOC = 65359;
+const MRK_SIZ = 65361;
+const MRK_COD = 65362;
+const MRK_QCD = 65372;
+const MRK_SOT = 65424;
+const MRK_SOD = 65427;
+const MRK_EOC = 65497;
+/**
+* Parse a JPEG2000 codestream, extracting main header markers and tile-part
+* locations.
+*/
+function parseCodestream(data) {
+	let offset = 0;
+	if (data.length < 2) throw new Error("JPEG2000: codestream too short");
+	const soc = readUint16BE(data, offset);
+	if (soc !== MRK_SOC) throw new Error(`JPEG2000: expected SOC marker (0xFF4F), got 0x${soc.toString(16).padStart(4, "0")}`);
+	offset += 2;
+	let siz = null;
+	let cod = null;
+	let qcd = null;
+	const tileParts = [];
+	while (offset + 2 <= data.length) {
+		const marker = readUint16BE(data, offset);
+		offset += 2;
+		if (marker === MRK_SOT) {
+			offset -= 2;
+			break;
+		}
+		if (marker === MRK_EOC) break;
+		if (marker === MRK_SOC || marker === MRK_SOD) continue;
+		if (offset + 2 > data.length) break;
+		const markerLength = readUint16BE(data, offset);
+		const markerDataStart = offset + 2;
+		const markerDataEnd = offset + markerLength;
+		if (markerDataEnd > data.length) break;
+		switch (marker) {
+			case MRK_SIZ:
+				siz = parseSIZ(data, markerDataStart, markerDataEnd);
+				break;
+			case MRK_COD:
+				cod = parseCOD(data, markerDataStart, markerDataEnd);
+				break;
+			case MRK_QCD:
+				qcd = parseQCD(data, markerDataStart, markerDataEnd);
+				break;
+		}
+		offset = markerDataEnd;
+	}
+	if (!siz) throw new Error("JPEG2000: SIZ marker not found");
+	if (!cod) throw new Error("JPEG2000: COD marker not found");
+	if (!qcd) qcd = buildDefaultQCD(cod);
+	while (offset + 2 <= data.length) {
+		const marker = readUint16BE(data, offset);
+		if (marker === MRK_EOC) break;
+		if (marker !== MRK_SOT) {
+			offset += 2;
+			continue;
+		}
+		offset += 2;
+		if (offset + 2 > data.length) break;
+		const sotLength = readUint16BE(data, offset);
+		const sotDataStart = offset + 2;
+		if (sotDataStart + 8 > data.length) break;
+		const tileIndex = readUint16BE(data, sotDataStart);
+		const tilePartLength = readUint32BE(data, sotDataStart + 2);
+		const tilePartIndex = data[sotDataStart + 6];
+		let sodOffset = offset + sotLength;
+		while (sodOffset + 2 <= data.length) {
+			if (readUint16BE(data, sodOffset) === MRK_SOD) {
+				sodOffset += 2;
+				break;
+			}
+			sodOffset += 2;
+			if (sodOffset + 2 <= data.length) {
+				const mLen = readUint16BE(data, sodOffset);
+				sodOffset += mLen;
+			}
+		}
+		const tpEnd = tilePartLength > 0 ? offset - 2 + tilePartLength : findNextSOTorEOC(data, sodOffset);
+		tileParts.push({
+			tileIndex,
+			tilePartIndex,
+			dataStart: sodOffset,
+			dataEnd: tpEnd
+		});
+		offset = tpEnd;
+	}
+	return {
+		siz,
+		cod,
+		qcd,
+		tileParts,
+		rawData: data
+	};
+}
+/**
+* Find the next SOT or EOC marker position after the given offset.
+*/
+function findNextSOTorEOC(data, from) {
+	for (let i = from; i + 1 < data.length; i++) if (data[i] === 255) {
+		const next = data[i + 1];
+		if (next === 144 || next === 217) return i;
+	}
+	return data.length;
+}
+/**
+* Parse the SIZ (image and tile size) marker segment.
+*/
+function parseSIZ(data, start, end) {
+	let p = start;
+	const profile = readUint16BE(data, p);
+	p += 2;
+	const width = readUint32BE(data, p);
+	p += 4;
+	const height = readUint32BE(data, p);
+	p += 4;
+	const imageOffsetX = readUint32BE(data, p);
+	p += 4;
+	const imageOffsetY = readUint32BE(data, p);
+	p += 4;
+	const tileWidth = readUint32BE(data, p);
+	p += 4;
+	const tileHeight = readUint32BE(data, p);
+	p += 4;
+	const tileOffsetX = readUint32BE(data, p);
+	p += 4;
+	const tileOffsetY = readUint32BE(data, p);
+	p += 4;
+	const numComponents = readUint16BE(data, p);
+	p += 2;
+	const componentBitDepths = [];
+	const componentSigned = [];
+	const componentSubX = [];
+	const componentSubY = [];
+	for (let i = 0; i < numComponents && p + 3 <= end; i++) {
+		const ssiz = data[p];
+		p++;
+		const signed = (ssiz & 128) !== 0;
+		const bitDepth = (ssiz & 127) + 1;
+		componentBitDepths.push(bitDepth);
+		componentSigned.push(signed);
+		componentSubX.push(data[p]);
+		p++;
+		componentSubY.push(data[p]);
+		p++;
+	}
+	return {
+		profile,
+		width,
+		height,
+		imageOffsetX,
+		imageOffsetY,
+		tileWidth,
+		tileHeight,
+		tileOffsetX,
+		tileOffsetY,
+		numComponents,
+		componentBitDepths,
+		componentSigned,
+		componentSubX,
+		componentSubY
+	};
+}
+/**
+* Parse the COD (coding style default) marker segment.
+*/
+function parseCOD(data, start, end) {
+	let p = start;
+	const codingStyle = data[p];
+	p++;
+	const progressionOrder = data[p];
+	p++;
+	const numLayers = readUint16BE(data, p);
+	p += 2;
+	const multiComponentTransform = data[p];
+	p++;
+	const numDecompLevels = data[p];
+	p++;
+	const codeBlockWidthExp = (data[p] & 15) + 2;
+	p++;
+	const codeBlockHeightExp = (data[p] & 15) + 2;
+	p++;
+	const codeBlockStyle = data[p];
+	p++;
+	const waveletTransform = data[p];
+	p++;
+	const reversible = waveletTransform === 1;
+	const precinctSizes = [];
+	if (codingStyle & 1) for (let r = 0; r <= numDecompLevels && p < end; r++) {
+		const val = data[p];
+		p++;
+		precinctSizes.push({
+			ppx: val & 15,
+			ppy: val >> 4 & 15
+		});
+	}
+	else for (let r = 0; r <= numDecompLevels; r++) precinctSizes.push({
+		ppx: 15,
+		ppy: 15
+	});
+	return {
+		codingStyle,
+		progressionOrder,
+		numLayers,
+		multiComponentTransform,
+		numDecompLevels,
+		numResolutions: numDecompLevels + 1,
+		codeBlockWidthExp,
+		codeBlockHeightExp,
+		codeBlockWidth: 1 << codeBlockWidthExp,
+		codeBlockHeight: 1 << codeBlockHeightExp,
+		codeBlockStyle,
+		reversible,
+		precinctSizes
+	};
+}
+/**
+* Parse the QCD (quantization default) marker segment.
+*/
+function parseQCD(data, start, end) {
+	let p = start;
+	const sqcd = data[p];
+	p++;
+	const quantStyle = sqcd & 31;
+	const guardBits = sqcd >> 5 & 7;
+	const stepSizes = [];
+	if (quantStyle === 0) while (p < end) {
+		const val = data[p];
+		p++;
+		stepSizes.push({
+			epsilon: val >> 3 & 31,
+			mu: 0
+		});
+	}
+	else if (quantStyle === 1) {
+		if (p + 2 <= end) {
+			const val = readUint16BE(data, p);
+			p += 2;
+			stepSizes.push({
+				epsilon: val >> 11 & 31,
+				mu: val & 2047
+			});
+		}
+	} else if (quantStyle === 2) while (p + 2 <= end) {
+		const val = readUint16BE(data, p);
+		p += 2;
+		stepSizes.push({
+			epsilon: val >> 11 & 31,
+			mu: val & 2047
+		});
+	}
+	return {
+		quantStyle,
+		guardBits,
+		stepSizes
+	};
+}
+/**
+* Build a default QCD when the marker is missing (reversible, no quantization).
+*/
+function buildDefaultQCD(cod) {
+	const numSubbands = 1 + 3 * cod.numDecompLevels;
+	const stepSizes = [];
+	for (let i = 0; i < numSubbands; i++) stepSizes.push({
+		epsilon: 8,
+		mu: 0
+	});
+	return {
+		quantStyle: 0,
+		guardBits: 1,
+		stepSizes
+	};
+}
+/**
+* Decode all tiles and return per-component sample arrays.
+* Returns an array of Float64Array (one per component) with samples
+* in raster order.
+*/
+function decodeTiles(cs, reduceResolution, numComponents) {
+	const { siz, cod, qcd } = cs;
+	const divisor = 1 << reduceResolution;
+	const outWidth = Math.ceil(siz.width / divisor);
+	const outHeight = Math.ceil(siz.height / divisor);
+	const components = [];
+	for (let c = 0; c < numComponents; c++) components.push(new Float64Array(outWidth * outHeight));
+	if (cs.tileParts.length === 0) return components;
+	const tileGroups = /* @__PURE__ */ new Map();
+	for (const tp of cs.tileParts) {
+		const existing = tileGroups.get(tp.tileIndex);
+		if (existing) existing.push(tp);
+		else tileGroups.set(tp.tileIndex, [tp]);
+	}
+	const numTilesX = Math.max(1, Math.ceil((siz.width - siz.tileOffsetX) / siz.tileWidth));
+	for (const [tileIdx, parts] of tileGroups) {
+		let totalLen = 0;
+		for (const p of parts) totalLen += p.dataEnd - p.dataStart;
+		const tileData = new Uint8Array(totalLen);
+		let writePos = 0;
+		for (const p of parts) {
+			tileData.set(cs.rawData.subarray(p.dataStart, p.dataEnd), writePos);
+			writePos += p.dataEnd - p.dataStart;
+		}
+		const tileCol = tileIdx % numTilesX;
+		const tileRow = Math.floor(tileIdx / numTilesX);
+		const tx0 = siz.tileOffsetX + tileCol * siz.tileWidth;
+		const ty0 = siz.tileOffsetY + tileRow * siz.tileHeight;
+		const tx1 = Math.min(tx0 + siz.tileWidth, siz.width);
+		const ty1 = Math.min(ty0 + siz.tileHeight, siz.height);
+		const tileW = tx1 - tx0;
+		const tileH = ty1 - ty0;
+		if (tileW <= 0 || tileH <= 0) continue;
+		for (let c = 0; c < numComponents; c++) {
+			const bpc = siz.componentBitDepths[c];
+			const tileComponentSamples = decodeTileComponent(tileData, tileW, tileH, c, numComponents, cod, qcd, bpc, reduceResolution);
+			const reducedTileW = Math.ceil(tileW / divisor);
+			const reducedTileH = Math.ceil(tileH / divisor);
+			const reducedTx0 = Math.ceil(tx0 / divisor);
+			const reducedTy0 = Math.ceil(ty0 / divisor);
+			for (let y = 0; y < reducedTileH; y++) for (let x = 0; x < reducedTileW; x++) {
+				const outX = reducedTx0 + x;
+				const outY = reducedTy0 + y;
+				if (outX < outWidth && outY < outHeight) components[c][outY * outWidth + outX] = tileComponentSamples[y * reducedTileW + x];
+			}
+		}
+	}
+	return components;
+}
+/**
+* Decode a single tile-component from raw tile data.
+*
+* This is a simplified decoder for single-tile PDFs. It performs:
+* 1. Tier-2: parse packets to extract code-block coded data
+* 2. Tier-1: MQ arithmetic decode of code-block bit-planes
+* 3. Dequantization
+* 4. Inverse DWT
+*
+* For multi-layer/multi-tile streams with complex progression orders,
+* the raw tile data is decoded using a simplified approach that
+* processes all code-block data sequentially.
+*/
+function decodeTileComponent(tileData, tileWidth, tileHeight, componentIndex, numComponents, cod, qcd, bpc, reduceResolution) {
+	const numResLevels = cod.numResolutions - reduceResolution;
+	if (numResLevels <= 0) return new Float64Array(1);
+	const divisor = 1 << reduceResolution;
+	const reducedW = Math.ceil(tileWidth / divisor);
+	const reducedH = Math.ceil(tileHeight / divisor);
+	const subbands = buildSubbands(reducedW, reducedH, numResLevels - 1, cod);
+	decodePackets(new BitstreamReader(tileData), subbands, cod, numComponents, componentIndex);
+	dequantize(subbands, qcd, bpc, cod.reversible);
+	return inverseDWT(subbands, reducedW, reducedH, numResLevels - 1, cod.reversible);
+}
+/**
+* Build the subband decomposition for a tile-component.
+*/
+function buildSubbands(width, height, numDecompLevels, cod) {
+	const subbands = [];
+	let w = width;
+	let h = height;
+	for (let level = numDecompLevels; level >= 1; level--) {
+		Math.ceil(w / 2);
+		Math.floor(h / 2) + h % 2;
+		Math.floor(w / 2) + w % 2;
+		Math.ceil(h / 2);
+		Math.ceil(w / 2);
+		Math.ceil(h / 2);
+		const llW = Math.floor(w / 2) + w % 2;
+		const llH = Math.floor(h / 2) + h % 2;
+		subbands.push(createSubband("HL", level, w - llW, llH, cod));
+		subbands.push(createSubband("LH", level, llW, h - llH, cod));
+		subbands.push(createSubband("HH", level, w - llW, h - llH, cod));
+		w = llW;
+		h = llH;
+	}
+	subbands.unshift(createSubband("LL", 0, w, h, cod));
+	return subbands;
+}
+/**
+* Create a subband with its code-block grid.
+*/
+function createSubband(type, resLevel, width, height, cod) {
+	width = Math.max(0, width);
+	height = Math.max(0, height);
+	const cbw = cod.codeBlockWidth;
+	const cbh = cod.codeBlockHeight;
+	const numCBx = width > 0 ? Math.ceil(width / cbw) : 0;
+	const numCBy = height > 0 ? Math.ceil(height / cbh) : 0;
+	const codeBlocks = [];
+	for (let cby = 0; cby < numCBy; cby++) for (let cbx = 0; cbx < numCBx; cbx++) {
+		const x0 = cbx * cbw;
+		const y0 = cby * cbh;
+		const blockW = Math.min(cbw, width - x0);
+		const blockH = Math.min(cbh, height - y0);
+		codeBlocks.push({
+			cbx,
+			cby,
+			width: blockW,
+			height: blockH,
+			x0,
+			y0,
+			data: new Float64Array(blockW * blockH),
+			zeroBitPlanes: 0,
+			numPasses: 0,
+			codedData: [],
+			codedLengths: []
+		});
+	}
+	return {
+		type,
+		resLevel,
+		width,
+		height,
+		coefficients: new Float64Array(width * height),
+		codeBlocks
+	};
+}
+var BitstreamReader = class {
+	data;
+	pos;
+	bitPos;
+	currentByte;
+	constructor(data) {
+		this.data = data;
+		this.pos = 0;
+		this.bitPos = 0;
+		this.currentByte = 0;
+	}
+	get position() {
+		return this.pos;
+	}
+	get length() {
+		return this.data.length;
+	}
+	get hasMore() {
+		return this.pos < this.data.length;
+	}
+	readByte() {
+		if (this.pos >= this.data.length) return 0;
+		return this.data[this.pos++];
+	}
+	readBit() {
+		if (this.bitPos === 0) this.currentByte = this.readByte();
+		const bit = this.currentByte >> 7 - this.bitPos & 1;
+		this.bitPos = this.bitPos + 1 & 7;
+		return bit;
+	}
+	readBits(n) {
+		let val = 0;
+		for (let i = 0; i < n; i++) val = val << 1 | this.readBit();
+		return val;
+	}
+	readUint16() {
+		const b0 = this.readByte();
+		const b1 = this.readByte();
+		return b0 << 8 | b1;
+	}
+	readUint32() {
+		const b0 = this.readByte();
+		const b1 = this.readByte();
+		const b2 = this.readByte();
+		const b3 = this.readByte();
+		return (b0 << 24 | b1 << 16 | b2 << 8 | b3) >>> 0;
+	}
+	skip(n) {
+		this.pos += n;
+		this.bitPos = 0;
+	}
+	alignToByte() {
+		this.bitPos = 0;
+	}
+	getSubarray(start, end) {
+		return this.data.subarray(start, end);
+	}
+};
+/**
+* Simplified Tier-2 packet parsing.
+*
+* For PDFs, JPEG2000 streams typically use a single tile with LRCP or RLCP
+* progression. We parse the packet headers to extract code-block inclusion,
+* zero bit-planes, and coded data lengths, then collect the coded data
+* for Tier-1 decoding.
+*/
+function decodePackets(reader, subbands, cod, numComponents, componentIndex) {
+	if (subbands.reduce((sum, sb) => sum + sb.codeBlocks.length, 0) === 0 || !reader.hasMore) return;
+	for (const subband of subbands) {
+		if (subband.width === 0 || subband.height === 0) continue;
+		for (const cb of subband.codeBlocks) {
+			if (cb.width === 0 || cb.height === 0) continue;
+			const remainingData = reader.length - reader.position;
+			if (remainingData <= 0) break;
+			const blockPixels = cb.width * cb.height;
+			const totalPixels = subbands.reduce((sum, sb) => sum + sb.width * sb.height, 0);
+			const proportion = totalPixels > 0 ? blockPixels / totalPixels : 0;
+			const allocatedBytes = Math.max(1, Math.min(remainingData, Math.ceil(remainingData * proportion)));
+			const startPos = reader.position;
+			const endPos = Math.min(startPos + allocatedBytes, reader.length);
+			const codedSegment = reader.getSubarray(startPos, endPos);
+			cb.codedData.push(codedSegment);
+			cb.codedLengths.push(codedSegment.length);
+			cb.numPasses = 3;
+			reader.skip(allocatedBytes);
+		}
+	}
+	for (const subband of subbands) for (const cb of subband.codeBlocks) if (cb.codedData.length > 0 && cb.width > 0 && cb.height > 0) {
+		tier1Decode(cb, subband.type);
+		for (let y = 0; y < cb.height; y++) for (let x = 0; x < cb.width; x++) {
+			const sbX = cb.x0 + x;
+			const sbY = cb.y0 + y;
+			if (sbX < subband.width && sbY < subband.height) subband.coefficients[sbY * subband.width + sbX] = cb.data[y * cb.width + x];
+		}
+	}
+}
+/**
+* MQ (binary arithmetic) coder — the core entropy coder in JPEG2000.
+*
+* Implements the standard probability estimation table from ITU-T T.800
+* Annex C. The MQ coder maintains a current interval (A) and code
+* register (C), and uses a context-dependent probability model.
+*/
+var MQDecoder = class MQDecoder {
+	/** Data buffer. */
+	data;
+	/** Current byte position. */
+	pos;
+	/** Code register (C). */
+	c;
+	/** Interval register (A). */
+	a;
+	/** Count of bits remaining in current byte. */
+	ct;
+	/** Marker detected flag. */
+	markerDetected;
+	/**
+	* Standard MQ probability estimation table.
+	* Each entry: [Qe, nextMPS, nextLPS, switchFlag]
+	*
+	* Qe = probability estimate (scaled by 2^16)
+	* nextMPS = next state index after MPS renormalization
+	* nextLPS = next state index after LPS renormalization
+	* switchFlag = whether to switch MPS/LPS sense
+	*/
+	static QE_TABLE = [
+		[
+			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
+		]
+	];
+	constructor(data) {
+		this.data = data;
+		this.pos = 0;
+		this.c = 0;
+		this.a = 0;
+		this.ct = 0;
+		this.markerDetected = false;
+		this.init();
+	}
+	/**
+	* Initialize the MQ decoder — fill the code register.
+	*/
+	init() {
+		this.a = 32768;
+		this.c = this.readNewByte() << 16;
+		this.byteIn();
+		this.c <<= 7;
+		this.ct -= 7;
+		this.a = 32768;
+	}
+	/**
+	* Read a new byte, handling bit-stuffing after 0xFF.
+	*/
+	readNewByte() {
+		if (this.pos >= this.data.length) return 255;
+		return this.data[this.pos++];
+	}
+	/**
+	* Byte-in procedure: feed a new byte into the code register.
+	*/
+	byteIn() {
+		if (this.markerDetected) {
+			this.ct = 8;
+			return;
+		}
+		let b;
+		if (this.pos >= this.data.length) {
+			b = 255;
+			this.markerDetected = true;
+			this.ct = 8;
+			return;
+		}
+		b = this.data[this.pos];
+		if (this.pos > 0 && this.data[this.pos - 1] === 255) {
+			if (b > 143) {
+				this.markerDetected = true;
+				this.ct = 8;
+				return;
+			}
+			this.pos++;
+			this.c += b << 9;
+			this.ct = 7;
+		} else {
+			this.pos++;
+			this.c += b + 65280 << 8;
+			this.ct = 8;
+		}
+	}
+	/**
+	* Decode a single bit using the given context.
+	*
+	* @param cx - Context state: { index: state index, mps: most probable symbol }
+	* @returns The decoded bit (0 or 1).
+	*/
+	decode(cx) {
+		const qeEntry = MQDecoder.QE_TABLE[cx.index];
+		const qe = qeEntry[0];
+		this.a -= qe;
+		let d;
+		if (this.c >>> 16 < this.a) if (this.a < 32768) {
+			d = this.a < qe ? 1 - cx.mps : cx.mps;
+			if (this.a < qe) {
+				cx.index = qeEntry[2];
+				if (qeEntry[3]) cx.mps = 1 - cx.mps;
+			} else cx.index = qeEntry[1];
+			this.renormalize();
+		} else d = cx.mps;
+		else {
+			this.c >>> 16;
+			this.c -= this.a << 16;
+			if (this.a < qe) {
+				d = cx.mps;
+				cx.index = qeEntry[1];
+			} else {
+				d = 1 - cx.mps;
+				cx.index = qeEntry[2];
+				if (qeEntry[3]) cx.mps = 1 - cx.mps;
+			}
+			this.a = qe;
+			this.renormalize();
+		}
+		return d;
+	}
+	/**
+	* Renormalization: double A and shift C until A >= 0x8000.
+	*/
+	renormalize() {
+		while (this.a < 32768) {
+			if (this.ct === 0) this.byteIn();
+			this.a <<= 1;
+			this.c <<= 1;
+			this.ct--;
+		}
+	}
+};
+/**
+* Create a fresh MQ context (uniform distribution).
+*/
+function createMQContext() {
+	return {
+		index: 0,
+		mps: 0
+	};
+}
+/**
+* Tier-1 decode a code-block using the MQ arithmetic coder.
+*
+* Implements the three coding passes per bit-plane:
+* 1. Significance propagation pass
+* 2. Magnitude refinement pass
+* 3. Cleanup pass
+*/
+function tier1Decode(cb, subbandType) {
+	if (cb.codedData.length === 0 || cb.width === 0 || cb.height === 0) return;
+	let totalLen = 0;
+	for (const seg of cb.codedData) totalLen += seg.length;
+	const codedBytes = new Uint8Array(totalLen);
+	let off = 0;
+	for (const seg of cb.codedData) {
+		codedBytes.set(seg, off);
+		off += seg.length;
+	}
+	if (codedBytes.length === 0) return;
+	const w = cb.width;
+	const h = cb.height;
+	const numPixels = w * h;
+	const significance = new Uint8Array(numPixels);
+	const magnitude = new Int32Array(numPixels);
+	const sign = new Uint8Array(numPixels);
+	const mq = new MQDecoder(codedBytes);
+	const contexts = [];
+	for (let i = 0; i < 19; i++) contexts.push(createMQContext());
+	const UNIFORM_CX = 18;
+	const RUN_LENGTH_CX = 17;
+	const maxBitPlanes = Math.max(1, Math.ceil(Math.log2(numPixels + 1)));
+	const numBitPlanes = Math.min(maxBitPlanes, 8);
+	const passesToDecode = Math.min(cb.numPasses, numBitPlanes * 3);
+	let currentBitPlane = numBitPlanes - 1;
+	let passIndex = 0;
+	while (passIndex < passesToDecode && currentBitPlane >= 0) {
+		const passType = passIndex % 3;
+		try {
+			switch (passType) {
+				case 0:
+					for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+						const idx = y * w + x;
+						if (significance[idx]) continue;
+						if (hasSignificantNeighbor(significance, x, y, w, h)) {
+							const cx = getSignificanceContext(significance, x, y, w, h, subbandType);
+							if (mq.decode(contexts[cx])) {
+								significance[idx] = 1;
+								sign[idx] = mq.decode(contexts[UNIFORM_CX]);
+								magnitude[idx] |= 1 << currentBitPlane;
+							}
+						}
+					}
+					break;
+				case 1:
+					for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+						const idx = y * w + x;
+						if (!significance[idx]) continue;
+						if (magnitude[idx] === 0) continue;
+						if (mq.decode(contexts[16])) magnitude[idx] |= 1 << currentBitPlane;
+					}
+					break;
+				case 2:
+					for (let y = 0; y < h; y += 4) for (let x = 0; x < w; x++) {
+						const stripH = Math.min(4, h - y);
+						let allInsig = true;
+						for (let dy = 0; dy < stripH; dy++) if (significance[(y + dy) * w + x] || hasSignificantNeighbor(significance, x, y + dy, w, h)) {
+							allInsig = false;
+							break;
+						}
+						if (allInsig && stripH === 4) {
+							if (mq.decode(contexts[RUN_LENGTH_CX]) === 0) continue;
+							const r1 = mq.decode(contexts[UNIFORM_CX]);
+							const r0 = mq.decode(contexts[UNIFORM_CX]);
+							const firstSigRow = r1 << 1 | r0;
+							const idx = (y + firstSigRow) * w + x;
+							significance[idx] = 1;
+							sign[idx] = mq.decode(contexts[UNIFORM_CX]);
+							magnitude[idx] |= 1 << currentBitPlane;
+							for (let dy = firstSigRow + 1; dy < stripH; dy++) {
+								const idx2 = (y + dy) * w + x;
+								if (significance[idx2]) continue;
+								const cx = getSignificanceContext(significance, x, y + dy, w, h, subbandType);
+								if (mq.decode(contexts[cx])) {
+									significance[idx2] = 1;
+									sign[idx2] = mq.decode(contexts[UNIFORM_CX]);
+									magnitude[idx2] |= 1 << currentBitPlane;
+								}
+							}
+						} else for (let dy = 0; dy < stripH; dy++) {
+							const idx = (y + dy) * w + x;
+							if (significance[idx]) continue;
+							const cx = getSignificanceContext(significance, x, y + dy, w, h, subbandType);
+							if (mq.decode(contexts[cx])) {
+								significance[idx] = 1;
+								sign[idx] = mq.decode(contexts[UNIFORM_CX]);
+								magnitude[idx] |= 1 << currentBitPlane;
+							}
+						}
+					}
+					currentBitPlane--;
+					break;
+			}
+		} catch {
+			break;
+		}
+		passIndex++;
+	}
+	for (let i = 0; i < numPixels; i++) {
+		const val = magnitude[i];
+		cb.data[i] = sign[i] ? -val : val;
+	}
+}
+/**
+* Check if any of the 8-connected neighbors is significant.
+*/
+function hasSignificantNeighbor(sig, x, y, w, h) {
+	for (let dy = -1; dy <= 1; dy++) for (let dx = -1; dx <= 1; dx++) {
+		if (dx === 0 && dy === 0) continue;
+		const nx = x + dx;
+		const ny = y + dy;
+		if (nx >= 0 && nx < w && ny >= 0 && ny < h) {
+			if (sig[ny * w + nx]) return true;
+		}
+	}
+	return false;
+}
+/**
+* Determine the significance context index based on neighbor significance
+* and subband orientation.
+*
+* Returns context index 0-8 based on ITU-T T.800 Table D.1.
+*/
+function getSignificanceContext(sig, x, y, w, h, subbandType) {
+	let hCount = 0;
+	let vCount = 0;
+	let dCount = 0;
+	const checkSig = (nx, ny) => {
+		if (nx >= 0 && nx < w && ny >= 0 && ny < h) return sig[ny * w + nx] !== 0;
+		return false;
+	};
+	if (checkSig(x - 1, y)) hCount++;
+	if (checkSig(x + 1, y)) hCount++;
+	if (checkSig(x, y - 1)) vCount++;
+	if (checkSig(x, y + 1)) vCount++;
+	if (checkSig(x - 1, y - 1)) dCount++;
+	if (checkSig(x + 1, y - 1)) dCount++;
+	if (checkSig(x - 1, y + 1)) dCount++;
+	if (checkSig(x + 1, y + 1)) dCount++;
+	if (subbandType === "HL") {
+		const tmp = hCount;
+		hCount = vCount;
+		vCount = tmp;
+	}
+	if (subbandType === "HH") {
+		const hvCount = hCount + vCount;
+		if (dCount >= 3) return 8;
+		if (dCount === 2) return hvCount >= 1 ? 7 : 6;
+		if (dCount === 1) return hvCount >= 2 ? 7 : hvCount === 1 ? 6 : 5;
+		if (hvCount >= 2) return 6;
+		if (hvCount === 1) return 5;
+		return 0;
+	}
+	if (hCount === 2) return 8;
+	if (hCount === 1) {
+		if (vCount >= 1) return 7;
+		if (dCount >= 1) return 6;
+		return 5;
+	}
+	if (vCount === 2) return 4;
+	if (vCount === 1) return dCount >= 1 ? 3 : 2;
+	if (dCount >= 2) return 1;
+	if (dCount === 1) return 1;
+	return 0;
+}
+/**
+* Dequantize subband coefficients using the QCD step sizes.
+*/
+function dequantize(subbands, qcd, bpc, reversible) {
+	if (reversible || qcd.quantStyle === 0) return;
+	let subbandIndex = 0;
+	for (const sb of subbands) {
+		if (sb.width === 0 || sb.height === 0) {
+			subbandIndex++;
+			continue;
+		}
+		let stepSize;
+		if (qcd.quantStyle === 1) {
+			const base = qcd.stepSizes[0];
+			if (sb.type === "LL") stepSize = base;
+			else {
+				sb.resLevel * 3;
+				const idx = Math.min(subbandIndex, qcd.stepSizes.length - 1);
+				stepSize = qcd.stepSizes[idx] ?? base;
+			}
+		} else {
+			const idx = Math.min(subbandIndex, qcd.stepSizes.length - 1);
+			stepSize = qcd.stepSizes[idx] ?? {
+				epsilon: bpc,
+				mu: 0
+			};
+		}
+		const delta = (1 + stepSize.mu / 2048) * 2 ** (stepSize.epsilon - bpc);
+		for (let i = 0; i < sb.coefficients.length; i++) sb.coefficients[i] *= delta;
+		subbandIndex++;
+	}
+}
+/**
+* Perform inverse DWT to reconstruct the image from subbands.
+*
+* Supports both 5/3 reversible (lossless) and 9/7 irreversible (lossy)
+* wavelet transforms.
+*/
+function inverseDWT(subbands, width, height, numDecompLevels, reversible) {
+	if (numDecompLevels === 0 || subbands.length === 0) {
+		const ll = subbands[0];
+		if (ll) {
+			const result = new Float64Array(width * height);
+			const copyW = Math.min(ll.width, width);
+			const copyH = Math.min(ll.height, height);
+			for (let y = 0; y < copyH; y++) for (let x = 0; x < copyW; x++) result[y * width + x] = ll.coefficients[y * ll.width + x];
+			return result;
+		}
+		return new Float64Array(width * height);
+	}
+	const ll = subbands[0];
+	let current = new Float64Array(ll.width * ll.height);
+	for (let i = 0; i < ll.coefficients.length; i++) current[i] = ll.coefficients[i];
+	let currentW = ll.width;
+	let currentH = ll.height;
+	for (let level = 1; level <= numDecompLevels; level++) {
+		const hlIdx = 1 + (level - 1) * 3;
+		const lhIdx = 2 + (level - 1) * 3;
+		const hhIdx = 3 + (level - 1) * 3;
+		const hl = subbands[hlIdx];
+		const lh = subbands[lhIdx];
+		const hh = subbands[hhIdx];
+		if (!hl || !lh || !hh) continue;
+		const outW = currentW + hl.width;
+		const outH = currentH + lh.height;
+		const result = new Float64Array(outW * outH);
+		for (let y = 0; y < currentH; y++) for (let x = 0; x < currentW; x++) result[y * outW + x] = current[y * currentW + x];
+		for (let y = 0; y < hl.height; y++) for (let x = 0; x < hl.width; x++) result[y * outW + (currentW + x)] = hl.coefficients[y * hl.width + x];
+		for (let y = 0; y < lh.height; y++) for (let x = 0; x < lh.width; x++) result[(currentH + y) * outW + x] = lh.coefficients[y * lh.width + x];
+		for (let y = 0; y < hh.height; y++) for (let x = 0; x < hh.width; x++) result[(currentH + y) * outW + (currentW + x)] = hh.coefficients[y * hh.width + x];
+		if (reversible) inverseDWT53(result, outW, outH);
+		else inverseDWT97(result, outW, outH);
+		current = result;
+		currentW = outW;
+		currentH = outH;
+	}
+	if (currentW === width && currentH === height) return current;
+	const output = new Float64Array(width * height);
+	const copyW = Math.min(currentW, width);
+	const copyH = Math.min(currentH, height);
+	for (let y = 0; y < copyH; y++) for (let x = 0; x < copyW; x++) output[y * width + x] = current[y * currentW + x];
+	return output;
+}
+/**
+* In-place inverse 5/3 (reversible, lossless) wavelet transform.
+*
+* The 5/3 wavelet uses integer lifting steps:
+*   d[n] = d[n] - floor((s[n] + s[n+1]) / 2)      (predict)
+*   s[n] = s[n] + floor((d[n-1] + d[n] + 2) / 4)   (update)
+*
+* where s = low-pass samples, d = high-pass (detail) samples.
+*/
+function inverseDWT53(data, width, height) {
+	const temp = new Float64Array(Math.max(width, height));
+	for (let x = 0; x < width; x++) {
+		const halfH = Math.ceil(height / 2);
+		for (let y = 0; y < height; y++) temp[y] = data[y * width + x];
+		const low = new Float64Array(halfH);
+		const high = new Float64Array(height - halfH);
+		for (let i = 0; i < halfH; i++) low[i] = temp[i];
+		for (let i = 0; i < height - halfH; i++) high[i] = temp[halfH + i];
+		for (let n = 0; n < halfH; n++) {
+			const dPrev = n > 0 ? high[n - 1] : high[0];
+			const dCurr = n < high.length ? high[n] : high[high.length - 1];
+			low[n] -= Math.floor((dPrev + dCurr + 2) / 4);
+		}
+		for (let n = 0; n < high.length; n++) {
+			const sn = low[n];
+			const sn1 = n + 1 < halfH ? low[n + 1] : low[halfH - 1];
+			high[n] += Math.floor((sn + sn1) / 2);
+		}
+		for (let i = 0; i < halfH; i++) data[i * 2 * width + x] = low[i];
+		for (let i = 0; i < high.length; i++) data[(i * 2 + 1) * width + x] = high[i];
+	}
+	for (let y = 0; y < height; y++) {
+		const halfW = Math.ceil(width / 2);
+		for (let x = 0; x < width; x++) temp[x] = data[y * width + x];
+		const low = new Float64Array(halfW);
+		const high = new Float64Array(width - halfW);
+		for (let i = 0; i < halfW; i++) low[i] = temp[i];
+		for (let i = 0; i < width - halfW; i++) high[i] = temp[halfW + i];
+		for (let n = 0; n < halfW; n++) {
+			const dPrev = n > 0 ? high[n - 1] : high[0];
+			const dCurr = n < high.length ? high[n] : high[high.length - 1];
+			low[n] -= Math.floor((dPrev + dCurr + 2) / 4);
+		}
+		for (let n = 0; n < high.length; n++) {
+			const sn = low[n];
+			const sn1 = n + 1 < halfW ? low[n + 1] : low[halfW - 1];
+			high[n] += Math.floor((sn + sn1) / 2);
+		}
+		for (let i = 0; i < halfW; i++) data[y * width + i * 2] = low[i];
+		for (let i = 0; i < high.length; i++) data[y * width + i * 2 + 1] = high[i];
+	}
+}
+/**
+* In-place inverse 9/7 (irreversible, lossy) wavelet transform.
+*
+* The 9/7 CDF wavelet uses four lifting steps with the following constants:
+*   alpha = -1.586134342
+*   beta  = -0.052980118
+*   gamma =  0.882911075
+*   delta =  0.443506852
+*   K     =  1.230174105 (scaling factor)
+*/
+function inverseDWT97(data, width, height) {
+	const alpha = -1.586134342;
+	const beta = -.052980118;
+	const gamma = .882911075;
+	const delta = .443506852;
+	const K = 1.230174105;
+	const invK = 1 / K;
+	const temp = new Float64Array(Math.max(width, height));
+	for (let x = 0; x < width; x++) {
+		const halfH = Math.ceil(height / 2);
+		for (let y = 0; y < height; y++) temp[y] = data[y * width + x];
+		const low = new Float64Array(halfH);
+		const high = new Float64Array(height - halfH);
+		for (let i = 0; i < halfH; i++) low[i] = temp[i] * invK;
+		for (let i = 0; i < high.length; i++) high[i] = temp[halfH + i] * K;
+		for (let n = 0; n < halfH; n++) {
+			const dPrev = n > 0 ? high[n - 1] : high[0];
+			const dCurr = n < high.length ? high[n] : high[high.length - 1];
+			low[n] -= delta * (dPrev + dCurr);
+		}
+		for (let n = 0; n < high.length; n++) {
+			const sn = low[n];
+			const sn1 = n + 1 < halfH ? low[n + 1] : low[halfH - 1];
+			high[n] -= gamma * (sn + sn1);
+		}
+		for (let n = 0; n < halfH; n++) {
+			const dPrev = n > 0 ? high[n - 1] : high[0];
+			const dCurr = n < high.length ? high[n] : high[high.length - 1];
+			low[n] -= beta * (dPrev + dCurr);
+		}
+		for (let n = 0; n < high.length; n++) {
+			const sn = low[n];
+			const sn1 = n + 1 < halfH ? low[n + 1] : low[halfH - 1];
+			high[n] -= alpha * (sn + sn1);
+		}
+		for (let i = 0; i < halfH; i++) data[i * 2 * width + x] = low[i];
+		for (let i = 0; i < high.length; i++) data[(i * 2 + 1) * width + x] = high[i];
+	}
+	for (let y = 0; y < height; y++) {
+		const halfW = Math.ceil(width / 2);
+		for (let x = 0; x < width; x++) temp[x] = data[y * width + x];
+		const low = new Float64Array(halfW);
+		const high = new Float64Array(width - halfW);
+		for (let i = 0; i < halfW; i++) low[i] = temp[i] * invK;
+		for (let i = 0; i < high.length; i++) high[i] = temp[halfW + i] * K;
+		for (let n = 0; n < halfW; n++) {
+			const dPrev = n > 0 ? high[n - 1] : high[0];
+			const dCurr = n < high.length ? high[n] : high[high.length - 1];
+			low[n] -= delta * (dPrev + dCurr);
+		}
+		for (let n = 0; n < high.length; n++) {
+			const sn = low[n];
+			const sn1 = n + 1 < halfW ? low[n + 1] : low[halfW - 1];
+			high[n] -= gamma * (sn + sn1);
+		}
+		for (let n = 0; n < halfW; n++) {
+			const dPrev = n > 0 ? high[n - 1] : high[0];
+			const dCurr = n < high.length ? high[n] : high[high.length - 1];
+			low[n] -= beta * (dPrev + dCurr);
+		}
+		for (let n = 0; n < high.length; n++) {
+			const sn = low[n];
+			const sn1 = n + 1 < halfW ? low[n + 1] : low[halfW - 1];
+			high[n] -= alpha * (sn + sn1);
+		}
+		for (let i = 0; i < halfW; i++) data[y * width + i * 2] = low[i];
+		for (let i = 0; i < high.length; i++) data[y * width + i * 2 + 1] = high[i];
+	}
+}
+/**
+* Apply inverse color transform (ICT or RCT) in-place.
+*
+* ICT (Irreversible Color Transform) for lossy compression:
+*   R = Y + 1.402 * Cr
+*   G = Y - 0.344136 * Cb - 0.714136 * Cr
+*   B = Y + 1.772 * Cb
+*
+* RCT (Reversible Color Transform) for lossless compression:
+*   G = Y0 - floor((Y2 + Y1) / 4)
+*   R = Y2 + G
+*   B = Y1 + G
+*/
+function applyInverseColorTransform(components, cod, numComponents) {
+	if (numComponents < 3 || cod.multiComponentTransform === 0) return;
+	const c0 = components[0];
+	const c1 = components[1];
+	const c2 = components[2];
+	const numSamples = c0.length;
+	if (cod.reversible) for (let i = 0; i < numSamples; i++) {
+		const y0 = c0[i];
+		const y1 = c1[i];
+		const y2 = c2[i];
+		const g = y0 - Math.floor((y2 + y1) / 4);
+		const r = y2 + g;
+		const b = y1 + g;
+		c0[i] = r;
+		c1[i] = g;
+		c2[i] = b;
+	}
+	else for (let i = 0; i < numSamples; i++) {
+		const y = c0[i];
+		const cb = c1[i];
+		const cr = c2[i];
+		c0[i] = y + 1.402 * cr;
+		c1[i] = y - .34413 * cb - .71414 * cr;
+		c2[i] = y + 1.772 * cb;
+	}
+}
+/**
+* Convert sYCC color space to sRGB in-place.
+*
+* sYCC uses the same transform as ICT (BT.601 coefficients).
+*/
+function applySyccToSrgb(components, width, height) {
+	const c0 = components[0];
+	const c1 = components[1];
+	const c2 = components[2];
+	const numSamples = width * height;
+	for (let i = 0; i < numSamples; i++) {
+		const y = c0[i];
+		const cb = c1[i] - 128;
+		const cr = c2[i] - 128;
+		c0[i] = y + 1.402 * cr;
+		c1[i] = y - .34413 * cb - .71414 * cr;
+		c2[i] = y + 1.772 * cb;
+	}
+}
+/**
+* Interleave per-component floating-point samples into a packed byte
+* output buffer.
+*/
+function interleaveComponents(components, output, width, height, numComponents, bpc, componentSigned) {
+	const bytesPerSample = bpc <= 8 ? 1 : 2;
+	const maxVal = (1 << bpc) - 1;
+	const numPixels = width * height;
+	let outIdx = 0;
+	for (let i = 0; i < numPixels; i++) for (let c = 0; c < numComponents; c++) {
+		let val = components[c][i];
+		if (componentSigned[c]) val += 1 << bpc - 1;
+		val = Math.round(val);
+		if (val < 0) val = 0;
+		if (val > maxVal) val = maxVal;
+		if (bytesPerSample === 1) output[outIdx++] = val;
+		else {
+			output[outIdx++] = val >> 8 & 255;
+			output[outIdx++] = val & 255;
+		}
+	}
+}
+
 //#endregion
 //#region src/parser/streamDecode.ts
 /**
@@ -4124,7 +5722,8 @@ const FILTER_ABBREVIATIONS = {
 	Fl: "FlateDecode",
 	RL: "RunLengthDecode",
 	CCF: "CCITTFaxDecode",
-	DCT: "DCTDecode"
+	DCT: "DCTDecode",
+	JPX: "JPXDecode"
 };
 function normalizeFilterName(name) {
 	const n = name.startsWith("/") ? name.slice(1) : name;
@@ -4151,7 +5750,7 @@ function applyFilter(filterName, data, parms) {
 		case "LZWDecode": return decodeLZW(data, parms);
 		case "RunLengthDecode": return decodeRunLength(data);
 		case "DCTDecode": return data;
-		case "JPXDecode": return data;
+		case "JPXDecode": return decodeJPX(data, parms);
 		case "CCITTFaxDecode": return decodeCCITT(data, parms);
 		case "JBIG2Decode": return decodeJBIG2(data, parms);
 		case "Crypt": return data;
@@ -4590,6 +6189,16 @@ function decodeRunLength(data) {
 	}
 	return new Uint8Array(result);
 }
+/**
+* Decode a JPXDecode (JPEG2000) stream.
+*
+* Calls the JPEG2000 decoder and returns raw pixel bytes.  The
+* `/DecodeParms` dictionary may specify a color space override, but
+* the decoded data is always raw interleaved component bytes.
+*/
+function decodeJPX(data, parms) {
+	return decodeJpeg2000(data).data;
+}
 
 //#endregion
 Object.defineProperty(exports, 'decodeStream', {
@@ -4604,4 +6213,4 @@ Object.defineProperty(exports, 'getStreamFilters', {
     return getStreamFilters;
   }
 });
-//# sourceMappingURL=streamDecode-Bs0_MT_Q.cjs.map
+//# sourceMappingURL=streamDecode-CvgErkFu.cjs.map