pdf-codec 1.5.0 → 1.7.0

package/dist/image/jpeg2000.js

@@ -0,0 +1,320 @@
+import { Jpeg2000ParseError, Jpeg2000UnsupportedError } from "./jpeg2000-errors.js";
+import { parseJp2Container } from "./jp2-boxes.js";
+import { parseJpeg2000Codestream } from "./jpeg2000-codestream.js";
+import { inverseDwt53Level, inverseDwt97Level } from "./jpeg2000-dwt.js";
+import { decodeJpeg2000CodeBlock } from "./jpeg2000-t1.js";
+import { buildPacketSequence, buildTileGeometry, readTilePackets, subbandGainLog2, tileHasSubdividedPrecincts } from "./jpeg2000-t2.js";
+//#region src/image/jpeg2000.ts
+function resolveCoding(main, tile, component) {
+	const tileCoc = tile?.coc.get(component);
+	if (tileCoc !== void 0) return tileCoc;
+	if (tile?.cod !== void 0) return tile.cod;
+	const mainCoc = main.coc.get(component);
+	if (mainCoc !== void 0) return mainCoc;
+	if (main.cod === void 0) throw new Jpeg2000ParseError("no COD marker defines a coding style for this codestream");
+	return main.cod;
+}
+function resolveQuantization(main, tile, component) {
+	const tileQcc = tile?.qcc.get(component);
+	if (tileQcc !== void 0) return tileQcc;
+	if (tile?.qcd !== void 0) return tile.qcd;
+	const mainQcc = main.qcc.get(component);
+	if (mainQcc !== void 0) return mainQcc;
+	if (main.qcd === void 0) throw new Jpeg2000ParseError("no QCD marker defines a quantization for this codestream");
+	return main.qcd;
+}
+function tileDefaults(main, tile) {
+	if (tile?.cod !== void 0) return tile.cod;
+	if (main.cod === void 0) throw new Jpeg2000ParseError("no COD marker defines a coding style for this codestream");
+	return main.cod;
+}
+function undecodableReason(codestream) {
+	const main = codestream.main;
+	const cod = main.cod;
+	if (cod === void 0) return "the codestream carries no COD marker";
+	const headers = [main, ...codestream.tileParts.map((part) => part.header)];
+	for (const header of headers) {
+		if (header.hasProgressionChanges) return "the codestream carries a POC marker (progression order change), which this decoder does not follow";
+		if (header.hasRegionOfInterest) return "the codestream carries an RGN marker (region of interest), whose coefficient upshift this decoder does not undo";
+		if (header.hasPackedPacketHeaders) return "the codestream carries a PPT marker (packed packet headers in the tile-part header), an organisation this decoder does not reassemble";
+	}
+	for (let c = 0; c < codestream.siz.components.length; c++) {
+		const size = codestream.siz.components[c];
+		if (size === void 0) continue;
+		if (size.dx !== 1 || size.dy !== 1) return `component ${String(c)} is sub-sampled (${String(size.dx)}x${String(size.dy)}), which this decoder does not resample`;
+		for (const header of headers) {
+			const style = resolveCoding(main, header === main ? void 0 : header, c);
+			if ((style.codeBlockStyle & 1) !== 0) return "the code-block style enables selective arithmetic coding bypass, which this decoder does not read";
+			if ((style.codeBlockStyle & 4) !== 0) return "the code-block style terminates the arithmetic coder on every coding pass, which this decoder does not read";
+		}
+	}
+	for (const part of codestream.tileParts) {
+		if (part.partIndex !== 0) continue;
+		const defaults = part.header.cod ?? cod;
+		if (defaults.progressionOrder === "LRCP" || defaults.progressionOrder === "RLCP") continue;
+		const numTilesWide = Math.max(Math.ceil((codestream.siz.xsiz - codestream.siz.xtosiz) / codestream.siz.xtsiz), 1);
+		const codingPerComponent = codestream.siz.components.map((_, c) => resolveCoding(main, part.header, c));
+		if (tileHasSubdividedPrecincts(codestream.siz, part.tileIndex % numTilesWide, Math.floor(part.tileIndex / numTilesWide), codingPerComponent)) return `progression order ${defaults.progressionOrder} is only decoded here when every resolution level holds a single precinct, and this codestream subdivides at least one of them`;
+	}
+	const first = codestream.siz.components[0];
+	if (first !== void 0) {
+		for (const size of codestream.siz.components) if (size.bitDepth !== first.bitDepth || size.signed !== first.signed) return "the codestream mixes component bit depths or signedness, which this decoder does not combine into one image";
+		if (first.bitDepth > 31) return `a component bit depth of ${String(first.bitDepth)} exceeds what this decoder's own 32-bit sample arithmetic can hold`;
+	}
+}
+function readJpeg2000Metadata(data) {
+	const container = parseJp2Container(data);
+	const codestream = parseJpeg2000Codestream(container.codestream);
+	const cod = codestream.main.cod;
+	const qcd = codestream.main.qcd;
+	if (cod === void 0 || qcd === void 0) throw new Jpeg2000ParseError("the codestream main header is missing its COD or QCD marker");
+	const reason = undecodableReason(codestream);
+	const siz = codestream.siz;
+	return {
+		width: siz.xsiz - siz.xosiz,
+		height: siz.ysiz - siz.yosiz,
+		components: siz.components.map((component) => ({
+			bitDepth: component.bitDepth,
+			signed: component.signed,
+			dx: component.dx,
+			dy: component.dy
+		})),
+		tileWidth: siz.xtsiz,
+		tileHeight: siz.ytsiz,
+		tilesWide: codestream.numTilesWide,
+		tilesHigh: codestream.numTilesHigh,
+		tilePartCount: codestream.tileParts.length,
+		decompositionLevels: cod.decompositionLevels,
+		transform: cod.transform,
+		progressionOrder: cod.progressionOrder,
+		layers: cod.layers,
+		codeBlockWidth: 2 ** cod.codeBlockWidthExp,
+		codeBlockHeight: 2 ** cod.codeBlockHeightExp,
+		codeBlockStyle: cod.codeBlockStyle,
+		quantizationStyle: qcd.style,
+		guardBits: qcd.guardBits,
+		multipleComponentTransform: cod.multipleComponentTransform,
+		usesSopMarkers: cod.useSop,
+		usesEphMarkers: cod.useEph,
+		hasIccProfile: container.iccProfile !== void 0,
+		channelDefinitions: container.channelDefinitions,
+		comments: codestream.comments,
+		truncated: codestream.truncated,
+		decodable: reason === void 0,
+		...container.colourSpace !== void 0 ? { colourSpace: container.colourSpace } : {},
+		...reason !== void 0 ? { undecodableReason: reason } : {}
+	};
+}
+function concatTilePartData(codestream, tileIndex) {
+	const parts = codestream.tileParts.filter((part) => part.tileIndex === tileIndex).sort((a, b) => a.partIndex - b.partIndex);
+	let total = 0;
+	for (const part of parts) total += part.dataEnd - part.dataStart;
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const part of parts) {
+		out.set(codestream.bytes.subarray(part.dataStart, part.dataEnd), offset);
+		offset += part.dataEnd - part.dataStart;
+	}
+	return out;
+}
+function halveTowardZero(value) {
+	return value < 0 ? -(-value >> 1) : value >> 1;
+}
+function quantizationStep(band, componentBitDepth) {
+	return 2 ** (componentBitDepth + subbandGainLog2(band.type) - band.stepSize.exponent) * (1 + band.stepSize.mantissa / 2048);
+}
+function decodeSubbandBlocks(band, codeBlockStyle, data, place) {
+	for (const precinct of band.precincts) for (const block of precinct.codeBlocks) {
+		const blockWidth = block.x1 - block.x0;
+		const blockHeight = block.y1 - block.y0;
+		if (blockWidth <= 0 || blockHeight <= 0 || block.passes === 0) continue;
+		let coded = /* @__PURE__ */ new Uint8Array(0);
+		if (block.chunks.length === 1) {
+			const chunk = block.chunks[0];
+			coded = chunk === void 0 ? coded : data.subarray(chunk.start, chunk.end);
+		} else if (block.chunks.length > 1) {
+			let total = 0;
+			for (const chunk of block.chunks) total += chunk.end - chunk.start;
+			const joined = new Uint8Array(total);
+			let offset = 0;
+			for (const chunk of block.chunks) {
+				joined.set(data.subarray(chunk.start, chunk.end), offset);
+				offset += chunk.end - chunk.start;
+			}
+			coded = joined;
+		}
+		const { values } = decodeJpeg2000CodeBlock({
+			width: blockWidth,
+			height: blockHeight,
+			subband: band.type,
+			zeroBitPlanes: block.zeroBitPlanes,
+			maxBitPlanes: band.maxBitPlanes,
+			totalPasses: block.passes,
+			codeBlockStyle,
+			data: coded
+		});
+		for (let y = 0; y < blockHeight; y++) for (let x = 0; x < blockWidth; x++) place(block.x0 - band.x0 + x, block.y0 - band.y0 + y, values[y * blockWidth + x] ?? 0);
+	}
+}
+function decodeReversibleTileComponent(tile, componentIndex, data) {
+	const component = tile.components[componentIndex];
+	if (component === void 0) throw new Jpeg2000ParseError(`the tile has no component ${String(componentIndex)}`);
+	const bands = /* @__PURE__ */ new Map();
+	for (const resolution of component.resolutions) for (const band of resolution.subbands) {
+		const width = band.x1 - band.x0;
+		const samples = new Int32Array(Math.max(width * (band.y1 - band.y0), 0));
+		decodeSubbandBlocks(band, component.coding.codeBlockStyle, data, (x, y, value) => {
+			samples[y * width + x] = halveTowardZero(value);
+		});
+		bands.set(`${String(resolution.index)}:${band.type}`, samples);
+	}
+	let current = bands.get("0:LL") ?? /* @__PURE__ */ new Int32Array(0);
+	for (let r = 1; r < component.resolutions.length; r++) {
+		const resolution = component.resolutions[r];
+		if (resolution === void 0) break;
+		current = inverseDwt53Level({
+			ll: current,
+			hl: bands.get(`${String(r)}:HL`) ?? /* @__PURE__ */ new Int32Array(0),
+			lh: bands.get(`${String(r)}:LH`) ?? /* @__PURE__ */ new Int32Array(0),
+			hh: bands.get(`${String(r)}:HH`) ?? /* @__PURE__ */ new Int32Array(0)
+		}, {
+			u0: resolution.x0,
+			u1: resolution.x1,
+			v0: resolution.y0,
+			v1: resolution.y1
+		});
+	}
+	return current;
+}
+function decodeIrreversibleTileComponent(tile, componentIndex, componentBitDepth, data) {
+	const component = tile.components[componentIndex];
+	if (component === void 0) throw new Jpeg2000ParseError(`the tile has no component ${String(componentIndex)}`);
+	const bands = /* @__PURE__ */ new Map();
+	for (const resolution of component.resolutions) for (const band of resolution.subbands) {
+		const width = band.x1 - band.x0;
+		const samples = new Float32Array(Math.max(width * (band.y1 - band.y0), 0));
+		const scale = quantizationStep(band, componentBitDepth) / 2;
+		decodeSubbandBlocks(band, component.coding.codeBlockStyle, data, (x, y, value) => {
+			samples[y * width + x] = value * scale;
+		});
+		bands.set(`${String(resolution.index)}:${band.type}`, samples);
+	}
+	let current = bands.get("0:LL") ?? /* @__PURE__ */ new Float32Array(0);
+	for (let r = 1; r < component.resolutions.length; r++) {
+		const resolution = component.resolutions[r];
+		if (resolution === void 0) break;
+		current = inverseDwt97Level({
+			ll: current,
+			hl: bands.get(`${String(r)}:HL`) ?? /* @__PURE__ */ new Float32Array(0),
+			lh: bands.get(`${String(r)}:LH`) ?? /* @__PURE__ */ new Float32Array(0),
+			hh: bands.get(`${String(r)}:HH`) ?? /* @__PURE__ */ new Float32Array(0)
+		}, {
+			u0: resolution.x0,
+			u1: resolution.x1,
+			v0: resolution.y0,
+			v1: resolution.y1
+		});
+	}
+	return current;
+}
+function inverseReversibleComponentTransform(planes) {
+	const y = planes[0];
+	const u = planes[1];
+	const v = planes[2];
+	if (y === void 0 || u === void 0 || v === void 0) return;
+	for (let i = 0; i < y.length; i++) {
+		const green = (y[i] ?? 0) - Math.floor(((u[i] ?? 0) + (v[i] ?? 0)) / 4);
+		const red = (v[i] ?? 0) + green;
+		const blue = (u[i] ?? 0) + green;
+		y[i] = red;
+		u[i] = green;
+		v[i] = blue;
+	}
+}
+const ICT_RED_FROM_CR = 1.402;
+const ICT_GREEN_FROM_CB = -.344136;
+const ICT_GREEN_FROM_CR = -.714136;
+const ICT_BLUE_FROM_CB = 1.772;
+function inverseIrreversibleComponentTransform(planes) {
+	const y = planes[0];
+	const cb = planes[1];
+	const cr = planes[2];
+	if (y === void 0 || cb === void 0 || cr === void 0) return;
+	for (let i = 0; i < y.length; i++) {
+		const luma = y[i] ?? 0;
+		const blueDiff = cb[i] ?? 0;
+		const redDiff = cr[i] ?? 0;
+		y[i] = luma + ICT_RED_FROM_CR * redDiff;
+		cb[i] = luma + ICT_GREEN_FROM_CB * blueDiff + ICT_GREEN_FROM_CR * redDiff;
+		cr[i] = luma + ICT_BLUE_FROM_CB * blueDiff;
+	}
+}
+function decodeJpeg2000(data, options = {}) {
+	const onWarning = options.onWarning ?? (() => void 0);
+	const container = parseJp2Container(data);
+	const codestream = parseJpeg2000Codestream(container.codestream);
+	const reason = undecodableReason(codestream);
+	if (reason !== void 0) throw new Jpeg2000UnsupportedError(reason);
+	if (codestream.truncated) onWarning("the codestream ends without an EOC marker, so it is truncated; decoding whatever packets did arrive");
+	const siz = codestream.siz;
+	const width = siz.xsiz - siz.xosiz;
+	const height = siz.ysiz - siz.yosiz;
+	const componentCount = siz.components.length;
+	const first = siz.components[0];
+	if (first === void 0) throw new Jpeg2000ParseError("the codestream declares no components");
+	const planes = Array.from({ length: componentCount }, () => new Int32Array(width * height));
+	const tileIndices = new Set(codestream.tileParts.map((part) => part.tileIndex));
+	if (tileIndices.size === 0) throw new Jpeg2000ParseError("the codestream carries no tile-part data");
+	for (const tileIndex of [...tileIndices].sort((a, b) => a - b)) {
+		const tileX = tileIndex % codestream.numTilesWide;
+		const tileY = Math.floor(tileIndex / codestream.numTilesWide);
+		const tileHeader = codestream.tileParts.find((part) => part.tileIndex === tileIndex && part.partIndex === 0)?.header;
+		const codingPerComponent = Array.from({ length: componentCount }, (_, c) => resolveCoding(codestream.main, tileHeader, c));
+		const quantizationPerComponent = Array.from({ length: componentCount }, (_, c) => resolveQuantization(codestream.main, tileHeader, c));
+		const defaults = tileDefaults(codestream.main, tileHeader);
+		const geometry = buildTileGeometry(siz, tileX, tileY, codingPerComponent, quantizationPerComponent);
+		const tileData = concatTilePartData(codestream, tileIndex);
+		const sequence = buildPacketSequence(geometry, defaults.progressionOrder, defaults.layers);
+		readTilePackets(tileData, 0, tileData.length, geometry, sequence, {
+			useSop: defaults.useSop,
+			useEph: defaults.useEph,
+			onWarning
+		});
+		const tilePlanes = [];
+		if (defaults.transform === "reversible-5-3") {
+			const reversible = Array.from({ length: componentCount }, (_, c) => decodeReversibleTileComponent(geometry, c, tileData));
+			if (defaults.multipleComponentTransform && componentCount >= 3) inverseReversibleComponentTransform(reversible);
+			tilePlanes.push(...reversible);
+		} else {
+			const irreversible = Array.from({ length: componentCount }, (_, c) => decodeIrreversibleTileComponent(geometry, c, first.bitDepth, tileData));
+			if (defaults.multipleComponentTransform && componentCount >= 3) inverseIrreversibleComponentTransform(irreversible);
+			tilePlanes.push(...irreversible);
+		}
+		for (let c = 0; c < componentCount; c++) {
+			const tileComponent = geometry.components[c];
+			const source = tilePlanes[c];
+			const destination = planes[c];
+			if (tileComponent === void 0 || source === void 0 || destination === void 0) continue;
+			const tileWidth = tileComponent.x1 - tileComponent.x0;
+			for (let y = tileComponent.y0; y < tileComponent.y1; y++) for (let x = tileComponent.x0; x < tileComponent.x1; x++) destination[(y - siz.yosiz) * width + (x - siz.xosiz)] = Math.round(source[(y - tileComponent.y0) * tileWidth + (x - tileComponent.x0)] ?? 0);
+		}
+	}
+	const shift = first.signed ? 0 : 1 << first.bitDepth - 1;
+	const minimum = first.signed ? -(1 << first.bitDepth - 1) : 0;
+	const maximum = first.signed ? (1 << first.bitDepth - 1) - 1 : (1 << first.bitDepth) - 1;
+	for (const plane of planes) for (let i = 0; i < plane.length; i++) plane[i] = Math.min(Math.max((plane[i] ?? 0) + shift, minimum), maximum);
+	const base = {
+		width,
+		height,
+		bitDepth: first.bitDepth,
+		signed: first.signed,
+		components: planes,
+		channelDefinitions: container.channelDefinitions
+	};
+	return container.colourSpace !== void 0 ? {
+		...base,
+		colourSpace: container.colourSpace
+	} : base;
+}
+//#endregion
+export { decodeJpeg2000, readJpeg2000Metadata };

