pdf-codec 1.6.0 → 1.8.0

package/dist/image/jpeg2000-codestream.js

@@ -0,0 +1,308 @@
+import { Jpeg2000ParseError, Jpeg2000UnsupportedError } from "./jpeg2000-errors.js";
+//#region src/image/jpeg2000-codestream.ts
+const MARKER_SOC = 65359;
+const MARKER_SIZ = 65361;
+const MARKER_COD = 65362;
+const MARKER_COC = 65363;
+const MARKER_QCD = 65372;
+const MARKER_QCC = 65373;
+const MARKER_RGN = 65374;
+const MARKER_POC = 65375;
+const MARKER_PPM = 65376;
+const MARKER_PPT = 65377;
+const MARKER_COM = 65380;
+const MARKER_SOT = 65424;
+const MARKER_SOD = 65427;
+const MARKER_EOC = 65497;
+const PROGRESSION_ORDERS = [
+	"LRCP",
+	"RLCP",
+	"RPCL",
+	"PCRL",
+	"CPRL"
+];
+var MarkerCursor = class {
+	data;
+	position;
+	constructor(data, start = 0) {
+		this.data = data;
+		this.position = start;
+	}
+	get remaining() {
+		return this.data.length - this.position;
+	}
+	uint8() {
+		const value = this.data[this.position];
+		if (value === void 0) throw new Jpeg2000ParseError("JPEG 2000 codestream ended in the middle of a marker segment");
+		this.position++;
+		return value;
+	}
+	uint16() {
+		return this.uint8() << 8 | this.uint8();
+	}
+	uint32() {
+		return this.uint16() * 65536 + this.uint16();
+	}
+	bytes(length) {
+		if (length < 0 || this.position + length > this.data.length) throw new Jpeg2000ParseError("a JPEG 2000 marker segment declares more data than the codestream carries");
+		const slice = this.data.subarray(this.position, this.position + length);
+		this.position += length;
+		return slice;
+	}
+};
+function readImageSize(cursor, segmentEnd) {
+	cursor.uint16();
+	const xsiz = cursor.uint32();
+	const ysiz = cursor.uint32();
+	const xosiz = cursor.uint32();
+	const yosiz = cursor.uint32();
+	const xtsiz = cursor.uint32();
+	const ytsiz = cursor.uint32();
+	const xtosiz = cursor.uint32();
+	const ytosiz = cursor.uint32();
+	const count = cursor.uint16();
+	if (count === 0) throw new Jpeg2000ParseError("SIZ declares zero components");
+	if (cursor.position + count * 3 > segmentEnd) throw new Jpeg2000ParseError(`SIZ declares ${String(count)} components but its own length leaves room for fewer`);
+	const components = [];
+	for (let i = 0; i < count; i++) {
+		const ssiz = cursor.uint8();
+		components.push({
+			signed: (ssiz & 128) !== 0,
+			bitDepth: (ssiz & 127) + 1,
+			dx: cursor.uint8(),
+			dy: cursor.uint8()
+		});
+	}
+	if (xsiz <= xosiz || ysiz <= yosiz) throw new Jpeg2000ParseError("SIZ declares an image with no area (Xsiz/Ysiz do not exceed XOsiz/YOsiz)");
+	if (xtsiz === 0 || ytsiz === 0) throw new Jpeg2000ParseError("SIZ declares a zero-sized tile");
+	return {
+		xsiz,
+		ysiz,
+		xosiz,
+		yosiz,
+		xtsiz,
+		ytsiz,
+		xtosiz,
+		ytosiz,
+		components
+	};
+}
+const DEFAULT_PRECINCT_EXPONENT = 15;
+function readCodingStyleParameters(cursor, explicitPrecincts) {
+	const decompositionLevels = cursor.uint8();
+	const codeBlockWidthExp = (cursor.uint8() & 15) + 2;
+	const codeBlockHeightExp = (cursor.uint8() & 15) + 2;
+	const codeBlockStyle = cursor.uint8();
+	const transformCode = cursor.uint8();
+	if (transformCode !== 0 && transformCode !== 1) throw new Jpeg2000ParseError(`SPcod/SPcoc declares transformation ${String(transformCode)}, which is neither of the two ISO/IEC 15444-1 defines`);
+	if (codeBlockWidthExp > 10 || codeBlockHeightExp > 10 || codeBlockWidthExp + codeBlockHeightExp > 12) throw new Jpeg2000ParseError(`code-block size 2^${String(codeBlockWidthExp)} by 2^${String(codeBlockHeightExp)} is outside the range ISO/IEC 15444-1 Table A.18 permits`);
+	const precinctSizes = [];
+	if (explicitPrecincts) for (let r = 0; r <= decompositionLevels; r++) {
+		const packed = cursor.uint8();
+		precinctSizes.push({
+			ppx: packed & 15,
+			ppy: packed >> 4 & 15
+		});
+	}
+	else for (let r = 0; r <= decompositionLevels; r++) precinctSizes.push({
+		ppx: DEFAULT_PRECINCT_EXPONENT,
+		ppy: DEFAULT_PRECINCT_EXPONENT
+	});
+	return {
+		decompositionLevels,
+		codeBlockWidthExp,
+		codeBlockHeightExp,
+		codeBlockStyle,
+		transform: transformCode === 1 ? "reversible-5-3" : "irreversible-9-7",
+		precinctSizes
+	};
+}
+function readCodingDefaults(cursor) {
+	const scod = cursor.uint8();
+	const progressionOrder = PROGRESSION_ORDERS[cursor.uint8()];
+	if (progressionOrder === void 0) throw new Jpeg2000ParseError("COD declares a progression order outside the five ISO/IEC 15444-1 Table A.16 defines");
+	const layers = cursor.uint16();
+	if (layers === 0) throw new Jpeg2000ParseError("COD declares zero quality layers");
+	const multipleComponentTransform = cursor.uint8() !== 0;
+	return {
+		...readCodingStyleParameters(cursor, (scod & 1) !== 0),
+		progressionOrder,
+		layers,
+		multipleComponentTransform,
+		useSop: (scod & 2) !== 0,
+		useEph: (scod & 4) !== 0
+	};
+}
+function readQuantization(cursor, segmentEnd) {
+	const sq = cursor.uint8();
+	const guardBits = sq >> 5;
+	const styleCode = sq & 31;
+	const stepSizes = [];
+	if (styleCode === 0) {
+		while (cursor.position < segmentEnd) stepSizes.push({
+			exponent: cursor.uint8() >> 3,
+			mantissa: 0
+		});
+		return {
+			style: "none",
+			guardBits,
+			stepSizes
+		};
+	}
+	if (styleCode === 1 || styleCode === 2) {
+		while (cursor.position + 1 < segmentEnd) {
+			const packed = cursor.uint16();
+			stepSizes.push({
+				exponent: packed >> 11,
+				mantissa: packed & 2047
+			});
+		}
+		return {
+			style: styleCode === 1 ? "derived" : "expounded",
+			guardBits,
+			stepSizes
+		};
+	}
+	throw new Jpeg2000ParseError(`QCD/QCC declares quantization style ${String(styleCode)}, which ISO/IEC 15444-1 Table A.28 does not define`);
+}
+function readComponentIndex(cursor, componentCount) {
+	return componentCount < 257 ? cursor.uint8() : cursor.uint16();
+}
+function emptyHeader() {
+	return {
+		coc: /* @__PURE__ */ new Map(),
+		qcc: /* @__PURE__ */ new Map(),
+		hasProgressionChanges: false,
+		hasRegionOfInterest: false,
+		hasPackedPacketHeaders: false
+	};
+}
+function freezeHeader(header) {
+	const base = {
+		coc: header.coc,
+		qcc: header.qcc,
+		hasProgressionChanges: header.hasProgressionChanges,
+		hasRegionOfInterest: header.hasRegionOfInterest,
+		hasPackedPacketHeaders: header.hasPackedPacketHeaders
+	};
+	if (header.cod !== void 0 && header.qcd !== void 0) return {
+		...base,
+		cod: header.cod,
+		qcd: header.qcd
+	};
+	if (header.cod !== void 0) return {
+		...base,
+		cod: header.cod
+	};
+	if (header.qcd !== void 0) return {
+		...base,
+		qcd: header.qcd
+	};
+	return base;
+}
+function readHeaderSegment(marker, cursor, header, componentCount, comments) {
+	const length = cursor.uint16();
+	if (length < 2) throw new Jpeg2000ParseError(`marker segment 0x${marker.toString(16)} declares a length of ${String(length)}, which is shorter than the length field itself`);
+	const segmentEnd = cursor.position + length - 2;
+	if (segmentEnd > cursor.data.length) throw new Jpeg2000ParseError(`marker segment 0x${marker.toString(16)} declares more data than the codestream carries`);
+	if (marker === MARKER_COD) header.cod = readCodingDefaults(cursor);
+	else if (marker === MARKER_COC) {
+		const component = readComponentIndex(cursor, componentCount);
+		header.coc.set(component, readCodingStyleParameters(cursor, (cursor.uint8() & 1) !== 0));
+	} else if (marker === MARKER_QCD) header.qcd = readQuantization(cursor, segmentEnd);
+	else if (marker === MARKER_QCC) {
+		const component = readComponentIndex(cursor, componentCount);
+		header.qcc.set(component, readQuantization(cursor, segmentEnd));
+	} else if (marker === MARKER_POC) header.hasProgressionChanges = true;
+	else if (marker === MARKER_RGN) header.hasRegionOfInterest = true;
+	else if (marker === MARKER_PPT) header.hasPackedPacketHeaders = true;
+	else if (marker === MARKER_COM) {
+		const registration = cursor.uint16();
+		const body = cursor.bytes(segmentEnd - cursor.position);
+		if (registration === 1) comments.push(Array.from(body, (byte) => String.fromCharCode(byte)).join(""));
+	}
+	cursor.position = segmentEnd;
+}
+function validateMainHeader(header) {
+	if (header.cod === void 0) throw new Jpeg2000ParseError("the main header carries no COD marker, so no coding style is defined for any tile");
+	if (header.qcd === void 0) throw new Jpeg2000ParseError("the main header carries no QCD marker, so no quantization is defined for any tile");
+}
+function parseJpeg2000Codestream(data) {
+	const cursor = new MarkerCursor(data);
+	if (cursor.remaining < 4 || cursor.uint16() !== MARKER_SOC) throw new Jpeg2000ParseError("codestream does not begin with an SOC marker");
+	if (cursor.uint16() !== MARKER_SIZ) throw new Jpeg2000ParseError("the SOC marker is not immediately followed by SIZ, which ISO/IEC 15444-1 A.3 requires");
+	const sizLength = cursor.uint16();
+	const sizEnd = cursor.position + sizLength - 2;
+	const siz = readImageSize(cursor, sizEnd);
+	cursor.position = sizEnd;
+	const comments = [];
+	const main = emptyHeader();
+	const tileParts = [];
+	let sawEoc = false;
+	for (;;) {
+		if (cursor.remaining < 2) break;
+		const marker = cursor.uint16();
+		if (marker === MARKER_EOC) {
+			sawEoc = true;
+			break;
+		}
+		if (marker === MARKER_PPM) throw new Jpeg2000UnsupportedError("the codestream carries a PPM marker (packed packet headers in the main header), an organisation this decoder does not reassemble");
+		if (marker === MARKER_SOT) {
+			cursor.position -= 2;
+			readTilePart(cursor, siz.components.length, tileParts, comments);
+			continue;
+		}
+		if (marker === MARKER_SOD || marker === MARKER_SOC) throw new Jpeg2000ParseError(`unexpected marker 0x${marker.toString(16)} in the main header`);
+		readHeaderSegment(marker, cursor, main, siz.components.length, comments);
+	}
+	validateMainHeader(main);
+	const numTilesWide = Math.ceil((siz.xsiz - siz.xtosiz) / siz.xtsiz);
+	const numTilesHigh = Math.ceil((siz.ysiz - siz.ytosiz) / siz.ytsiz);
+	return {
+		bytes: data,
+		siz,
+		main: freezeHeader(main),
+		tileParts,
+		comments,
+		numTilesWide,
+		numTilesHigh,
+		truncated: !sawEoc
+	};
+}
+function readTilePart(cursor, componentCount, tileParts, comments) {
+	const sotStart = cursor.position;
+	cursor.uint16();
+	const lsot = cursor.uint16();
+	if (lsot !== 10) throw new Jpeg2000ParseError(`SOT declares a length of ${String(lsot)}, but ISO/IEC 15444-1 A.4.2 fixes it at 10`);
+	const tileIndex = cursor.uint16();
+	const psot = cursor.uint32();
+	const partIndex = cursor.uint8();
+	cursor.uint8();
+	const header = emptyHeader();
+	for (;;) {
+		if (cursor.remaining < 2) throw new Jpeg2000ParseError("a tile-part header ended without an SOD marker");
+		const marker = cursor.uint16();
+		if (marker === MARKER_SOD) break;
+		if (marker === MARKER_SOT || marker === MARKER_EOC) throw new Jpeg2000ParseError(`a tile-part header ended at marker 0x${marker.toString(16)} rather than at SOD`);
+		readHeaderSegment(marker, cursor, header, componentCount, comments);
+	}
+	const dataStart = cursor.position;
+	const declaredEnd = psot === 0 ? cursor.data.length : sotStart + psot;
+	const dataEnd = Math.min(declaredEnd, cursor.data.length);
+	if (dataEnd < dataStart) throw new Jpeg2000ParseError("a tile-part declares a Psot shorter than its own header");
+	const trimmedEnd = trimTrailingEoc(cursor.data, dataStart, dataEnd);
+	tileParts.push({
+		tileIndex,
+		partIndex,
+		header: freezeHeader(header),
+		dataStart,
+		dataEnd: trimmedEnd
+	});
+	cursor.position = dataEnd;
+}
+function trimTrailingEoc(data, start, end) {
+	if (end - start >= 2 && data[end - 2] === 255 && data[end - 1] === 217) return end - 2;
+	return end;
+}
+//#endregion
+export { parseJpeg2000Codestream };

