reamkit 1.26.0 → 1.28.0

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

@@ -71,6 +71,29 @@ export declare function decodeGenericRegion(mq: MQDecoder, cx: Cx, width: number
  * @param dy Likewise, vertically.
  */
 export declare function decodeRefinement(mq: MQDecoder, cx: Cx, width: number, height: number, template: number, reference: Jbig2Bitmap, dx: number, dy: number, at: ReadonlyArray<At>, tpgron: boolean): Jbig2Bitmap;
+/**
+ * §6.4.5 — draw a text region: a run of strips, each holding instances of the
+ * symbols in `symbols`, placed by running coordinates rather than absolute ones.
+ *
+ * This is what JBIG2 is for. A scanned page is not stored as pixels but as "the
+ * shape called 37, here; the shape called 12, four pixels on" — so the letter
+ * "e" costs its bitmap once and a few bits per occurrence after that.
+ */
+/**
+ * §6.4.5 Table 34 — SBSYMCODELEN, how many bits a text region spends naming
+ * one of its symbols.
+ *
+ * `ceil(log2(SBNUMSYMS))`, and for ONE symbol that is ZERO: there is nothing to
+ * choose, so no bits are read and the id is always that symbol.
+ * Rounded up to one — which the HUFFMAN side of the same table does need — the
+ * decoder takes a bit belonging to the next field and reads the id as 1, which
+ * is no symbol at all: bitmap-symbol-big-segmentid.pdf places one instance of
+ * one symbol in each of two regions, and both came back empty.
+ *
+ * @param symbols How many symbols the region has to choose between.
+ * @returns The number of bits an id takes.
+ */
+export declare function symbolCodeLength(symbols: number): number;
 /**
  * Decode an embedded JBIG2 image.
  *

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

@@ -1,4 +1,4 @@
-import { decodeCcitt } from "./ccitt.js";
+import { decodeCcitt, decodeCcittPlanes } from "./ccitt.js";
 //#region src/pdf-reader/jbig2.ts
 function makeBitmap(width, height, fill = 0) {
 	const data = new Uint8Array(width * height);
@@ -1792,21 +1792,38 @@ var Corner = /* @__PURE__ */ function(Corner) {
 * shape called 37, here; the shape called 12, four pixels on" — so the letter
 * "e" costs its bitmap once and a few bits per occurrence after that.
 */
-function decodeTextRegion(mq, symbols, p, stripsLog) {
+/**
+* §6.4.5 Table 34 — SBSYMCODELEN, how many bits a text region spends naming
+* one of its symbols.
+*
+* `ceil(log2(SBNUMSYMS))`, and for ONE symbol that is ZERO: there is nothing to
+* choose, so no bits are read and the id is always that symbol.
+* Rounded up to one — which the HUFFMAN side of the same table does need — the
+* decoder takes a bit belonging to the next field and reads the id as 1, which
+* is no symbol at all: bitmap-symbol-big-segmentid.pdf places one instance of
+* one symbol in each of two regions, and both came back empty.
+*
+* @param symbols How many symbols the region has to choose between.
+* @returns The number of bits an id takes.
+*/
+function symbolCodeLength(symbols) {
+	return Math.ceil(Math.log2(Math.max(symbols, 1)));
+}
+function decodeTextRegion(mq, symbols, p, stripsLog, lent) {
 	const bmp = makeBitmap(p.width, p.height, p.defPixel);
 	const strips = 1 << stripsLog;
-	const codeLen = Math.max(1, Math.ceil(Math.log2(Math.max(symbols.length, 1))));
-	const iadt = new IntDecoder(mq);
-	const iafs = new IntDecoder(mq);
-	const iads = new IntDecoder(mq);
-	const iait = new IntDecoder(mq);
-	const iari = new IntDecoder(mq);
-	const iardw = new IntDecoder(mq);
-	const iardh = new IntDecoder(mq);
-	const iardx = new IntDecoder(mq);
-	const iardy = new IntDecoder(mq);
-	const iaid = new IdDecoder(mq, codeLen);
-	const refineCx = newContexts(8192);
+	const codeLen = lent?.codeLen ?? symbolCodeLength(symbols.length);
+	const iadt = lent?.iadt ?? new IntDecoder(mq);
+	const iafs = lent?.iafs ?? new IntDecoder(mq);
+	const iads = lent?.iads ?? new IntDecoder(mq);
+	const iait = lent?.iait ?? new IntDecoder(mq);
+	const iari = lent?.iari ?? new IntDecoder(mq);
+	const iardw = lent?.iardw ?? new IntDecoder(mq);
+	const iardh = lent?.iardh ?? new IntDecoder(mq);
+	const iardx = lent?.iardx ?? new IntDecoder(mq);
+	const iardy = lent?.iardy ?? new IntDecoder(mq);
+	const iaid = lent?.iaid ?? new IdDecoder(mq, codeLen);
+	const refineCx = lent?.refineCx ?? newContexts(8192);
 	const num = (v) => v === OOB ? 0 : v;
 	let stripT = -num(iadt.decode()) * strips;
 	let firstS = 0;
@@ -1845,10 +1862,10 @@ function decodeTextRegion(mq, symbols, p, stripsLog) {
 			compose(bmp, sym, x, y, p.combOp);
 			curS += (p.transposed ? sh : sw) - 1;
 			placed++;
-			if (placed >= p.instances) break;
 			const ids = iads.decode();
 			if (ids === OOB) break;
 			curS += ids + p.dsOffset;
+			if (placed > p.instances * 2 + 16) break;
 		}
 	}
 	return bmp;
@@ -1873,6 +1890,22 @@ function decodeSymbolDictionary(mq, input, newCount, exportCount, template, at,
 	const refineCx = newContexts(8192);
 	const newSymbols = [];
 	const num = (v) => v === OOB ? 0 : v;
+	const codeLen = symbolCodeLength(input.length + newCount);
+	const iaid = new IdDecoder(mq, codeLen);
+	const lent = {
+		codeLen,
+		iadt: new IntDecoder(mq),
+		iafs: new IntDecoder(mq),
+		iads: new IntDecoder(mq),
+		iait: new IntDecoder(mq),
+		iari: new IntDecoder(mq),
+		iardw: new IntDecoder(mq),
+		iardh: new IntDecoder(mq),
+		iardx,
+		iardy,
+		iaid,
+		refineCx
+	};
 	let height = 0;
 	let guard = 0;
 	while (newSymbols.length < newCount && guard++ < 1e4) {
@@ -1892,7 +1925,7 @@ function decodeSymbolDictionary(mq, input, newCount, exportCount, template, at,
 				const instances = num(iaai.decode());
 				if (instances === 1) {
 					const all = [...input, ...newSymbols];
-					const id = new IdDecoder(mq, Math.max(1, Math.ceil(Math.log2(Math.max(all.length + newCount, 1))))).decode();
+					const id = iaid.decode();
 					const rdx = num(iardx.decode());
 					const rdy = num(iardy.decode());
 					newSymbols.push(decodeRefinement(mq, refineCx, width, height, rTemplate, all[id] ?? makeBitmap(1, 1), rdx, rdy, rAt, false));
@@ -1911,7 +1944,7 @@ function decodeSymbolDictionary(mq, input, newCount, exportCount, template, at,
 						refine: true,
 						rTemplate,
 						rAt
-					}, 0));
+					}, 0, lent));
 				}
 			}
 		}
