pdf-parser.js 5.2.26 → 5.2.28

package/dist/image/png-decode.js

@@ -3,30 +3,39 @@ import { inflateTolerant } from "../bytes/flate.js";
 import { unfilterScanlines } from "./png-filter.js";
 import { crc32 } from "../bytes/crc32.js";
 //#region src/image/png-decode.ts
+const PNG_SIGNATURE_HIGH_BIT_MARKER = 137;
+const PNG_SIGNATURE_P = 80;
+const PNG_SIGNATURE_N = 78;
+const PNG_SIGNATURE_G = 71;
+const PNG_SIGNATURE_CR = 13;
+const PNG_SIGNATURE_LF = 10;
 const PNG_SIGNATURE = [
-	137,
-	80,
-	78,
-	71,
-	13,
-	10,
+	PNG_SIGNATURE_HIGH_BIT_MARKER,
+	PNG_SIGNATURE_P,
+	PNG_SIGNATURE_N,
+	PNG_SIGNATURE_G,
+	PNG_SIGNATURE_CR,
+	PNG_SIGNATURE_LF,
 	26,
-	10
+	PNG_SIGNATURE_LF
 ];
 function requireDataView(bytes) {
 	return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 }
+const PNG_CHUNK_LENGTH_SIZE = 4;
+const PNG_CHUNK_CRC_SIZE = 4;
+const PNG_CHUNK_HEADER_SIZE = 8;
 function readChunks(bytes, onWarning) {
 	const chunks = [];
 	const view = requireDataView(bytes);
 	let offset = PNG_SIGNATURE.length;
-	while (offset + 8 <= bytes.length) {
+	while (offset + PNG_CHUNK_HEADER_SIZE <= bytes.length) {
 		const length = view.getUint32(offset);
-		const typeBytes = bytes.subarray(offset + 4, offset + 8);
+		const typeBytes = bytes.subarray(offset + PNG_CHUNK_LENGTH_SIZE, offset + PNG_CHUNK_HEADER_SIZE);
 		const type = new TextDecoder("latin1").decode(typeBytes);
-		const dataStart = offset + 8;
+		const dataStart = offset + PNG_CHUNK_HEADER_SIZE;
 		const dataEnd = dataStart + length;
-		if (dataEnd + 4 > bytes.length) throw new Error(`PNG chunk '${type}' declares a length that runs past the end of the file`);
+		if (dataEnd + PNG_CHUNK_CRC_SIZE > bytes.length) throw new Error(`PNG chunk '${type}' declares a length that runs past the end of the file`);
 		const data = bytes.subarray(dataStart, dataEnd);
 		if (onWarning !== void 0) {
 			if (view.getUint32(dataEnd) !== crc32(concatBytes([typeBytes, data]))) onWarning(`PNG chunk '${type}' failed its CRC32 check`);
@@ -35,42 +44,53 @@ function readChunks(bytes, onWarning) {
 			type,
 			data
 		});
-		offset = dataEnd + 4;
+		offset = dataEnd + PNG_CHUNK_CRC_SIZE;
 		if (type === "IEND") break;
 	}
 	return chunks;
 }
+const IHDR_HEIGHT_OFFSET = 4;
 function parseIhdr(data) {
 	const view = requireDataView(data);
 	return {
 		width: view.getUint32(0),
-		height: view.getUint32(4),
+		height: view.getUint32(IHDR_HEIGHT_OFFSET),
 		bitDepth: data[8],
 		colorType: data[9],
 		interlace: data[12]
 	};
 }
+const PNG_COLOR_TYPE_GRAYSCALE = 0;
+const PNG_COLOR_TYPE_TRUECOLOR = 2;
+const PNG_COLOR_TYPE_INDEXED = 3;
+const PNG_COLOR_TYPE_GRAYSCALE_ALPHA = 4;
+const PNG_COLOR_TYPE_TRUECOLOR_ALPHA = 6;
+const PNG_CHANNELS_TRUECOLOR = 3;
+const PNG_CHANNELS_TRUECOLOR_ALPHA = 4;
 function channelsForColorType(colorType) {
-	if (colorType === 0) return 1;
-	if (colorType === 2) return 3;
-	if (colorType === 3) return 1;
-	if (colorType === 4) return 2;
-	if (colorType === 6) return 4;
+	if (colorType === PNG_COLOR_TYPE_GRAYSCALE) return 1;
+	if (colorType === PNG_COLOR_TYPE_TRUECOLOR) return PNG_CHANNELS_TRUECOLOR;
+	if (colorType === PNG_COLOR_TYPE_INDEXED) return 1;
+	if (colorType === PNG_COLOR_TYPE_GRAYSCALE_ALPHA) return 2;
+	if (colorType === PNG_COLOR_TYPE_TRUECOLOR_ALPHA) return PNG_CHANNELS_TRUECOLOR_ALPHA;
 	throw new Error(`unsupported PNG colour type: ${colorType}`);
 }
+const BITS_PER_BYTE = 8;
 function filterBpp(bitDepth, channels) {
-	return Math.max(1, Math.ceil(bitDepth * channels / 8));
+	return Math.max(1, Math.ceil(bitDepth * channels / BITS_PER_BYTE));
 }
+const PNG_BIT_DEPTH_16 = 16;
+const BYTE_INDEX_SHIFT = 3;
 function unpackRow(rowBytes, width, channels, bitDepth) {
 	const sampleCount = width * channels;
 	const samples = Array.from({ length: sampleCount });
-	if (bitDepth === 16) for (let i = 0; i < sampleCount; i++) samples[i] = rowBytes[i * 2];
+	if (bitDepth === PNG_BIT_DEPTH_16) for (let i = 0; i < sampleCount; i++) samples[i] = rowBytes[i * 2];
 	else {
 		const mask = (1 << bitDepth) - 1;
 		for (let i = 0; i < sampleCount; i++) {
 			const bitOffset = i * bitDepth;
-			const byteIndex = bitOffset >> 3;
-			const shift = 8 - bitDepth - (bitOffset & 7);
+			const byteIndex = bitOffset >> BYTE_INDEX_SHIFT;
+			const shift = BITS_PER_BYTE - bitDepth - (bitOffset & 7);
 			samples[i] = rowBytes[byteIndex] >> shift & mask;
 		}
 	}
@@ -79,18 +99,20 @@ function unpackRow(rowBytes, width, channels, bitDepth) {
 function readTrnsGrayValue(trns) {
 	return requireDataView(trns).getUint16(0);
 }
+const TRNS_RGB_BLUE_OFFSET = 4;
 function readTrnsRgbKey(trns) {
 	const view = requireDataView(trns);
 	return [
 		view.getUint16(0),
 		view.getUint16(2),
-		view.getUint16(4)
+		view.getUint16(TRNS_RGB_BLUE_OFFSET)
 	];
 }
+const MAX_BYTE_VALUE = 255;
 function scaleToByte(sample, bitDepth) {
-	if (bitDepth === 16) return sample;
+	if (bitDepth === PNG_BIT_DEPTH_16) return sample;
 	const maxSample = (1 << bitDepth) - 1;
-	return Math.round(sample * 255 / maxSample);
+	return Math.round(sample * MAX_BYTE_VALUE / maxSample);
 }
 function decodePng(bytes, options = {}) {
 	for (let i = 0; i < PNG_SIGNATURE.length; i++) if (bytes[i] !== PNG_SIGNATURE[i]) throw new Error("not a valid PNG file: bad signature");
@@ -101,23 +123,24 @@ function decodePng(bytes, options = {}) {
 	if (ihdr.interlace !== 0) throw new Error("Adam7-interlaced PNG images are not supported");
 	const channels = channelsForColorType(ihdr.colorType);
 	const bpp = filterBpp(ihdr.bitDepth, channels);
-	const bytesPerRow = Math.ceil(ihdr.width * channels * ihdr.bitDepth / 8);
+	const bytesPerRow = Math.ceil(ihdr.width * channels * ihdr.bitDepth / BITS_PER_BYTE);
 	const idatChunks = chunks.filter((c) => c.type === "IDAT").map((c) => c.data);
 	if (idatChunks.length === 0) throw new Error("PNG file has no IDAT chunks");
 	const compressed = concatBytes(idatChunks);
 	const { bytes: inflated, recovered } = inflateTolerant(compressed);
 	if (recovered && options.onWarning !== void 0) options.onWarning("PNG IDAT stream required tolerant recovery (truncated or malformed)");
 	const unfiltered = unfilterScanlines(inflated, ihdr.height, bytesPerRow, bpp);
-	const palette = ihdr.colorType === 3 ? chunks.find((c) => c.type === "PLTE")?.data : void 0;
-	if (ihdr.colorType === 3 && palette === void 0) throw new Error("indexed-colour PNG has no PLTE chunk");
+	const palette = ihdr.colorType === PNG_COLOR_TYPE_INDEXED ? chunks.find((c) => c.type === "PLTE")?.data : void 0;
+	if (ihdr.colorType === PNG_COLOR_TYPE_INDEXED && palette === void 0) throw new Error("indexed-colour PNG has no PLTE chunk");
 	const trns = chunks.find((c) => c.type === "tRNS")?.data;
 	return buildRawImage(ihdr, channels, bytesPerRow, unfiltered, palette, trns);
 }
+const ALPHA_SAMPLE_INDEX_IN_RGBA = 3;
 function buildRawImage(ihdr, channels, bytesPerRow, unfiltered, palette, trns) {
 	const { width, height, bitDepth, colorType } = ihdr;
-	const outChannels = colorType === 0 || colorType === 4 ? 1 : 3;
+	const outChannels = colorType === 0 || colorType === PNG_COLOR_TYPE_GRAYSCALE_ALPHA ? 1 : PNG_CHANNELS_TRUECOLOR;
 	const data = new Uint8Array(width * height * outChannels);
-	const alpha = colorType === 4 || colorType === 6 || trns !== void 0 ? new Uint8Array(width * height).fill(255) : void 0;
+	const alpha = colorType === PNG_COLOR_TYPE_GRAYSCALE_ALPHA || colorType === PNG_COLOR_TYPE_TRUECOLOR_ALPHA || trns !== void 0 ? new Uint8Array(width * height).fill(MAX_BYTE_VALUE) : void 0;
 	const trnsGray = colorType === 0 && trns !== void 0 ? readTrnsGrayValue(trns) : void 0;
 	const trnsRgb = colorType === 2 && trns !== void 0 ? readTrnsRgbKey(trns) : void 0;
 	for (let y = 0; y < height; y++) {
@@ -130,7 +153,7 @@ function buildRawImage(ihdr, channels, bytesPerRow, unfiltered, palette, trns) {
 			if (colorType === 0) {
 				const g = samples[pixelBase];
 				data[outBase] = scaleToByte(g, bitDepth);
-				if (alpha !== void 0 && trnsGray !== void 0) alpha[alphaIndex] = g === trnsGray ? 0 : 255;
+				if (alpha !== void 0 && trnsGray !== void 0) alpha[alphaIndex] = g === trnsGray ? 0 : MAX_BYTE_VALUE;
 			} else if (colorType === 2) {
 				const r = samples[pixelBase];
 				const g = samples[pixelBase + 1];
@@ -140,15 +163,15 @@ function buildRawImage(ihdr, channels, bytesPerRow, unfiltered, palette, trns) {
 				data[outBase + 2] = b;
 				if (alpha !== void 0 && trnsRgb !== void 0) {
 					const [kr, kg, kb] = trnsRgb;
-					alpha[alphaIndex] = r === kr && g === kg && b === kb ? 0 : 255;
+					alpha[alphaIndex] = r === kr && g === kg && b === kb ? 0 : MAX_BYTE_VALUE;
 				}
-			} else if (colorType === 3) {
+			} else if (colorType === PNG_COLOR_TYPE_INDEXED) {
 				const index = samples[pixelBase];
-				data[outBase] = palette[index * 3];
-				data[outBase + 1] = palette[index * 3 + 1];
-				data[outBase + 2] = palette[index * 3 + 2];
-				if (alpha !== void 0 && trns !== void 0) alpha[alphaIndex] = index < trns.length ? trns[index] : 255;
-			} else if (colorType === 4) {
+				data[outBase] = palette[index * PNG_CHANNELS_TRUECOLOR];
+				data[outBase + 1] = palette[index * PNG_CHANNELS_TRUECOLOR + 1];
+				data[outBase + 2] = palette[index * PNG_CHANNELS_TRUECOLOR + 2];
+				if (alpha !== void 0 && trns !== void 0) alpha[alphaIndex] = index < trns.length ? trns[index] : MAX_BYTE_VALUE;
+			} else if (colorType === PNG_COLOR_TYPE_GRAYSCALE_ALPHA) {
 				const g = samples[pixelBase];
 				const a = samples[pixelBase + 1];
 				data[outBase] = scaleToByte(g, bitDepth);
@@ -157,7 +180,7 @@ function buildRawImage(ihdr, channels, bytesPerRow, unfiltered, palette, trns) {
 				data[outBase] = samples[pixelBase];
 				data[outBase + 1] = samples[pixelBase + 1];
 				data[outBase + 2] = samples[pixelBase + 2];
-				if (alpha !== void 0) alpha[alphaIndex] = samples[pixelBase + 3];
+				if (alpha !== void 0) alpha[alphaIndex] = samples[pixelBase + ALPHA_SAMPLE_INDEX_IN_RGBA];
 			}
 		}
 	}

package/dist/image/png-filter.cjs

@@ -1,5 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/image/png-filter.ts
+const FILTER_TYPE_NONE = 0;
+const FILTER_TYPE_SUB = 1;
+const FILTER_TYPE_UP = 2;
+const FILTER_TYPE_AVERAGE = 3;
+const FILTER_TYPE_PAETH = 4;
+const BYTE_MASK = 255;
 function paethPredictor(a, b, c) {
 	const p = a + b - c;
 	const pa = Math.abs(p - a);
@@ -10,13 +16,13 @@ function paethPredictor(a, b, c) {
 	return c;
 }
 function isPngFilterType(value) {
-	return value === 0 || value === 1 || value === 2 || value === 3 || value === 4;
+	return value === FILTER_TYPE_NONE || value === FILTER_TYPE_SUB || value === FILTER_TYPE_UP || value === FILTER_TYPE_AVERAGE || value === FILTER_TYPE_PAETH;
 }
 function predictorValue(filterType, a, b, c) {
-	if (filterType === 1) return a;
-	if (filterType === 2) return b;
-	if (filterType === 3) return Math.floor((a + b) / 2);
-	if (filterType === 4) return paethPredictor(a, b, c);
+	if (filterType === FILTER_TYPE_SUB) return a;
+	if (filterType === FILTER_TYPE_UP) return b;
+	if (filterType === FILTER_TYPE_AVERAGE) return Math.floor((a + b) / 2);
+	if (filterType === FILTER_TYPE_PAETH) return paethPredictor(a, b, c);
 	return 0;
 }
 function unfilterScanlines(data, height, bytesPerRow, bpp) {
@@ -34,14 +40,16 @@ function unfilterScanlines(data, height, bytesPerRow, bpp) {
 			const a = x >= bpp ? out[outRowStart + x - bpp] : 0;
 			const b = prevOutRowStart === void 0 ? 0 : out[prevOutRowStart + x];
 			const c = x >= bpp && prevOutRowStart !== void 0 ? out[prevOutRowStart + x - bpp] : 0;
-			out[outRowStart + x] = raw + predictorValue(filterByte, a, b, c) & 255;
+			out[outRowStart + x] = raw + predictorValue(filterByte, a, b, c) & BYTE_MASK;
 		}
 	}
 	return out;
 }
+const BYTE_RADIX = 256;
+const SIGNED_BYTE_THRESHOLD = 128;
 function sumOfAbsSigned(bytes) {
 	let sum = 0;
-	for (const byte of bytes) sum += byte < 128 ? byte : 256 - byte;
+	for (const byte of bytes) sum += byte < SIGNED_BYTE_THRESHOLD ? byte : BYTE_RADIX - byte;
 	return sum;
 }
 function filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, filterType, out, outOffset) {
@@ -50,15 +58,15 @@ function filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, filterType
 		const a = x >= bpp ? raw[rowStart + x - bpp] : 0;
 		const b = prevRowStart === void 0 ? 0 : raw[prevRowStart + x];
 		const c = x >= bpp && prevRowStart !== void 0 ? raw[prevRowStart + x - bpp] : 0;
-		out[outOffset + x] = rawByte - predictorValue(filterType, a, b, c) & 255;
+		out[outOffset + x] = rawByte - predictorValue(filterType, a, b, c) & BYTE_MASK;
 	}
 }
 const ALL_FILTER_TYPES = [
-	0,
-	1,
-	2,
-	3,
-	4
+	FILTER_TYPE_NONE,
+	FILTER_TYPE_SUB,
+	FILTER_TYPE_UP,
+	FILTER_TYPE_AVERAGE,
+	FILTER_TYPE_PAETH
 ];
 function filterScanlines(raw, height, bytesPerRow, bpp, strategy = "adaptive") {
 	const stride = bytesPerRow + 1;
@@ -70,10 +78,10 @@ function filterScanlines(raw, height, bytesPerRow, bpp, strategy = "adaptive") {
 		const outRowStart = y * stride;
 		if (strategy === "none") {
 			out[outRowStart] = 0;
-			filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, 0, out, outRowStart + 1);
+			filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, FILTER_TYPE_NONE, out, outRowStart + 1);
 			continue;
 		}
-		let bestType = 0;
+		let bestType = FILTER_TYPE_NONE;
 		let bestSum = Number.POSITIVE_INFINITY;
 		let best;
 		for (const filterType of ALL_FILTER_TYPES) {

package/dist/image/png-filter.js

@@ -1,4 +1,10 @@
 //#region src/image/png-filter.ts
+const FILTER_TYPE_NONE = 0;
+const FILTER_TYPE_SUB = 1;
+const FILTER_TYPE_UP = 2;
+const FILTER_TYPE_AVERAGE = 3;
+const FILTER_TYPE_PAETH = 4;
+const BYTE_MASK = 255;
 function paethPredictor(a, b, c) {
 	const p = a + b - c;
 	const pa = Math.abs(p - a);
@@ -9,13 +15,13 @@ function paethPredictor(a, b, c) {
 	return c;
 }
 function isPngFilterType(value) {
-	return value === 0 || value === 1 || value === 2 || value === 3 || value === 4;
+	return value === FILTER_TYPE_NONE || value === FILTER_TYPE_SUB || value === FILTER_TYPE_UP || value === FILTER_TYPE_AVERAGE || value === FILTER_TYPE_PAETH;
 }
 function predictorValue(filterType, a, b, c) {
-	if (filterType === 1) return a;
-	if (filterType === 2) return b;
-	if (filterType === 3) return Math.floor((a + b) / 2);
-	if (filterType === 4) return paethPredictor(a, b, c);
+	if (filterType === FILTER_TYPE_SUB) return a;
+	if (filterType === FILTER_TYPE_UP) return b;
+	if (filterType === FILTER_TYPE_AVERAGE) return Math.floor((a + b) / 2);
+	if (filterType === FILTER_TYPE_PAETH) return paethPredictor(a, b, c);
 	return 0;
 }
 function unfilterScanlines(data, height, bytesPerRow, bpp) {
@@ -33,14 +39,16 @@ function unfilterScanlines(data, height, bytesPerRow, bpp) {
 			const a = x >= bpp ? out[outRowStart + x - bpp] : 0;
 			const b = prevOutRowStart === void 0 ? 0 : out[prevOutRowStart + x];
 			const c = x >= bpp && prevOutRowStart !== void 0 ? out[prevOutRowStart + x - bpp] : 0;
-			out[outRowStart + x] = raw + predictorValue(filterByte, a, b, c) & 255;
+			out[outRowStart + x] = raw + predictorValue(filterByte, a, b, c) & BYTE_MASK;
 		}
 	}
 	return out;
 }
+const BYTE_RADIX = 256;
+const SIGNED_BYTE_THRESHOLD = 128;
 function sumOfAbsSigned(bytes) {
 	let sum = 0;
-	for (const byte of bytes) sum += byte < 128 ? byte : 256 - byte;
+	for (const byte of bytes) sum += byte < SIGNED_BYTE_THRESHOLD ? byte : BYTE_RADIX - byte;
 	return sum;
 }
 function filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, filterType, out, outOffset) {
@@ -49,15 +57,15 @@ function filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, filterType
 		const a = x >= bpp ? raw[rowStart + x - bpp] : 0;
 		const b = prevRowStart === void 0 ? 0 : raw[prevRowStart + x];
 		const c = x >= bpp && prevRowStart !== void 0 ? raw[prevRowStart + x - bpp] : 0;
-		out[outOffset + x] = rawByte - predictorValue(filterType, a, b, c) & 255;
+		out[outOffset + x] = rawByte - predictorValue(filterType, a, b, c) & BYTE_MASK;
 	}
 }
 const ALL_FILTER_TYPES = [
-	0,
-	1,
-	2,
-	3,
-	4
+	FILTER_TYPE_NONE,
+	FILTER_TYPE_SUB,
+	FILTER_TYPE_UP,
+	FILTER_TYPE_AVERAGE,
+	FILTER_TYPE_PAETH
 ];
 function filterScanlines(raw, height, bytesPerRow, bpp, strategy = "adaptive") {
 	const stride = bytesPerRow + 1;
@@ -69,10 +77,10 @@ function filterScanlines(raw, height, bytesPerRow, bpp, strategy = "adaptive") {
 		const outRowStart = y * stride;
 		if (strategy === "none") {
 			out[outRowStart] = 0;
-			filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, 0, out, outRowStart + 1);
+			filterRowInto(raw, rowStart, prevRowStart, bytesPerRow, bpp, FILTER_TYPE_NONE, out, outRowStart + 1);
 			continue;
 		}
-		let bestType = 0;
+		let bestType = FILTER_TYPE_NONE;
 		let bestSum = Number.POSITIVE_INFINITY;
 		let best;
 		for (const filterType of ALL_FILTER_TYPES) {

package/dist/images-read.cjs

@@ -4,10 +4,14 @@ const require_filters = require("./filters.cjs");
 const require_image_jpeg2000 = require("./image/jpeg2000.cjs");
 let byte_codec = require("byte-codec");
 //#region src/images-read.ts
+const CMYK_COMPONENT_COUNT = 4;
+const RGB_CHANNEL_COUNT = 3;
+const MAX_BYTE_VALUE = 255;
+const BITS_PER_BYTE = 8;
 function componentsOf(cs) {
 	if (cs.kind === "gray") return 1;
-	if (cs.kind === "cmyk") return 4;
-	return 3;
+	if (cs.kind === "cmyk") return CMYK_COMPONENT_COUNT;
+	return RGB_CHANNEL_COUNT;
 }
 function resolveColorSpace(csObj, resolver, sink) {
 	const resolved = resolver.resolve(csObj);
@@ -31,7 +35,7 @@ function resolveColorSpace(csObj, resolver, sink) {
 		const streamObj = resolver.resolve(arr[1]);
 		const n = streamObj?.kind === "stream" ? require_objects.asNumber(require_objects.dictGet(streamObj.dict, "N")) : void 0;
 		if (n === 1) return { kind: "gray" };
-		if (n === 4) return { kind: "cmyk" };
+		if (n === CMYK_COMPONENT_COUNT) return { kind: "cmyk" };
 		return { kind: "rgb" };
 	}
 	if (family === "Indexed") {
@@ -55,9 +59,9 @@ function resolveColorSpace(csObj, resolver, sink) {
 	};
 }
 function unpackSamples(data, width, height, componentsPerPixel, bitsPerComponent) {
-	if (bitsPerComponent === 8) return Array.from(data.subarray(0, width * height * componentsPerPixel));
+	if (bitsPerComponent === BITS_PER_BYTE) return Array.from(data.subarray(0, width * height * componentsPerPixel));
 	const samplesPerRow = width * componentsPerPixel;
-	const bytesPerRow = Math.ceil(samplesPerRow * bitsPerComponent / 8);
+	const bytesPerRow = Math.ceil(samplesPerRow * bitsPerComponent / BITS_PER_BYTE);
 	const out = [];
 	for (let row = 0; row < height; row++) {
 		const rowStart = row * bytesPerRow;
@@ -65,8 +69,8 @@ function unpackSamples(data, width, height, componentsPerPixel, bitsPerComponent
 		for (let s = 0; s < samplesPerRow; s++) {
 			let value = 0;
 			for (let b = 0; b < bitsPerComponent; b++) {
-				const byteIndex = rowStart + Math.floor(bitPos / 8);
-				const bitIndex = 7 - bitPos % 8;
+				const byteIndex = rowStart + Math.floor(bitPos / BITS_PER_BYTE);
+				const bitIndex = 7 - bitPos % BITS_PER_BYTE;
 				const bit = (data[byteIndex] ?? 0) >> bitIndex & 1;
 				value = value << 1 | bit;
 				bitPos++;
@@ -78,13 +82,13 @@ function unpackSamples(data, width, height, componentsPerPixel, bitsPerComponent
 }
 function scaleToByte(value, maxValue, inverted) {
 	const v = inverted ? maxValue - value : value;
-	return maxValue === 255 ? v : Math.round(v * 255 / maxValue);
+	return maxValue === MAX_BYTE_VALUE ? v : Math.round(v * MAX_BYTE_VALUE / maxValue);
 }
 function cmykToRgbByte(c, m, y, k) {
 	return {
-		r: Math.round(255 * (1 - c) * (1 - k)),
-		g: Math.round(255 * (1 - m) * (1 - k)),
-		b: Math.round(255 * (1 - y) * (1 - k))
+		r: Math.round(MAX_BYTE_VALUE * (1 - c) * (1 - k)),
+		g: Math.round(MAX_BYTE_VALUE * (1 - m) * (1 - k)),
+		b: Math.round(MAX_BYTE_VALUE * (1 - y) * (1 - k))
 	};
 }
 function sampleFromPalette(base, lookup, offset) {
@@ -96,7 +100,7 @@ function sampleFromPalette(base, lookup, offset) {
 			b: g
 		};
 	}
-	if (base.kind === "cmyk") return cmykToRgbByte((lookup[offset] ?? 0) / 255, (lookup[offset + 1] ?? 0) / 255, (lookup[offset + 2] ?? 0) / 255, (lookup[offset + 3] ?? 0) / 255);
+	if (base.kind === "cmyk") return cmykToRgbByte((lookup[offset] ?? 0) / MAX_BYTE_VALUE, (lookup[offset + 1] ?? 0) / MAX_BYTE_VALUE, (lookup[offset + 2] ?? 0) / MAX_BYTE_VALUE, (lookup[offset + 3] ?? 0) / MAX_BYTE_VALUE);
 	return {
 		r: lookup[offset] ?? 0,
 		g: lookup[offset + 1] ?? 0,
@@ -108,7 +112,7 @@ function buildRawImage(data, width, height, bitsPerComponent, colorSpace, invert
 	if (colorSpace.kind === "indexed") {
 		const indices = unpackSamples(data, width, height, 1, bitsPerComponent);
 		const baseComponents = componentsOf(colorSpace.base);
-		const out = new Uint8Array(width * height * (colorSpace.base.kind === "gray" ? 1 : 3));
+		const out = new Uint8Array(width * height * (colorSpace.base.kind === "gray" ? 1 : RGB_CHANNEL_COUNT));
 		let outIdx = 0;
 		for (const index of indices) {
 			const rgb = sampleFromPalette(colorSpace.base, colorSpace.lookup, index * baseComponents);
@@ -122,7 +126,7 @@ function buildRawImage(data, width, height, bitsPerComponent, colorSpace, invert
 		return {
 			width,
 			height,
-			channels: colorSpace.base.kind === "gray" ? 1 : 3,
+			channels: colorSpace.base.kind === "gray" ? 1 : RGB_CHANNEL_COUNT,
 			data: out
 		};
 	}
@@ -136,26 +140,27 @@ function buildRawImage(data, width, height, bitsPerComponent, colorSpace, invert
 		};
 	}
 	if (colorSpace.kind === "rgb") {
-		const samples = unpackSamples(data, width, height, 3, bitsPerComponent);
+		const samples = unpackSamples(data, width, height, RGB_CHANNEL_COUNT, bitsPerComponent);
+		const out = Uint8Array.from(samples, (v) => scaleToByte(v, maxValue, inverted));
 		return {
 			width,
 			height,
-			channels: 3,
-			data: Uint8Array.from(samples, (v) => scaleToByte(v, maxValue, inverted))
+			channels: RGB_CHANNEL_COUNT,
+			data: out
 		};
 	}
-	const samples = unpackSamples(data, width, height, 4, bitsPerComponent);
-	const out = new Uint8Array(width * height * 3);
+	const samples = unpackSamples(data, width, height, CMYK_COMPONENT_COUNT, bitsPerComponent);
+	const out = new Uint8Array(width * height * RGB_CHANNEL_COUNT);
 	for (let px = 0; px < width * height; px++) {
-		const rgb = cmykToRgbByte(scaleToByte(samples[px * 4] ?? 0, maxValue, inverted) / 255, scaleToByte(samples[px * 4 + 1] ?? 0, maxValue, inverted) / 255, scaleToByte(samples[px * 4 + 2] ?? 0, maxValue, inverted) / 255, scaleToByte(samples[px * 4 + 3] ?? 0, maxValue, inverted) / 255);
-		out[px * 3] = rgb.r;
-		out[px * 3 + 1] = rgb.g;
-		out[px * 3 + 2] = rgb.b;
+		const rgb = cmykToRgbByte(scaleToByte(samples[px * CMYK_COMPONENT_COUNT] ?? 0, maxValue, inverted) / MAX_BYTE_VALUE, scaleToByte(samples[px * CMYK_COMPONENT_COUNT + 1] ?? 0, maxValue, inverted) / MAX_BYTE_VALUE, scaleToByte(samples[px * CMYK_COMPONENT_COUNT + 2] ?? 0, maxValue, inverted) / MAX_BYTE_VALUE, scaleToByte(samples[px * CMYK_COMPONENT_COUNT + 3] ?? 0, maxValue, inverted) / MAX_BYTE_VALUE);
+		out[px * RGB_CHANNEL_COUNT] = rgb.r;
+		out[px * RGB_CHANNEL_COUNT + 1] = rgb.g;
+		out[px * RGB_CHANNEL_COUNT + 2] = rgb.b;
 	}
 	return {
 		width,
 		height,
-		channels: 3,
+		channels: RGB_CHANNEL_COUNT,
 		data: out
 	};
 }
@@ -166,8 +171,8 @@ function readSoftMaskAlpha(dict, width, height, resolver, sink) {
 	if (decoded.remainingFilter !== void 0) return;
 	const smaskWidth = require_objects.asNumber(require_objects.dictGet(smaskObj.dict, "Width")) ?? width;
 	const smaskHeight = require_objects.asNumber(require_objects.dictGet(smaskObj.dict, "Height")) ?? height;
-	const smaskBpc = require_objects.asNumber(require_objects.dictGet(smaskObj.dict, "BitsPerComponent")) ?? 8;
-	if (smaskWidth !== width || smaskHeight !== height || smaskBpc !== 8) return;
+	const smaskBpc = require_objects.asNumber(require_objects.dictGet(smaskObj.dict, "BitsPerComponent")) ?? BITS_PER_BYTE;
+	if (smaskWidth !== width || smaskHeight !== height || smaskBpc !== BITS_PER_BYTE) return;
 	return decoded.bytes.subarray(0, width * height);
 }
 function jpeg2000ChannelKind(image, dict, resolver, sink) {
@@ -179,7 +184,7 @@ function jpeg2000ChannelKind(image, dict, resolver, sink) {
 	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";
+	return image.components.length >= CMYK_COMPONENT_COUNT ? "cmyk" : image.components.length >= RGB_CHANNEL_COUNT ? "rgb" : "gray";
 }
 function readJpeg2000Image(dict, raw, resolver, sink) {
 	let image;
@@ -205,7 +210,7 @@ function readJpeg2000Image(dict, raw, resolver, sink) {
 		return;
 	}
 	const kind = jpeg2000ChannelKind(image, dict, resolver, sink);
-	const required = kind === "cmyk" ? 4 : kind === "rgb" ? 3 : 1;
+	const required = kind === "cmyk" ? CMYK_COMPONENT_COUNT : kind === "rgb" ? RGB_CHANNEL_COUNT : 1;
 	if (image.components.length < required) {
 		sink({
 			code: "image/jpx-undecodable",
@@ -220,15 +225,15 @@ function readJpeg2000Image(dict, raw, resolver, sink) {
 		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 scale = (value) => image.bitDepth === BITS_PER_BYTE ? value : Math.round(value * MAX_BYTE_VALUE / maximum);
 	const pixels = image.width * image.height;
-	const channels = kind === "gray" ? 1 : 3;
+	const channels = kind === "gray" ? 1 : RGB_CHANNEL_COUNT;
 	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;
+		const rgb = cmykToRgbByte(scale(image.components[0]?.[i] ?? 0) / MAX_BYTE_VALUE, scale(image.components[1]?.[i] ?? 0) / MAX_BYTE_VALUE, scale(image.components[2]?.[i] ?? 0) / MAX_BYTE_VALUE, scale(image.components[3]?.[i] ?? 0) / MAX_BYTE_VALUE);
+		data[i * RGB_CHANNEL_COUNT] = rgb.r;
+		data[i * RGB_CHANNEL_COUNT + 1] = rgb.g;
+		data[i * RGB_CHANNEL_COUNT + 2] = rgb.b;
 	}
 	else for (let channel = 0; channel < channels; channel++) {
 		const plane = image.components[channel];
@@ -302,8 +307,8 @@ function readImageXObject(dict, raw, resolver, sink) {
 		});
 		return;
 	}
-	const bitsPerComponent = require_objects.asNumber(require_objects.dictGet(dict, "BitsPerComponent") ?? require_objects.dictGet(dict, "BPC")) ?? 8;
-	if (bitsPerComponent !== 1 && bitsPerComponent !== 2 && bitsPerComponent !== 4 && bitsPerComponent !== 8) {
+	const bitsPerComponent = require_objects.asNumber(require_objects.dictGet(dict, "BitsPerComponent") ?? require_objects.dictGet(dict, "BPC")) ?? BITS_PER_BYTE;
+	if (bitsPerComponent !== 1 && bitsPerComponent !== 2 && bitsPerComponent !== 4 && bitsPerComponent !== BITS_PER_BYTE) {
 		sink({
 			code: "image/unsupported-bit-depth",
 			severity: "warning",

package/dist/images-read.d.cts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.cjs";
-import { n as PdfDict } from "./objects-B7HdMeWS.cjs";
+import { n as PdfDict } from "./objects-e2RS3-yT.cjs";
 import { PdfObjectResolver } from "./interpret.cjs";
 //#region src/images-read.d.ts
 interface ExtractedPdfImage {
@@ -13,6 +13,6 @@ interface ExtractedPdfImage {
     readonly globalsBytes?: Uint8Array<ArrayBuffer>;
   };
 }
-declare function readImageXObject(dict: PdfDict, raw: Uint8Array<ArrayBuffer>, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): ExtractedPdfImage | undefined;
+declare function readImageXObject(dict: PdfDict, raw: Uint8Array<ArrayBuffer>, resolver: Readonly<PdfObjectResolver>, sink: PdfDiagnosticSink): ExtractedPdfImage | undefined;
 //#endregion
 export { ExtractedPdfImage, readImageXObject };

package/dist/images-read.d.ts

@@ -1,5 +1,5 @@
 import { PdfDiagnosticSink } from "./diagnostics.js";
-import { n as PdfDict } from "./objects-B7HdMeWS.js";
+import { n as PdfDict } from "./objects-e2RS3-yT.js";
 import { PdfObjectResolver } from "./interpret.js";
 //#region src/images-read.d.ts
 interface ExtractedPdfImage {
@@ -13,6 +13,6 @@ interface ExtractedPdfImage {
     readonly globalsBytes?: Uint8Array<ArrayBuffer>;
   };
 }
-declare function readImageXObject(dict: PdfDict, raw: Uint8Array<ArrayBuffer>, resolver: PdfObjectResolver, sink: PdfDiagnosticSink): ExtractedPdfImage | undefined;
+declare function readImageXObject(dict: PdfDict, raw: Uint8Array<ArrayBuffer>, resolver: Readonly<PdfObjectResolver>, sink: PdfDiagnosticSink): ExtractedPdfImage | undefined;
 //#endregion
 export { ExtractedPdfImage, readImageXObject };