package/dist/image/jpeg2000-dwt.cjs

@@ -0,0 +1,148 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/image/jpeg2000-dwt.ts
+const EXTENSION_MARGIN = 6;
+const LIFT_ALPHA = -1.586134342059924;
+const LIFT_BETA = -.052980118572961;
+const LIFT_GAMMA = .882911075530934;
+const LIFT_DELTA = .443506852043971;
+const LIFT_K = 1.230174104914001;
+function subbandBounds(bounds) {
+	return {
+		llU0: Math.ceil(bounds.u0 / 2),
+		llU1: Math.ceil(bounds.u1 / 2),
+		llV0: Math.ceil(bounds.v0 / 2),
+		llV1: Math.ceil(bounds.v1 / 2),
+		hU0: Math.floor(bounds.u0 / 2),
+		hU1: Math.floor(bounds.u1 / 2),
+		hV0: Math.floor(bounds.v0 / 2),
+		hV1: Math.floor(bounds.v1 / 2)
+	};
+}
+function mirrorIndex(position, i0, i1) {
+	const length = i1 - i0;
+	if (length <= 1) return i0;
+	const period = 2 * (length - 1);
+	let offset = (position - i0) % period;
+	if (offset < 0) offset += period;
+	return i0 + (offset >= length ? period - offset : offset);
+}
+function interleave(source, bounds, write) {
+	const sub = subbandBounds(bounds);
+	for (let v = sub.llV0; v < sub.llV1; v++) for (let u = sub.llU0; u < sub.llU1; u++) write(2 * u, 2 * v, source.ll(u, v));
+	for (let v = sub.llV0; v < sub.llV1; v++) for (let u = sub.hU0; u < sub.hU1; u++) write(2 * u + 1, 2 * v, source.hl(u, v));
+	for (let v = sub.hV0; v < sub.hV1; v++) for (let u = sub.llU0; u < sub.llU1; u++) write(2 * u, 2 * v + 1, source.lh(u, v));
+	for (let v = sub.hV0; v < sub.hV1; v++) for (let u = sub.hU0; u < sub.hU1; u++) write(2 * u + 1, 2 * v + 1, source.hh(u, v));
+}
+function inverse53Filter(buffer, i0, i1) {
+	const base = EXTENSION_MARGIN - i0;
+	const first = Math.floor(i0 / 2) - 1;
+	const last = Math.floor(i1 / 2) + 1;
+	for (let n = first; n <= last; n++) {
+		const index = base + 2 * n;
+		buffer[index] = (buffer[index] ?? 0) - Math.floor(((buffer[index - 1] ?? 0) + (buffer[index + 1] ?? 0) + 2) / 4);
+	}
+	for (let n = first; n < last; n++) {
+		const index = base + 2 * n + 1;
+		buffer[index] = (buffer[index] ?? 0) + Math.floor(((buffer[index - 1] ?? 0) + (buffer[index + 1] ?? 0)) / 2);
+	}
+}
+function inverse97Filter(buffer, i0, i1) {
+	const base = EXTENSION_MARGIN - i0;
+	const first = Math.floor(i0 / 2);
+	const last = Math.floor(i1 / 2);
+	const even = (n) => base + 2 * n;
+	const odd = (n) => base + 2 * n + 1;
+	for (let n = first - 2; n <= last + 2; n++) {
+		buffer[even(n)] = (buffer[even(n)] ?? 0) * LIFT_K;
+		buffer[odd(n)] = (buffer[odd(n)] ?? 0) / LIFT_K;
+	}
+	for (let n = first - 1; n <= last + 1; n++) buffer[even(n)] = (buffer[even(n)] ?? 0) - LIFT_DELTA * ((buffer[even(n) - 1] ?? 0) + (buffer[even(n) + 1] ?? 0));
+	for (let n = first - 1; n <= last; n++) buffer[odd(n)] = (buffer[odd(n)] ?? 0) - LIFT_GAMMA * ((buffer[odd(n) - 1] ?? 0) + (buffer[odd(n) + 1] ?? 0));
+	for (let n = first; n <= last + 1; n++) buffer[even(n)] = (buffer[even(n)] ?? 0) - LIFT_BETA * ((buffer[even(n) - 1] ?? 0) + (buffer[even(n) + 1] ?? 0));
+	for (let n = first; n <= last; n++) buffer[odd(n)] = (buffer[odd(n)] ?? 0) - LIFT_ALPHA * ((buffer[odd(n) - 1] ?? 0) + (buffer[odd(n) + 1] ?? 0));
+}
+function synthesiseLine(read, write, i0, i1, fillScratch, readScratch, runFilter, singleSampleHighPassGain) {
+	const length = i1 - i0;
+	if (length <= 0) return;
+	if (length === 1) {
+		const value = read(i0);
+		write(i0, i0 % 2 === 0 ? value : singleSampleHighPassGain(value));
+		return;
+	}
+	for (let k = -6; k < length + EXTENSION_MARGIN; k++) fillScratch(EXTENSION_MARGIN + k, read(mirrorIndex(i0 + k, i0, i1)));
+	runFilter();
+	for (let k = 0; k < length; k++) write(i0 + k, readScratch(EXTENSION_MARGIN + k));
+}
+function interleaveSource(bands, bounds) {
+	const sub = subbandBounds(bounds);
+	const llWidth = sub.llU1 - sub.llU0;
+	const hWidth = sub.hU1 - sub.hU0;
+	return {
+		ll: (u, v) => bands.ll[(v - sub.llV0) * llWidth + (u - sub.llU0)] ?? 0,
+		hl: (u, v) => bands.hl[(v - sub.llV0) * hWidth + (u - sub.hU0)] ?? 0,
+		lh: (u, v) => bands.lh[(v - sub.hV0) * llWidth + (u - sub.llU0)] ?? 0,
+		hh: (u, v) => bands.hh[(v - sub.hV0) * hWidth + (u - sub.hU0)] ?? 0
+	};
+}
+function inverseDwt53Level(bands, bounds) {
+	const { u0, u1, v0, v1 } = bounds;
+	const width = u1 - u0;
+	const height = v1 - v0;
+	const output = new Int32Array(Math.max(width * height, 0));
+	if (width <= 0 || height <= 0) return output;
+	interleave(interleaveSource(bands, bounds), bounds, (u, v, value) => {
+		output[(v - v0) * width + (u - u0)] = value;
+	});
+	const scratch = new Int32Array(Math.max(width, height) + 12);
+	for (let v = 0; v < height; v++) {
+		const rowStart = v * width;
+		synthesiseLine((index) => output[rowStart + index - u0] ?? 0, (index, value) => {
+			output[rowStart + index - u0] = value;
+		}, u0, u1, (offset, value) => {
+			scratch[offset] = value;
+		}, (offset) => scratch[offset] ?? 0, () => {
+			inverse53Filter(scratch, u0, u1);
+		}, (value) => value >> 1);
+	}
+	for (let u = 0; u < width; u++) synthesiseLine((index) => output[(index - v0) * width + u] ?? 0, (index, value) => {
+		output[(index - v0) * width + u] = value;
+	}, v0, v1, (offset, value) => {
+		scratch[offset] = value;
+	}, (offset) => scratch[offset] ?? 0, () => {
+		inverse53Filter(scratch, v0, v1);
+	}, (value) => value >> 1);
+	return output;
+}
+function inverseDwt97Level(bands, bounds) {
+	const { u0, u1, v0, v1 } = bounds;
+	const width = u1 - u0;
+	const height = v1 - v0;
+	const output = new Float32Array(Math.max(width * height, 0));
+	if (width <= 0 || height <= 0) return output;
+	interleave(interleaveSource(bands, bounds), bounds, (u, v, value) => {
+		output[(v - v0) * width + (u - u0)] = value;
+	});
+	const scratch = new Float32Array(Math.max(width, height) + 12);
+	for (let v = 0; v < height; v++) {
+		const rowStart = v * width;
+		synthesiseLine((index) => output[rowStart + index - u0] ?? 0, (index, value) => {
+			output[rowStart + index - u0] = value;
+		}, u0, u1, (offset, value) => {
+			scratch[offset] = value;
+		}, (offset) => scratch[offset] ?? 0, () => {
+			inverse97Filter(scratch, u0, u1);
+		}, (value) => value / 2);
+	}
+	for (let u = 0; u < width; u++) synthesiseLine((index) => output[(index - v0) * width + u] ?? 0, (index, value) => {
+		output[(index - v0) * width + u] = value;
+	}, v0, v1, (offset, value) => {
+		scratch[offset] = value;
+	}, (offset) => scratch[offset] ?? 0, () => {
+		inverse97Filter(scratch, v0, v1);
+	}, (value) => value / 2);
+	return output;
+}
+//#endregion
+exports.inverseDwt53Level = inverseDwt53Level;
+exports.inverseDwt97Level = inverseDwt97Level;
+exports.subbandBounds = subbandBounds;