@@ -2022,15 +2055,73 @@ function decodeTextRegionHuff(bits, data, symbols, p, stripsLog, t) {
 			compose(bmp, sym, x, y, p.combOp);
 			curS += (p.transposed ? sh : sw) - 1;
 			placed++;
-			if (placed >= p.instances) break;
 			const ids = huffDecode(bits, t.ds);
 			if (ids === OOB) break;
 			curS += ids + p.dsOffset;
+			if (placed > p.instances * 2 + 16) break;
 		}
 	}
 	return bmp;
 }
 /**
+* §6.5.8.2 — one shape of a REFINING Huffman dictionary.
+*
+* The dictionary states how many instances the shape is made of. One is a
+* refinement of a symbol it already holds — the id in as many bits as the
+* dictionary will end with, the offsets through table B.15, and the
+* refinement's own length through B.1, so the reader steps over exactly that.
+* Several is a text region of its own, read with the standard tables §6.5.8.2.1
+* names and with the symbol ids in plain fixed-width codes.
+*
+* @returns The shape, which is `width` by `height` whatever it took to make.
+*/
+function aggregateSymbolHuff(bits, data, symbols, width, height, codeLen, refineCx, agg) {
+	const num = (v) => v === OOB ? 0 : v;
+	const instances = num(huffDecode(bits, agg.inst));
+	const b15 = standardTable(15);
+	const b1 = standardTable(1);
+	if (instances !== 1) {
+		const ids = buildHuffTable(Array.from({ length: 1 << codeLen }, (_, i) => ({
+			prefLen: codeLen,
+			rangeLen: 0,
+			rangeLow: i
+		})));
+		return decodeTextRegionHuff(bits, data, symbols, {
+			width,
+			height,
+			instances: Math.max(1, instances),
+			stripT: 0,
+			refCorner: Corner.TopLeft,
+			transposed: false,
+			combOp: 0,
+			defPixel: 0,
+			dsOffset: 0,
+			refine: true,
+			rTemplate: agg.rTemplate,
+			rAt: agg.rAt
+		}, 0, {
+			fs: standardTable(6),
+			ds: standardTable(8),
+			dt: standardTable(11),
+			rdw: b15,
+			rdh: b15,
+			rdx: b15,
+			rdy: b15,
+			rsize: b1,
+			symbolIds: ids
+		});
+	}
+	const id = bits.readBits(codeLen);
+	const rdx = num(huffDecode(bits, b15));
+	const rdy = num(huffDecode(bits, b15));
+	const size = num(huffDecode(bits, b1));
+	bits.align();
+	const start = bits.bytePos;
+	const bmp = decodeRefinement(new MQDecoder(data.subarray(start)), refineCx, width, height, agg.rTemplate, symbols[id] ?? makeBitmap(1, 1), rdx, rdy, agg.rAt, false);
+	bits.skipTo(start + size);
+	return bmp;
+}
+/**
 * §6.5.9 — a Huffman-coded symbol dictionary.
 *
 * The shapes of a height class are not coded one by one: their widths are read
@@ -2038,9 +2129,11 @@ function decodeTextRegionHuff(bits, data, symbols, p, stripsLog, t) {
 * apart by those widths. That is why a Huffman dictionary needs a size field
 * the arithmetic one does not.
 */