package/dist/images-read.cjs

@@ -3,6 +3,7 @@ const require_objects = require("./objects.cjs");
 const require_filters = require("./filters.cjs");
 const require_image_png_encode = require("./image/png-encode.cjs");
 const require_image_jpeg_info = require("./image/jpeg-info.cjs");
+const require_image_jpeg2000 = require("./image/jpeg2000.cjs");
 //#region src/images-read.ts
 function componentsOf(cs) {
 	if (cs.kind === "gray") return 1;
@@ -170,6 +171,81 @@ function readSoftMaskAlpha(dict, width, height, resolver, sink) {
 	if (smaskWidth !== width || smaskHeight !== height || smaskBpc !== 8) return;
 	return decoded.bytes.subarray(0, width * height);
 }
+function jpeg2000ChannelKind(image, dict, resolver, sink) {
+	const declared = require_objects.dictGet(dict, "ColorSpace") ?? require_objects.dictGet(dict, "CS");
+	if (declared !== void 0) {
+		const resolved = resolveColorSpace(declared, resolver, sink);
+		if (resolved.kind === "gray" || resolved.kind === "rgb" || resolved.kind === "cmyk") return resolved.kind;
+	}
+	if (image.colourSpace === "greyscale") return "gray";
+	if (image.colourSpace === "cmyk") return "cmyk";
+	if (image.colourSpace === "srgb" || image.colourSpace === "sycc" || image.colourSpace === "e-srgb" || image.colourSpace === "rommrgb") return "rgb";
+	return image.components.length >= 4 ? "cmyk" : image.components.length >= 3 ? "rgb" : "gray";
+}
+function readJpeg2000Image(dict, raw, resolver, sink) {
+	let image;
+	try {
+		image = require_image_jpeg2000.decodeJpeg2000(raw, { onWarning: (message) => sink({
+			code: "image/jpx-degraded",
+			severity: "warning",
+			message
+		}) });
+	} catch (error) {
+		sink({
+			code: "image/jpx-undecodable",
+			severity: "warning",
+			message: `JPXDecode image could not be decoded (${error instanceof Error ? error.message : String(error)}); skipping this image`
+		});
+		return;
+	}
+	const kind = jpeg2000ChannelKind(image, dict, resolver, sink);
+	const required = kind === "cmyk" ? 4 : kind === "rgb" ? 3 : 1;
+	if (image.components.length < required) {
+		sink({
+			code: "image/jpx-undecodable",
+			severity: "warning",
+			message: `JPXDecode image resolves to a ${kind} colour space but carries only ${String(image.components.length)} component(s); skipping this image`
+		});
+		return;
+	}
+	if (image.components.length > required) sink({
+		code: "image/jpx-extra-channels",
+		severity: "info",
+		message: `JPXDecode image carries ${String(image.components.length)} components where its colour space needs ${String(required)}; the extra channel(s) are ignored`
+	});
+	const maximum = (1 << image.bitDepth) - 1;
+	const scale = (value) => image.bitDepth === 8 ? value : Math.round(value * 255 / maximum);
+	const pixels = image.width * image.height;
+	const channels = kind === "gray" ? 1 : 3;
+	const data = new Uint8Array(pixels * channels);
+	if (kind === "cmyk") for (let i = 0; i < pixels; i++) {
+		const rgb = cmykToRgbByte(scale(image.components[0]?.[i] ?? 0) / 255, scale(image.components[1]?.[i] ?? 0) / 255, scale(image.components[2]?.[i] ?? 0) / 255, scale(image.components[3]?.[i] ?? 0) / 255);
+		data[i * 3] = rgb.r;
+		data[i * 3 + 1] = rgb.g;
+		data[i * 3 + 2] = rgb.b;
+	}
+	else for (let channel = 0; channel < channels; channel++) {
+		const plane = image.components[channel];
+		for (let i = 0; i < pixels; i++) data[i * channels + channel] = scale(plane?.[i] ?? 0);
+	}
+	const rawImage = {
+		width: image.width,
+		height: image.height,
+		channels,
+		data
+	};
+	const alpha = readSoftMaskAlpha(dict, image.width, image.height, resolver, sink);
+	const withAlpha = alpha !== void 0 ? {
+		...rawImage,
+		alpha
+	} : rawImage;
+	return {
+		format: "png",
+		bytes: require_image_png_encode.encodePng(withAlpha),
+		widthPx: image.width,
+		heightPx: image.height
+	};
+}
 function readImageXObject(dict, raw, resolver, sink) {
 	if (require_objects.asBool(require_objects.dictGet(dict, "ImageMask") ?? require_objects.dictGet(dict, "IM")) === true) {
 		sink({
@@ -179,7 +255,7 @@ function readImageXObject(dict, raw, resolver, sink) {
 		});
 		return;
 	}
-	const decoded = require_filters.decodeStream(raw, dict, sink);
+	const decoded = require_filters.decodeStream(raw, dict, sink, (obj) => resolver.resolve(obj));
 	if (decoded.remainingFilter === "DCTDecode") {
 		let info;
 		try {
@@ -199,6 +275,7 @@ function readImageXObject(dict, raw, resolver, sink) {
 			heightPx: info.height
 		};
 	}
+	if (decoded.remainingFilter === "JPXDecode") return readJpeg2000Image(dict, decoded.bytes, resolver, sink);
 	if (decoded.remainingFilter !== void 0) return;
 	const width = require_objects.asNumber(require_objects.dictGet(dict, "Width") ?? require_objects.dictGet(dict, "W"));
 	const height = require_objects.asNumber(require_objects.dictGet(dict, "Height") ?? require_objects.dictGet(dict, "H"));

package/dist/images-read.js

@@ -2,6 +2,7 @@ import { asArray, asBool, asName, asNumber, dictGet } from "./objects.js";
 import { decodeStream } from "./filters.js";
 import { encodePng } from "./image/png-encode.js";
 import { readJpegInfo } from "./image/jpeg-info.js";
+import { decodeJpeg2000 } from "./image/jpeg2000.js";
 //#region src/images-read.ts
 function componentsOf(cs) {
 	if (cs.kind === "gray") return 1;
@@ -169,6 +170,81 @@ function readSoftMaskAlpha(dict, width, height, resolver, sink) {
 	if (smaskWidth !== width || smaskHeight !== height || smaskBpc !== 8) return;
 	return decoded.bytes.subarray(0, width * height);
 }
+function jpeg2000ChannelKind(image, dict, resolver, sink) {
+	const declared = dictGet(dict, "ColorSpace") ?? dictGet(dict, "CS");
+	if (declared !== void 0) {
+		const resolved = resolveColorSpace(declared, resolver, sink);
+		if (resolved.kind === "gray" || resolved.kind === "rgb" || resolved.kind === "cmyk") return resolved.kind;
+	}
+	if (image.colourSpace === "greyscale") return "gray";
+	if (image.colourSpace === "cmyk") return "cmyk";
+	if (image.colourSpace === "srgb" || image.colourSpace === "sycc" || image.colourSpace === "e-srgb" || image.colourSpace === "rommrgb") return "rgb";
+	return image.components.length >= 4 ? "cmyk" : image.components.length >= 3 ? "rgb" : "gray";
+}
+function readJpeg2000Image(dict, raw, resolver, sink) {
+	let image;
+	try {
+		image = decodeJpeg2000(raw, { onWarning: (message) => sink({
+			code: "image/jpx-degraded",
+			severity: "warning",
+			message
+		}) });
+	} catch (error) {
+		sink({
+			code: "image/jpx-undecodable",
+			severity: "warning",
+			message: `JPXDecode image could not be decoded (${error instanceof Error ? error.message : String(error)}); skipping this image`
+		});
+		return;
+	}
+	const kind = jpeg2000ChannelKind(image, dict, resolver, sink);
+	const required = kind === "cmyk" ? 4 : kind === "rgb" ? 3 : 1;
+	if (image.components.length < required) {
+		sink({
+			code: "image/jpx-undecodable",
+			severity: "warning",
+			message: `JPXDecode image resolves to a ${kind} colour space but carries only ${String(image.components.length)} component(s); skipping this image`
+		});
+		return;
+	}
+	if (image.components.length > required) sink({
+		code: "image/jpx-extra-channels",
+		severity: "info",
+		message: `JPXDecode image carries ${String(image.components.length)} components where its colour space needs ${String(required)}; the extra channel(s) are ignored`
+	});
+	const maximum = (1 << image.bitDepth) - 1;
+	const scale = (value) => image.bitDepth === 8 ? value : Math.round(value * 255 / maximum);
+	const pixels = image.width * image.height;
+	const channels = kind === "gray" ? 1 : 3;
+	const data = new Uint8Array(pixels * channels);
+	if (kind === "cmyk") for (let i = 0; i < pixels; i++) {
+		const rgb = cmykToRgbByte(scale(image.components[0]?.[i] ?? 0) / 255, scale(image.components[1]?.[i] ?? 0) / 255, scale(image.components[2]?.[i] ?? 0) / 255, scale(image.components[3]?.[i] ?? 0) / 255);
+		data[i * 3] = rgb.r;
+		data[i * 3 + 1] = rgb.g;
+		data[i * 3 + 2] = rgb.b;
+	}
+	else for (let channel = 0; channel < channels; channel++) {
+		const plane = image.components[channel];
+		for (let i = 0; i < pixels; i++) data[i * channels + channel] = scale(plane?.[i] ?? 0);
+	}
+	const rawImage = {
+		width: image.width,
+		height: image.height,
+		channels,
+		data
+	};
+	const alpha = readSoftMaskAlpha(dict, image.width, image.height, resolver, sink);
+	const withAlpha = alpha !== void 0 ? {
+		...rawImage,
+		alpha
+	} : rawImage;
+	return {
+		format: "png",
+		bytes: encodePng(withAlpha),
+		widthPx: image.width,
+		heightPx: image.height
+	};
+}
 function readImageXObject(dict, raw, resolver, sink) {
 	if (asBool(dictGet(dict, "ImageMask") ?? dictGet(dict, "IM")) === true) {
 		sink({
@@ -178,7 +254,7 @@ function readImageXObject(dict, raw, resolver, sink) {
 		});
 		return;
 	}
-	const decoded = decodeStream(raw, dict, sink);
+	const decoded = decodeStream(raw, dict, sink, (obj) => resolver.resolve(obj));
 	if (decoded.remainingFilter === "DCTDecode") {
 		let info;
 		try {
@@ -198,6 +274,7 @@ function readImageXObject(dict, raw, resolver, sink) {
 			heightPx: info.height
 		};
 	}
+	if (decoded.remainingFilter === "JPXDecode") return readJpeg2000Image(dict, decoded.bytes, resolver, sink);
 	if (decoded.remainingFilter !== void 0) return;
 	const width = asNumber(dictGet(dict, "Width") ?? dictGet(dict, "W"));
 	const height = asNumber(dictGet(dict, "Height") ?? dictGet(dict, "H"));

package/dist/index.cjs

@@ -6,12 +6,19 @@ const require_bytes_writer = require("./bytes/writer.cjs");
 const require_diagnostics = require("./diagnostics.cjs");
 const require_bytes_flate = require("./bytes/flate.cjs");
 const require_image_ccitt = require("./image/ccitt.cjs");
+const require_image_jbig2_errors = require("./image/jbig2-errors.cjs");
+const require_image_jbig2 = require("./image/jbig2.cjs");
 const require_image_png_filter = require("./image/png-filter.cjs");
 const require_fonts = require("./fonts.cjs");
 const require_image_png_encode = require("./image/png-encode.cjs");
 const require_image_jpeg_info = require("./image/jpeg-info.cjs");
+const require_image_jpeg2000_errors = require("./image/jpeg2000-errors.cjs");
+const require_image_jp2_boxes = require("./image/jp2-boxes.cjs");
+const require_image_jpeg2000 = require("./image/jpeg2000.cjs");
 const require_matrix = require("./matrix.cjs");
 const require_image_png_decode = require("./image/png-decode.cjs");
+const require_font_registry = require("./font-registry.cjs");
+const require_math_stretch = require("./math-stretch.cjs");
 const require_math_font = require("./math-font.cjs");
 const require_measure = require("./measure.cjs");
 const require_write = require("./write.cjs");
@@ -20,6 +27,11 @@ const require_codec = require("./codec.cjs");
 const require_text_layout = require("./text-layout.cjs");
 exports.ByteReader = require_bytes_reader.ByteReader;
 exports.ByteWriter = require_bytes_writer.ByteWriter;
+exports.DEFAULT_VERTICAL_METRIC_POLICY = require_measure.DEFAULT_VERTICAL_METRIC_POLICY;
+exports.Jbig2ParseError = require_image_jbig2_errors.Jbig2ParseError;
+exports.Jbig2UnsupportedError = require_image_jbig2_errors.Jbig2UnsupportedError;
+exports.Jpeg2000ParseError = require_image_jpeg2000_errors.Jpeg2000ParseError;
+exports.Jpeg2000UnsupportedError = require_image_jpeg2000_errors.Jpeg2000UnsupportedError;
 exports.MAX_INFLATE_OUTPUT_BYTES = require_bytes_flate.MAX_INFLATE_OUTPUT_BYTES;
 exports.NOOP_DIAGNOSTIC_SINK = require_diagnostics.NOOP_DIAGNOSTIC_SINK;
 exports.PdfBytesSchema = require_codec.PdfBytesSchema;
@@ -27,10 +39,15 @@ exports.PdfEncryptedError = require_diagnostics.PdfEncryptedError;
 exports.PdfParseError = require_diagnostics.PdfParseError;
 exports.PdfPasswordRequiredError = require_diagnostics.PdfPasswordRequiredError;
 exports.STANDARD_METRICS = require_afm_widths.STANDARD_METRICS;
+exports.assembleStretchyGlyph = require_math_stretch.assembleStretchyGlyph;
 exports.concatBytes = require_bytes_writer.concatBytes;
 exports.crc32 = require_bytes_crc32.crc32;
+exports.createFontMeasurer = require_measure.createFontMeasurer;
+exports.createFontRegistry = require_font_registry.createFontRegistry;
 exports.createStandardFontMeasurer = require_measure.createStandardFontMeasurer;
 exports.decodeCcittFax = require_image_ccitt.decodeCcittFax;
+exports.decodeJbig2Embedded = require_image_jbig2.decodeJbig2Embedded;
+exports.decodeJpeg2000 = require_image_jpeg2000.decodeJpeg2000;
 exports.decodePng = require_image_png_decode.decodePng;
 exports.deflate = require_bytes_flate.deflate;
 exports.encodePng = require_image_png_encode.encodePng;
@@ -39,11 +56,16 @@ exports.inflate = require_bytes_flate.inflate;
 exports.inflateTolerant = require_bytes_flate.inflateTolerant;
 exports.isAsciiWhitespace = require_bytes_reader.isAsciiWhitespace;
 exports.loadMathFont = require_math_font.loadMathFont;
+exports.looksLikeBareCodestream = require_image_jp2_boxes.looksLikeBareCodestream;
+exports.parseJp2Container = require_image_jp2_boxes.parseJp2Container;
 exports.pdfCodec = require_codec.pdfCodec;
+exports.readJpeg2000Metadata = require_image_jpeg2000.readJpeg2000Metadata;
 exports.readJpegInfo = require_image_jpeg_info.readJpegInfo;
 exports.readPdf = require_read.readPdf;
+exports.resolveFaceWithRegistry = require_font_registry.resolveFaceWithRegistry;
 exports.resolveStandardFont = require_fonts.resolveStandardFont;
 exports.rotatePointAboutCenter = require_matrix.rotatePointAboutCenter;
+exports.scaleMathStretchConstruction = require_math_stretch.scaleMathStretchConstruction;
 exports.unfilterScanlines = require_image_png_filter.unfilterScanlines;
 exports.wrapRunsToWidth = require_text_layout.wrapRunsToWidth;
 exports.writePdf = require_write.writePdf;

package/dist/index.d.cts

@@ -3,21 +3,32 @@ import { crc32 } from "./bytes/crc32.cjs";
 import { DeflateLevel, InflateResult, MAX_INFLATE_OUTPUT_BYTES, deflate, inflate, inflateTolerant } from "./bytes/flate.cjs";
 import { ByteReader, isAsciiWhitespace } from "./bytes/reader.cjs";
 import { ByteWriter, concatBytes } from "./bytes/writer.cjs";
+import { t as GlyphInkBounds } from "./glyph-bounds-BV_Z40KS.cjs";
 import { NOOP_DIAGNOSTIC_SINK, PdfDiagnostic, PdfDiagnosticSeverity, PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError } from "./diagnostics.cjs";
 import { PdfBytesSchema, pdfCodec } from "./codec.cjs";
-import { StandardFontMeasurerOptions, TextMeasurer, UnderlineMetrics, createStandardFontMeasurer } from "./measure.cjs";
+import { n as EmbeddedFaceMetrics, r as EmbeddedFaceSubstitution, t as EmbeddedFace } from "./embedded-font-CLedn-mT.cjs";
+import { a as ResolvedFace, i as ProvidedFont, n as FontRegistryOptions, o as createFontRegistry, r as FontSubstitution, s as resolveFaceWithRegistry, t as FontRegistry } from "./font-registry-yby02snZ.cjs";
+import { DEFAULT_VERTICAL_METRIC_POLICY, FontMeasurerOptions, StandardFontMeasurerOptions, TextMeasurer, UnderlineMetrics, VerticalMetricPolicy, createFontMeasurer, createStandardFontMeasurer } from "./measure.cjs";
 import { WinAnsiSubstitution } from "./winansi.cjs";
 import { i as Point, u as rotatePointAboutCenter } from "./matrix-BHzJESll.cjs";
 import { ResolvedFont, resolveStandardFont } from "./fonts.cjs";
-import { a as MathGlyphRun, c as MathStroke, i as MathGlyphMetrics, n as MathColor, o as MathLayoutItem, r as MathFontMetrics, s as MathRule, t as MathBox } from "./math-types-Ba8qAf1p.cjs";
+import { a as MathGlyphRun, c as MathStroke, i as MathGlyphMetrics, n as MathColor, o as MathLayoutItem, r as MathFontMetrics, s as MathRule, t as MathBox } from "./math-types-YSQUTviw.cjs";
 import { PositionedFormula } from "./formula.cjs";
 import { CcittFaxImage, CcittFaxOptions, decodeCcittFax } from "./image/ccitt.cjs";
+import { n as Jbig2UnsupportedError, t as Jbig2ParseError } from "./jbig2-errors-Bj6MPxrx.cjs";
+import { Jbig2DecodeOptions, Jbig2Image, decodeJbig2Embedded } from "./image/jbig2.cjs";
+import { Jp2ChannelDefinition, Jp2ColourSpace, Jp2Container, Jp2ImageHeader, looksLikeBareCodestream, parseJp2Container } from "./image/jp2-boxes.cjs";
 import { JpegInfo, readJpegInfo } from "./image/jpeg-info.cjs";
+import { Jpeg2000ProgressionOrder, Jpeg2000QuantizationStyle, Jpeg2000Transform } from "./image/jpeg2000-codestream.cjs";
+import { Jpeg2000ParseError, Jpeg2000UnsupportedError } from "./image/jpeg2000-errors.cjs";
+import { Jpeg2000ComponentMetadata, Jpeg2000DecodeOptions, Jpeg2000Image, Jpeg2000Metadata, decodeJpeg2000, readJpeg2000Metadata } from "./image/jpeg2000.cjs";
 import { PngDecodeOptions, RawImage, decodePng } from "./image/png-decode.cjs";
 import { PngEncodeOptions, encodePng } from "./image/png-encode.cjs";
 import { PngFilterType, filterScanlines, unfilterScanlines } from "./image/png-filter.cjs";
 import { ReadPdfOptions, readPdf } from "./read.cjs";
 import { WritePdfOptions, writePdf } from "./write.cjs";
+import { a as MathGlyphPart, c as MathVariants, n as MathGlyphAssembly, o as MathGlyphVariant, r as MathGlyphConstruction } from "./math-table-gFNB8DmQ.cjs";
+import { a as assembleStretchyGlyph, i as MathStretchPlacement, n as MathStretchConstruction, o as scaleMathStretchConstruction, r as MathStretchOptions, t as MathStretchAxis } from "./math-stretch-DXWjs8gL.cjs";
 import { LoadedMathFont, MathFont, MathFontDescriptorMetrics, loadMathFont } from "./math-font.cjs";
 import { StyledFragment, StyledRun, WrapOptions, WrappedLine, wrapRunsToWidth } from "./text-layout.cjs";
-export { ByteReader, ByteWriter, type CcittFaxImage, type CcittFaxOptions, type DeflateLevel, type FontMetrics, type InflateResult, type JpegInfo, type LoadedMathFont, MAX_INFLATE_OUTPUT_BYTES, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphMetrics, type MathGlyphRun, type MathLayoutItem, type MathRule, type MathStroke, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError, type PngDecodeOptions, type PngEncodeOptions, type PngFilterType, type Point, type PositionedFormula, type RawImage, type ReadPdfOptions, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, concatBytes, crc32, createStandardFontMeasurer, decodeCcittFax, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, loadMathFont, pdfCodec, readJpegInfo, readPdf, resolveStandardFont, rotatePointAboutCenter, unfilterScanlines, wrapRunsToWidth, writePdf };
+export { ByteReader, ByteWriter, type CcittFaxImage, type CcittFaxOptions, DEFAULT_VERTICAL_METRIC_POLICY, type DeflateLevel, type EmbeddedFace, type EmbeddedFaceMetrics, type EmbeddedFaceSubstitution, type FontMeasurerOptions, type FontMetrics, type FontRegistry, type FontRegistryOptions, type FontSubstitution, type GlyphInkBounds, type InflateResult, type Jbig2DecodeOptions, type Jbig2Image, Jbig2ParseError, Jbig2UnsupportedError, type Jp2ChannelDefinition, type Jp2ColourSpace, type Jp2Container, type Jp2ImageHeader, type Jpeg2000ComponentMetadata, type Jpeg2000DecodeOptions, type Jpeg2000Image, type Jpeg2000Metadata, Jpeg2000ParseError, type Jpeg2000ProgressionOrder, type Jpeg2000QuantizationStyle, type Jpeg2000Transform, Jpeg2000UnsupportedError, type JpegInfo, type LoadedMathFont, MAX_INFLATE_OUTPUT_BYTES, type MathBox, type MathColor, type MathFont, type MathFontDescriptorMetrics, type MathFontMetrics, type MathGlyphAssembly, type MathGlyphConstruction, type MathGlyphMetrics, type MathGlyphPart, type MathGlyphRun, type MathGlyphVariant, type MathLayoutItem, type MathRule, type MathStretchAxis, type MathStretchConstruction, type MathStretchOptions, type MathStretchPlacement, type MathStroke, type MathVariants, NOOP_DIAGNOSTIC_SINK, PdfBytesSchema, type PdfDiagnostic, type PdfDiagnosticSeverity, type PdfDiagnosticSink, PdfEncryptedError, PdfParseError, PdfPasswordRequiredError, type PngDecodeOptions, type PngEncodeOptions, type PngFilterType, type Point, type PositionedFormula, type ProvidedFont, type RawImage, type ReadPdfOptions, type ResolvedFace, type ResolvedFont, STANDARD_METRICS, type StandardFontMeasurerOptions, type StandardFontName, type StyledFragment, type StyledRun, type TextMeasurer, type UnderlineMetrics, type VerticalMetricPolicy, type WinAnsiSubstitution, type WrapOptions, type WrappedLine, type WritePdfOptions, assembleStretchyGlyph, concatBytes, crc32, createFontMeasurer, createFontRegistry, createStandardFontMeasurer, decodeCcittFax, decodeJbig2Embedded, decodeJpeg2000, decodePng, deflate, encodePng, filterScanlines, inflate, inflateTolerant, isAsciiWhitespace, loadMathFont, looksLikeBareCodestream, parseJp2Container, pdfCodec, readJpeg2000Metadata, readJpegInfo, readPdf, resolveFaceWithRegistry, resolveStandardFont, rotatePointAboutCenter, scaleMathStretchConstruction, unfilterScanlines, wrapRunsToWidth, writePdf };