package/dist/image/jpeg2000-dwt.d.cts

@@ -0,0 +1,34 @@
+//#region src/image/jpeg2000-dwt.d.ts
+interface Jpeg2000ResolutionBounds {
+  readonly u0: number;
+  readonly u1: number;
+  readonly v0: number;
+  readonly v1: number;
+}
+interface Jpeg2000SubbandBounds {
+  readonly llU0: number;
+  readonly llU1: number;
+  readonly llV0: number;
+  readonly llV1: number;
+  readonly hU0: number;
+  readonly hU1: number;
+  readonly hV0: number;
+  readonly hV1: number;
+}
+declare function subbandBounds(bounds: Jpeg2000ResolutionBounds): Jpeg2000SubbandBounds;
+interface Jpeg2000ReversibleSubbands {
+  readonly ll: Int32Array;
+  readonly hl: Int32Array;
+  readonly lh: Int32Array;
+  readonly hh: Int32Array;
+}
+interface Jpeg2000IrreversibleSubbands {
+  readonly ll: Float32Array;
+  readonly hl: Float32Array;
+  readonly lh: Float32Array;
+  readonly hh: Float32Array;
+}
+declare function inverseDwt53Level(bands: Jpeg2000ReversibleSubbands, bounds: Jpeg2000ResolutionBounds): Int32Array;
+declare function inverseDwt97Level(bands: Jpeg2000IrreversibleSubbands, bounds: Jpeg2000ResolutionBounds): Float32Array;
+//#endregion
+export { Jpeg2000IrreversibleSubbands, Jpeg2000ResolutionBounds, Jpeg2000ReversibleSubbands, Jpeg2000SubbandBounds, inverseDwt53Level, inverseDwt97Level, subbandBounds };