-function decodeSymbolDictionaryHuff(bits, data, input, newCount, exportCount, dh, dw, bmSize) {
+function decodeSymbolDictionaryHuff(bits, data, input, newCount, exportCount, dh, dw, bmSize, agg) {
 	const newSymbols = [];
 	const num = (v) => v === OOB ? 0 : v;
+	const codeLen = symbolCodeLength(input.length + newCount);
+	const refineCx = newContexts(8192);
 	let height = 0;
 	let guard = 0;
 	while (newSymbols.length < newCount && guard++ < 1e4) {
@@ -2054,9 +2147,14 @@ function decodeSymbolDictionaryHuff(bits, data, input, newCount, exportCount, dh
 			if (d === OOB) break;
 			width += d;
 			if (width <= 0 || width > 16384 || newSymbols.length + widths.length >= newCount + 1) break;
+			if (agg) {
+				newSymbols.push(aggregateSymbolHuff(bits, data, [...input, ...newSymbols], width, height, codeLen, refineCx, agg));
+				continue;
+			}
 			widths.push(width);
 			totalWidth += width;
 		}
+		if (agg) continue;
 		if (widths.length === 0) continue;
 		const size = num(huffDecode(bits, bmSize));
 		bits.align();
@@ -2164,21 +2262,13 @@ function decodePatternDictionary(data, mmr, template, pw, ph, grayMax) {
 function decodeGrayScale(mq, data, mmr, template, at, width, height, bits, skip) {
 	const cx = newContexts(65536);
 	const planes = new Array(bits);
-	let mmrOffset = 0;
+	const packed = mmr ? decodeCcittPlanes(data, width, height, bits) : void 0;
+	const rowBytes = width + 7 >> 3;
 	const decoder = mq ?? new MQDecoder(data);
 	for (let j = bits - 1; j >= 0; j--) if (mmr) {
-		const packed = decodeCcitt(data.subarray(mmrOffset), {
-			k: -1,
-			columns: width,
-			rows: height,
-			byteAlign: false
-		});
+		const bytes = packed?.[bits - 1 - j];
 		const plane = makeBitmap(width, height);
-		if (packed) {
-			const rowBytes = width + 7 >> 3;
-			for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) plane.data[y * width + x] = packed[y * rowBytes + (x >> 3)] >> 7 - (x & 7) & 1;
-			mmrOffset += packed.length;
-		}
+		if (bytes) for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) plane.data[y * width + x] = bytes[y * rowBytes + (x >> 3)] >> 7 - (x & 7) & 1;
 		planes[j] = plane;
 	} else planes[j] = decodeGenericRegion(decoder, cx, width, height, template, at, false, skip);
 	const values = new Array(width * height).fill(0);
@@ -2432,7 +2522,11 @@ function decodeJbig2(data, globals, width, height) {
 						const dwSel = flags >> 4 & 3;
 						const bmSel = flags >> 6 & 1;
 						const bits = new BitReader(bytes.subarray(seg.start + r.pos, seg.end));
-						symbolsBySegment.set(seg.number, decodeSymbolDictionaryHuff(bits, bytes.subarray(seg.start + r.pos, seg.end), inherited, newCount, exportCount, pick(dhSel, [4, 5]), pick(dwSel, [2, 3]), bmSel === 1 ? custom[ci++] ?? standardTable(1) : standardTable(1)));
+						symbolsBySegment.set(seg.number, decodeSymbolDictionaryHuff(bits, bytes.subarray(seg.start + r.pos, seg.end), inherited, newCount, exportCount, pick(dhSel, [4, 5]), pick(dwSel, [2, 3]), bmSel === 1 ? custom[ci++] ?? standardTable(1) : standardTable(1), refAgg ? {
+							inst: (flags >> 7 & 1) === 1 ? custom[ci++] ?? standardTable(1) : standardTable(1),
+							rTemplate,
+							rAt: rAt.length > 0 ? rAt : NOMINAL_AT_REFINE
+						} : void 0));
 						continue;
 					}
 					symbolsBySegment.set(seg.number, decodeSymbolDictionary(new MQDecoder(bytes.subarray(seg.start + r.pos, seg.end)), inherited, newCount, exportCount, template, at.length > 0 ? at : NOMINAL_AT[template] ?? [], refAgg, rTemplate, rAt.length > 0 ? rAt : NOMINAL_AT_REFINE));

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

@@ -1,5 +1,7 @@
 import { PdfFile } from './document.js';
 import { Reconstruction } from './flow-build.js';
+/** §9.10.2 — a glyph the face maps to no character (see `./font`). */
+export declare const UNMAPPED = "\uFFFD";
 /**
  * Heuristically reconstruct an untagged PDF into a {@link Reconstruction}
  * (E-PDF EP4). With no structure tree there is only positioned content, so
@@ -16,3 +18,33 @@ import { Reconstruction } from './flow-build.js';
  * @returns The reconstructed {@link FlowDoc} plus any read-time losses.
  */
 export declare function reconstructByLayout(file: PdfFile, mode?: 'flow' | 'positional'): Reconstruction;
+/**
+ * Whether a line ENDED a paragraph, rather than wrapping into the next.
+ *
+ * Leading alone cannot tell the two apart: five labels stacked at 15pt with a
+ * 12pt face look exactly like five wrapped lines, and alphatrans.pdf's five are
+ * read as one paragraph and re-wrapped into two. But a wrapping engine pulls
+ * the next word UP — so a line that stops well short of the measure stopped
+ * because its author stopped it, and the line after it begins something new.
+ * The same rule separates two paragraphs set with no extra space between them,
+ * which used to run together for the same reason.
+ *
+ * Only where both lines start at the same edge. Where they do not, the block is
+ * placed rather than set — a centred title's every line is short of the measure
+ * and none of them ends anything.
+ *
+ * @param prev   The line before: where it starts, how wide it is, its face.
+ * @param next   The line after — only where it starts matters.
+ * @param column The measure both were set in, when it is known.
+ * @returns Whether the first line ended a paragraph.
+ */
+export declare function endedParagraph(prev: {
+    x: number;
+    width: number;
+    fontSize: number;
+}, next: {
+    x: number;
+}, column: {
+    left: number;
+    right: number;
+} | undefined): boolean;