reamkit 1.24.0 → 1.25.0

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

@@ -0,0 +1,419 @@
+//#region src/pdf-reader/jpeg.ts
+/** §A.3.6 — the zig-zag order the coefficients of a block are coded in. */
+var ZIGZAG = new Uint8Array([
+	0,
+	1,
+	8,
+	16,
+	9,
+	2,
+	3,
+	10,
+	17,
+	24,
+	32,
+	25,
+	18,
+	11,
+	4,
+	5,
+	12,
+	19,
+	26,
+	33,
+	40,
+	48,
+	41,
+	34,
+	27,
+	20,
+	13,
+	6,
+	7,
+	14,
+	21,
+	28,
+	35,
+	42,
+	49,
+	56,
+	57,
+	50,
+	43,
+	36,
+	29,
+	22,
+	15,
+	23,
+	30,
+	37,
+	44,
+	51,
+	58,
+	59,
+	52,
+	45,
+	38,
+	31,
+	39,
+	46,
+	53,
+	60,
+	61,
+	54,
+	47,
+	55,
+	62,
+	63
+]);
+var MAX_PIXELS = 5e7;
+/**
+* Decode a baseline JPEG to interleaved 8-bit samples.
+*
+* @param bytes The JPEG stream, starting at its SOI marker.
+* @returns The decoded image, or `undefined` when the stream is not a baseline
+*          JPEG this decoder handles (progressive, arithmetic, 12-bit, CMYK) or
+*          is malformed — the caller then carries the original bytes through.
+*/
+function decodeJpeg(bytes) {
+	try {
+		return decode(bytes);
+	} catch {
+		return;
+	}
+}
+function decode(bytes) {
+	if (bytes.length < 4 || bytes[0] !== 255 || bytes[1] !== 216) return void 0;
+	const quant = [];
+	const dcTables = [];
+	const acTables = [];
+	let frame;
+	let restartInterval = 0;
+	let adobeTransform;
+	let p = 2;
+	while (p < bytes.length) {
+		if (bytes[p] !== 255) {
+			p++;
+			continue;
+		}
+		const marker = bytes[p + 1];
+		p += 2;
+		if (marker === 216 || marker === 1 || marker >= 208 && marker <= 215) continue;
+		if (marker === 217) break;
+		const length = be16(bytes, p);
+		const segEnd = p + length;
+		switch (marker) {
+			case 219:
+				readQuantTables(bytes, p + 2, segEnd, quant);
+				break;
+			case 196:
+				readHuffTables(bytes, p + 2, segEnd, dcTables, acTables);
+				break;
+			case 221:
+				restartInterval = be16(bytes, p + 2);
+				break;
+			case 238:
+				if (length >= 14 && str(bytes, p + 2, 5) === "Adobe") adobeTransform = bytes[p + 13];
+				break;
+			case 192:
+			case 193:
+				frame = readFrame(bytes, p + 2);
+				if (!frame) return void 0;
+				break;
+			case 194:
+			case 195:
+			case 197:
+			case 198:
+			case 199:
+			case 201:
+			case 202:
+			case 203:
+			case 205:
+			case 206:
+			case 207: return;
+			case 218: {
+				if (!frame) return void 0;
+				const scanComps = readScanHeader(bytes, p + 2, frame.comps);
+				if (!scanComps) return void 0;
+				p = decodeScan(bytes, segEnd, frame, scanComps, dcTables, acTables, quant, restartInterval);
+				continue;
+			}
+			default: break;
+		}
+		p = segEnd;
+	}
+	if (!frame) return void 0;
+	return assemble(frame, adobeTransform);
+}
+function readFrame(bytes, p) {
+	if (bytes[p] !== 8) return void 0;
+	const height = be16(bytes, p + 1);
+	const width = be16(bytes, p + 3);
+	const count = bytes[p + 5];
+	if (width <= 0 || height <= 0 || width * height > MAX_PIXELS) return void 0;
+	if (count !== 1 && count !== 3) return void 0;
+	const comps = [];
+	let maxH = 1;
+	let maxV = 1;
+	for (let i = 0; i < count; i++) {
+		const at = p + 6 + i * 3;
+		const h = bytes[at + 1] >> 4;
+		const v = bytes[at + 1] & 15;
+		if (h < 1 || h > 4 || v < 1 || v > 4) return void 0;
+		maxH = Math.max(maxH, h);
+		maxV = Math.max(maxV, v);
+		comps.push({
+			id: bytes[at],
+			h,
+			v,
+			tq: bytes[at + 2],
+			dc: 0,
+			ac: 0,
+			pred: 0,
+			blocksPerLine: 0,
+			blocksPerCol: 0,
+			plane: new Uint8ClampedArray(0),
+			stride: 0
+		});
+	}
+	const mcusPerLine = Math.ceil(width / (8 * maxH));
+	const mcusPerCol = Math.ceil(height / (8 * maxV));
+	for (const c of comps) {
+		c.blocksPerLine = mcusPerLine * c.h;
+		c.blocksPerCol = mcusPerCol * c.v;
+		c.stride = c.blocksPerLine * 8;
+		c.plane = new Uint8ClampedArray(c.stride * c.blocksPerCol * 8);
+	}
+	return {
+		width,
+		height,
+		comps,
+		maxH,
+		maxV
+	};
+}
+function readScanHeader(bytes, p, comps) {
+	const count = bytes[p];
+	const out = [];
+	for (let i = 0; i < count; i++) {
+		const id = bytes[p + 1 + i * 2];
+		const tables = bytes[p + 2 + i * 2];
+		const comp = comps.find((c) => c.id === id);
+		if (!comp) return void 0;
+		comp.dc = tables >> 4;
+		comp.ac = tables & 15;
+		out.push(comp);
+	}
+	return out;
+}
+function readQuantTables(bytes, p, end, into) {
+	while (p < end) {
+		const pq = bytes[p] >> 4;
+		const tq = bytes[p] & 15;
+		p++;
+		const table = new Int32Array(64);
+		for (let i = 0; i < 64; i++) table[ZIGZAG[i]] = pq === 0 ? bytes[p + i] : be16(bytes, p + i * 2);
+		p += pq === 0 ? 64 : 128;
+		into[tq] = table;
+	}
+}
+function readHuffTables(bytes, p, end, dc, ac) {
+	while (p < end) {
+		const tc = bytes[p] >> 4;
+		const th = bytes[p] & 15;
+		p++;
+		const counts = bytes.subarray(p, p + 16);
+		p += 16;
+		let total = 0;
+		for (const n of counts) total += n;
+		const values = bytes.slice(p, p + total);
+		p += total;
+		const table = buildHuffTable(counts, values);
+		if (tc === 0) dc[th] = table;
+		else ac[th] = table;
+	}
+}
+/** §F.2.2.3 — the decoding tables, built from BITS and HUFFVAL. */
+function buildHuffTable(counts, values) {
+	const maxcode = new Int32Array(18).fill(-1);
+	const mincode = new Int32Array(18);
+	const valptr = new Int32Array(18);
+	let code = 0;
+	let k = 0;
+	for (let l = 1; l <= 16; l++) {
+		const n = counts[l - 1];
+		if (n === 0) maxcode[l] = -1;
+		else {
+			valptr[l] = k;
+			mincode[l] = code;
+			code += n;
+			k += n;
+			maxcode[l] = code - 1;
+		}
+		code <<= 1;
+	}
+	return {
+		maxcode,
+		mincode,
+		valptr,
+		values
+	};
+}
+/**
+* Decode one scan's entropy-coded segment into the components' planes.
+*
+* @returns The offset of the marker that ends the scan.
+*/
+function decodeScan(bytes, start, frame, scan, dcTables, acTables, quant, restartInterval) {
+	let at = start;
+	let bitBuf = 0;
+	let bitCount = 0;
+	const nextBit = () => {
+		if (bitCount === 0) {
+			let b = bytes[at++] ?? 0;
+			if (b === 255) if ((bytes[at] ?? 0) === 0) at++;
+			else {
+				at--;
+				b = 0;
+			}
+			bitBuf = b;
+			bitCount = 8;
+		}
+		bitCount--;
+		return bitBuf >> bitCount & 1;
+	};
+	const decodeHuff = (table) => {
+		if (!table) return 0;
+		let code = nextBit();
+		let l = 1;
+		while (l <= 16 && (table.maxcode[l] === -1 || code > table.maxcode[l])) {
+			code = code << 1 | nextBit();
+			l++;
+		}
+		if (l > 16) return 0;
+		return table.values[table.valptr[l] + code - table.mincode[l]] ?? 0;
+	};
+	const receiveExtend = (s) => {
+		if (s === 0) return 0;
+		let v = 0;
+		for (let i = 0; i < s; i++) v = v << 1 | nextBit();
+		return v < 1 << s - 1 ? v - (1 << s) + 1 : v;
+	};
+	const block = new Int32Array(64);
+	const decodeBlock = (comp, row, col) => {
+		block.fill(0);
+		const q = quant[comp.tq];
+		const t = decodeHuff(dcTables[comp.dc]);
+		comp.pred += receiveExtend(t);
+		block[0] = comp.pred * (q?.[0] ?? 1);
+		let i = 1;
+		while (i < 64) {
+			const rs = decodeHuff(acTables[comp.ac]);
+			const run = rs >> 4;
+			const size = rs & 15;
+			if (size === 0) {
+				if (run !== 15) break;
+				i += 16;
+				continue;
+			}
+			i += run;
+			if (i > 63) break;
+			const z = ZIGZAG[i];
+			block[z] = receiveExtend(size) * (q?.[z] ?? 1);
+			i++;
+		}
+		idctBlock(block, comp.plane, row * 8 * comp.stride + col * 8, comp.stride);
+	};
+	const mcusPerLine = Math.ceil(frame.width / (8 * frame.maxH));
+	const mcusPerCol = Math.ceil(frame.height / (8 * frame.maxV));
+	const single = scan.length === 1;
+	const total = single ? Math.ceil(scan[0].blocksPerLine * scan[0].blocksPerCol) : mcusPerLine * mcusPerCol;
+	const perLine = single ? scan[0].blocksPerLine : mcusPerLine;
+	let untilRestart = restartInterval || total;
+	for (let n = 0; n < total; n++) {
+		if (single) {
+			const c = scan[0];
+			decodeBlock(c, Math.floor(n / perLine), n % perLine);
+		} else {
+			const mcuRow = Math.floor(n / mcusPerLine);
+			const mcuCol = n % mcusPerLine;
+			for (const c of scan) for (let v = 0; v < c.v; v++) for (let h = 0; h < c.h; h++) decodeBlock(c, mcuRow * c.v + v, mcuCol * c.h + h);
+		}
+		if (--untilRestart === 0 && n + 1 < total) {
+			bitCount = 0;
+			while (at + 1 < bytes.length && !(bytes[at] === 255 && bytes[at + 1] >= 208 && bytes[at + 1] <= 215)) at++;
+			at += 2;
+			for (const c of scan) c.pred = 0;
+			untilRestart = restartInterval;
+		}
+	}
+	while (at + 1 < bytes.length && !(bytes[at] === 255 && bytes[at + 1] !== 0)) at++;
+	return at;
+}
+/** §A.3.3 — cos((2x+1)uπ/16) · C(u)/2, precomputed. */
+var COS = (() => {
+	const t = new Float32Array(64);
+	for (let u = 0; u < 8; u++) {
+		const c = u === 0 ? Math.SQRT1_2 : 1;
+		for (let x = 0; x < 8; x++) t[u * 8 + x] = c * Math.cos((2 * x + 1) * u * Math.PI / 16) / 2;
+	}
+	return t;
+})();
+/** The separable 2-D inverse DCT of one block, levelshifted into `out`. */
+function idctBlock(block, out, offset, stride) {
+	const rows = new Float32Array(64);
+	for (let y = 0; y < 8; y++) for (let x = 0; x < 8; x++) {
+		let sum = 0;
+		for (let u = 0; u < 8; u++) sum += COS[u * 8 + x] * block[y * 8 + u];
+		rows[y * 8 + x] = sum;
+	}
+	for (let x = 0; x < 8; x++) for (let y = 0; y < 8; y++) {
+		let sum = 0;
+		for (let v = 0; v < 8; v++) sum += COS[v * 8 + y] * rows[v * 8 + x];
+		out[offset + y * stride + x] = sum + 128;
+	}
+}
+/** Upsample every component to full size and convert to gray or RGB. */
+function assemble(frame, adobeTransform) {
+	const { width, height, comps, maxH, maxV } = frame;
+	const n = comps.length;
+	const samples = new Uint8Array(width * height * n);
+	for (let ci = 0; ci < n; ci++) {
+		const c = comps[ci];
+		const sx = c.h / maxH;
+		const sy = c.v / maxV;
+		for (let y = 0; y < height; y++) {
+			const srcRow = Math.min(c.blocksPerCol * 8 - 1, y * sy | 0) * c.stride;
+			for (let x = 0; x < width; x++) samples[(y * width + x) * n + ci] = c.plane[srcRow + Math.min(c.stride - 1, x * sx | 0)];
+		}
+	}
+	if (n === 1) return {
+		width,
+		height,
+		components: 1,
+		samples
+	};
+	if (adobeTransform !== 0) ycbcrToRgb(samples);
+	return {
+		width,
+		height,
+		components: 3,
+		samples
+	};
+}
+/** ITU-T T.871 §7 — the JFIF YCbCr → RGB conversion, in place. */
+function ycbcrToRgb(s) {
+	for (let i = 0; i < s.length; i += 3) {
+		const y = s[i];
+		const cb = s[i + 1] - 128;
+		const cr = s[i + 2] - 128;
+		s[i] = clamp(y + 1.402 * cr);
+		s[i + 1] = clamp(y - .344136 * cb - .714136 * cr);
+		s[i + 2] = clamp(y + 1.772 * cb);
+	}
+}
+var clamp = (v) => v < 0 ? 0 : v > 255 ? 255 : v | 0;
+var be16 = (b, p) => (b[p] ?? 0) << 8 | (b[p + 1] ?? 0);
+var str = (b, p, n) => String.fromCharCode(...b.subarray(p, p + n));
+//#endregion
+export { decodeJpeg };

package/dist/esm/pdf-reader/layout.d.ts

@@ -15,4 +15,4 @@ import { Reconstruction } from './flow-build.js';
  * @param file The PDF to reconstruct.
  * @returns The reconstructed {@link FlowDoc} plus any read-time losses.
  */
-export declare function reconstructByLayout(file: PdfFile): Reconstruction;
+export declare function reconstructByLayout(file: PdfFile, mode?: 'flow' | 'positional'): Reconstruction;