package/dist/image/jpeg2000-dwt.d.ts

@@ -0,0 +1,34 @@
+//#region src/image/jpeg2000-dwt.d.ts
+interface Jpeg2000ResolutionBounds {
+  readonly u0: number;
+  readonly u1: number;
+  readonly v0: number;
+  readonly v1: number;
+}
+interface Jpeg2000SubbandBounds {
+  readonly llU0: number;
+  readonly llU1: number;
+  readonly llV0: number;
+  readonly llV1: number;
+  readonly hU0: number;
+  readonly hU1: number;
+  readonly hV0: number;
+  readonly hV1: number;
+}
+declare function subbandBounds(bounds: Jpeg2000ResolutionBounds): Jpeg2000SubbandBounds;
+interface Jpeg2000ReversibleSubbands {
+  readonly ll: Int32Array;
+  readonly hl: Int32Array;
+  readonly lh: Int32Array;
+  readonly hh: Int32Array;
+}
+interface Jpeg2000IrreversibleSubbands {
+  readonly ll: Float32Array;
+  readonly hl: Float32Array;
+  readonly lh: Float32Array;
+  readonly hh: Float32Array;
+}
+declare function inverseDwt53Level(bands: Jpeg2000ReversibleSubbands, bounds: Jpeg2000ResolutionBounds): Int32Array;
+declare function inverseDwt97Level(bands: Jpeg2000IrreversibleSubbands, bounds: Jpeg2000ResolutionBounds): Float32Array;
+//#endregion
+export { Jpeg2000IrreversibleSubbands, Jpeg2000ResolutionBounds, Jpeg2000ReversibleSubbands, Jpeg2000SubbandBounds, inverseDwt53Level, inverseDwt97Level, subbandBounds };

package/dist/image/jpeg2000-dwt.js

@@ -0,0 +1,145 @@
+//#region src/image/jpeg2000-dwt.ts
+const EXTENSION_MARGIN = 6;
+const LIFT_ALPHA = -1.586134342059924;
+const LIFT_BETA = -.052980118572961;
+const LIFT_GAMMA = .882911075530934;
+const LIFT_DELTA = .443506852043971;
+const LIFT_K = 1.230174104914001;
+function subbandBounds(bounds) {
+	return {
+		llU0: Math.ceil(bounds.u0 / 2),
+		llU1: Math.ceil(bounds.u1 / 2),
+		llV0: Math.ceil(bounds.v0 / 2),
+		llV1: Math.ceil(bounds.v1 / 2),
+		hU0: Math.floor(bounds.u0 / 2),
+		hU1: Math.floor(bounds.u1 / 2),
+		hV0: Math.floor(bounds.v0 / 2),
+		hV1: Math.floor(bounds.v1 / 2)
+	};
+}
+function mirrorIndex(position, i0, i1) {
+	const length = i1 - i0;
+	if (length <= 1) return i0;
+	const period = 2 * (length - 1);
+	let offset = (position - i0) % period;
+	if (offset < 0) offset += period;
+	return i0 + (offset >= length ? period - offset : offset);
+}
+function interleave(source, bounds, write) {
+	const sub = subbandBounds(bounds);
+	for (let v = sub.llV0; v < sub.llV1; v++) for (let u = sub.llU0; u < sub.llU1; u++) write(2 * u, 2 * v, source.ll(u, v));
+	for (let v = sub.llV0; v < sub.llV1; v++) for (let u = sub.hU0; u < sub.hU1; u++) write(2 * u + 1, 2 * v, source.hl(u, v));
+	for (let v = sub.hV0; v < sub.hV1; v++) for (let u = sub.llU0; u < sub.llU1; u++) write(2 * u, 2 * v + 1, source.lh(u, v));
+	for (let v = sub.hV0; v < sub.hV1; v++) for (let u = sub.hU0; u < sub.hU1; u++) write(2 * u + 1, 2 * v + 1, source.hh(u, v));
+}
+function inverse53Filter(buffer, i0, i1) {
+	const base = EXTENSION_MARGIN - i0;
+	const first = Math.floor(i0 / 2) - 1;
+	const last = Math.floor(i1 / 2) + 1;
+	for (let n = first; n <= last; n++) {
+		const index = base + 2 * n;
+		buffer[index] = (buffer[index] ?? 0) - Math.floor(((buffer[index - 1] ?? 0) + (buffer[index + 1] ?? 0) + 2) / 4);
+	}
+	for (let n = first; n < last; n++) {
+		const index = base + 2 * n + 1;
+		buffer[index] = (buffer[index] ?? 0) + Math.floor(((buffer[index - 1] ?? 0) + (buffer[index + 1] ?? 0)) / 2);
+	}
+}
+function inverse97Filter(buffer, i0, i1) {
+	const base = EXTENSION_MARGIN - i0;
+	const first = Math.floor(i0 / 2);
+	const last = Math.floor(i1 / 2);
+	const even = (n) => base + 2 * n;
+	const odd = (n) => base + 2 * n + 1;
+	for (let n = first - 2; n <= last + 2; n++) {
+		buffer[even(n)] = (buffer[even(n)] ?? 0) * LIFT_K;
+		buffer[odd(n)] = (buffer[odd(n)] ?? 0) / LIFT_K;
+	}
+	for (let n = first - 1; n <= last + 1; n++) buffer[even(n)] = (buffer[even(n)] ?? 0) - LIFT_DELTA * ((buffer[even(n) - 1] ?? 0) + (buffer[even(n) + 1] ?? 0));
+	for (let n = first - 1; n <= last; n++) buffer[odd(n)] = (buffer[odd(n)] ?? 0) - LIFT_GAMMA * ((buffer[odd(n) - 1] ?? 0) + (buffer[odd(n) + 1] ?? 0));
+	for (let n = first; n <= last + 1; n++) buffer[even(n)] = (buffer[even(n)] ?? 0) - LIFT_BETA * ((buffer[even(n) - 1] ?? 0) + (buffer[even(n) + 1] ?? 0));
+	for (let n = first; n <= last; n++) buffer[odd(n)] = (buffer[odd(n)] ?? 0) - LIFT_ALPHA * ((buffer[odd(n) - 1] ?? 0) + (buffer[odd(n) + 1] ?? 0));
+}
+function synthesiseLine(read, write, i0, i1, fillScratch, readScratch, runFilter, singleSampleHighPassGain) {
+	const length = i1 - i0;
+	if (length <= 0) return;
+	if (length === 1) {
+		const value = read(i0);
+		write(i0, i0 % 2 === 0 ? value : singleSampleHighPassGain(value));
+		return;
+	}
+	for (let k = -6; k < length + EXTENSION_MARGIN; k++) fillScratch(EXTENSION_MARGIN + k, read(mirrorIndex(i0 + k, i0, i1)));
+	runFilter();
+	for (let k = 0; k < length; k++) write(i0 + k, readScratch(EXTENSION_MARGIN + k));
+}
+function interleaveSource(bands, bounds) {
+	const sub = subbandBounds(bounds);
+	const llWidth = sub.llU1 - sub.llU0;
+	const hWidth = sub.hU1 - sub.hU0;
+	return {
+		ll: (u, v) => bands.ll[(v - sub.llV0) * llWidth + (u - sub.llU0)] ?? 0,
+		hl: (u, v) => bands.hl[(v - sub.llV0) * hWidth + (u - sub.hU0)] ?? 0,
+		lh: (u, v) => bands.lh[(v - sub.hV0) * llWidth + (u - sub.llU0)] ?? 0,
+		hh: (u, v) => bands.hh[(v - sub.hV0) * hWidth + (u - sub.hU0)] ?? 0
+	};
+}
+function inverseDwt53Level(bands, bounds) {
+	const { u0, u1, v0, v1 } = bounds;
+	const width = u1 - u0;
+	const height = v1 - v0;
+	const output = new Int32Array(Math.max(width * height, 0));
+	if (width <= 0 || height <= 0) return output;
+	interleave(interleaveSource(bands, bounds), bounds, (u, v, value) => {
+		output[(v - v0) * width + (u - u0)] = value;
+	});
+	const scratch = new Int32Array(Math.max(width, height) + 12);
+	for (let v = 0; v < height; v++) {
+		const rowStart = v * width;
+		synthesiseLine((index) => output[rowStart + index - u0] ?? 0, (index, value) => {
+			output[rowStart + index - u0] = value;
+		}, u0, u1, (offset, value) => {
+			scratch[offset] = value;
+		}, (offset) => scratch[offset] ?? 0, () => {
+			inverse53Filter(scratch, u0, u1);
+		}, (value) => value >> 1);
+	}
+	for (let u = 0; u < width; u++) synthesiseLine((index) => output[(index - v0) * width + u] ?? 0, (index, value) => {
+		output[(index - v0) * width + u] = value;
+	}, v0, v1, (offset, value) => {
+		scratch[offset] = value;
+	}, (offset) => scratch[offset] ?? 0, () => {
+		inverse53Filter(scratch, v0, v1);
+	}, (value) => value >> 1);
+	return output;
+}
+function inverseDwt97Level(bands, bounds) {
+	const { u0, u1, v0, v1 } = bounds;
+	const width = u1 - u0;
+	const height = v1 - v0;
+	const output = new Float32Array(Math.max(width * height, 0));
+	if (width <= 0 || height <= 0) return output;
+	interleave(interleaveSource(bands, bounds), bounds, (u, v, value) => {
+		output[(v - v0) * width + (u - u0)] = value;
+	});
+	const scratch = new Float32Array(Math.max(width, height) + 12);
+	for (let v = 0; v < height; v++) {
+		const rowStart = v * width;
+		synthesiseLine((index) => output[rowStart + index - u0] ?? 0, (index, value) => {
+			output[rowStart + index - u0] = value;
+		}, u0, u1, (offset, value) => {
+			scratch[offset] = value;
+		}, (offset) => scratch[offset] ?? 0, () => {
+			inverse97Filter(scratch, u0, u1);
+		}, (value) => value / 2);
+	}
+	for (let u = 0; u < width; u++) synthesiseLine((index) => output[(index - v0) * width + u] ?? 0, (index, value) => {
+		output[(index - v0) * width + u] = value;
+	}, v0, v1, (offset, value) => {
+		scratch[offset] = value;
+	}, (offset) => scratch[offset] ?? 0, () => {
+		inverse97Filter(scratch, v0, v1);
+	}, (value) => value / 2);
+	return output;
+}
+//#endregion
+export { inverseDwt53Level, inverseDwt97Level, subbandBounds };

package/dist/image/jpeg2000-errors.cjs

@@ -0,0 +1,17 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/image/jpeg2000-errors.ts
+var Jpeg2000ParseError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "Jpeg2000ParseError";
+	}
+};
+var Jpeg2000UnsupportedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "Jpeg2000UnsupportedError";
+	}
+};
+//#endregion
+exports.Jpeg2000ParseError = Jpeg2000ParseError;
+exports.Jpeg2000UnsupportedError = Jpeg2000UnsupportedError;