reamkit 1.26.0 → 1.28.0

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

@@ -6,20 +6,59 @@
 * @param data   The raw fax codestream (any wrapping filters already stripped).
 * @param params The `/CCITTFaxDecode` parameters.
 * @returns The packed bitmap (`rowBytes × rows`, bit 1 = black, MSB first), or
-*   `undefined` when the stream cannot be decoded (e.g. Group 3 2-D, or nothing
-*   decoded at all).
+*   `undefined` when nothing could be decoded at all.
 */
 function decodeCcitt(data, params) {
+	return decodeInto(new BitReader(data), params);
+}
+/**
+* ISO/IEC 14492 §C.5 — the bitplanes of a grey-scale image, all MMR-coded into
+* ONE stream, one after another with an EOFB between them.
+*
+* They cannot be decoded a plane at a time from the head of the data, because
+* nothing says how many BYTES a plane took: the reader has to carry its place
+* across them. Advancing instead by the size of what came OUT left every plane
+* after the first reading from the middle of the one before it, and
+* bitmap-halftone-10bpp-mmr.pdf came back as three specks.
+*
+* @param data    The stream holding all the planes.
+* @param columns Each plane's width, in pixels.
+* @param rows    Each plane's height.
+* @param count   How many planes to read.
+* @returns One packed bitmap per plane, or `undefined` if the first will not
+*          decode at all.
+*/
+function decodeCcittPlanes(data, columns, rows, count) {
+	const reader = new BitReader(data);
+	const out = [];
+	for (let i = 0; i < count; i++) {
+		const plane = decodeInto(reader, {
+			k: -1,
+			columns,
+			rows,
+			byteAlign: false
+		});
+		if (!plane) return out.length > 0 ? out : void 0;
+		out.push(plane);
+		reader.skipEofb();
+		reader.align();
+	}
+	return out;
+}
+function decodeInto(reader, params) {
 	const { k, columns, rows, byteAlign } = params;
-	if (k > 0) return void 0;
 	if (columns <= 0 || rows <= 0 || columns > 1 << 20) return void 0;
-	const reader = new BitReader(data);
 	const rowBytes = columns + 7 >> 3;
 	const out = new Uint8Array(rowBytes * rows);
 	let ref = [columns, columns];
 	for (let y = 0; y < rows; y++) {
 		if (byteAlign && y > 0) reader.align();
-		const cur = k < 0 ? decode2D(reader, ref, columns) : decode1D(reader, columns);
+		let twoDimensional = k < 0;
+		if (k > 0) {
+			reader.skipEol();
+			twoDimensional = reader.readBit() === 0;
+		} else if (k === 0) reader.skipEol();
+		const cur = twoDimensional ? decode2D(reader, ref, columns) : decode1D(reader, columns);
 		if (!cur) {
 			if (y === 0) return void 0;
 			break;
@@ -145,7 +184,64 @@ var BitReader = class {
 			this.bytePos++;
 		}
 	}
+	/**
+	* T.4 §4.1.2 — step over an end-of-line, which is eleven zeroes and a one.
+	* A stream that carries none is left exactly where it stands.
+	*/
+	skipEol() {
+		const at = {
+			byte: this.bytePos,
+			bit: this.bitPos
+		};
+		let zeros = 0;
+		for (;;) {
+			const b = this.readBit();
+			if (b < 0 || b === 0 && zeros > MAX_EOL_FILL) break;
+			if (b === 0) {
+				zeros++;
+				continue;
+			}
+			if (zeros >= 11) return;
+			break;
+		}
+		this.bytePos = at.byte;
+		this.bitPos = at.bit;
+	}
+	/**
+	* Step over the end-of-facsimile-block that closes an MMR plane: two EOLs,
+	* each eleven zeroes and a one. Anything else is left where it stands.
+	*/
+	skipEofb() {
+		const at = {
+			byte: this.bytePos,
+			bit: this.bitPos
+		};
+		for (let eol = 0; eol < 2; eol++) {
+			let zeros = 0;
+			for (;;) {
+				const b = this.readBit();
+				if (b < 0) return;
+				if (b === 0) {
+					zeros++;
+					if (zeros > 64) {
+						this.bytePos = at.byte;
+						this.bitPos = at.bit;
+						return;
+					}
+					continue;
+				}
+				if (zeros < 11) {
+					this.bytePos = at.byte;
+					this.bitPos = at.bit;
+					return;
+				}
+				break;
+			}
+		}
+	}
 };
+/** How much fill an end-of-line may carry before this stops looking for one. */
+var MAX_EOL_FILL = 64;
 /**
 * T.4 white-run modified-Huffman codes as `[run, bit-string]` (terminating runs
 * 0..63, make-up runs multiples of 64). Exported so the test can build an
@@ -406,4 +502,4 @@ var WHITE = buildRunTable(WHITE_CODES, SHARED_MAKEUP);
 var BLACK = buildRunTable(BLACK_CODES, SHARED_MAKEUP);
 var MODES = new Map(MODE_CODES.map(([bits, m]) => [bits.length << 8 | parseInt(bits, 2), m]));
 //#endregion
-export { decodeCcitt };
+export { decodeCcitt, decodeCcittPlanes };

package/dist/esm/pdf-reader/cff-outline.d.ts

@@ -0,0 +1,36 @@
+import { OutlineSource } from './glyf-outline.js';
+/**
+ * Prepare an embedded CFF program for outline reading.
+ *
+ * @param program The raw `/FontFile3` bytes (bare CFF, or the `CFF ` table of
+ *                an OpenType wrapper — the caller unwraps that).
+ * @returns A reader keyed by GLYPH INDEX, or `undefined` where the program
+ *          cannot be read.
+ */
+export declare function cffOutlineSource(program: Uint8Array): OutlineSource | undefined;
+/**
+ * TN 5176 §13 — the NAME a CFF gives each glyph, inverted.
+ *
+ * A simple font selects its glyphs by name, not by index: `/Differences` says
+ * code 2 is `g18`, and only the program's charset says which glyph `g18` is.
+ * TAMReview.pdf sets most of its body in a Cambria subset named that way.
+ *
+ * @param program The raw CFF bytes.
+ * @returns Glyph name → glyph index, or `undefined` for a CID-keyed program
+ *          (which names nothing) or one that cannot be read.
+ */
+export declare function cffNameToGid(program: Uint8Array): Map<string, number> | undefined;
+/**
+ * TN 5176 §10 — the CID a CID-keyed CFF gives each glyph, inverted.
+ *
+ * A `CIDFontType0C` program is charset-ordered by CID, not by glyph index, so a
+ * composite font's code (its CID) is not the index into `CharStrings`. Where the
+ * program is not CID-keyed the two are the same and this gives nothing.
+ *
+ * @param program The raw CFF bytes.
+ * @returns CID → glyph index, or `undefined` for a program that is not
+ *          CID-keyed or cannot be read.
+ */
+export declare function cffCidToGid(program: Uint8Array): Map<number, number> | undefined;
+/** The `CFF ` table of an OpenType wrapper, where the program is one. */
+export declare function openTypeCff(program: Uint8Array): Uint8Array | undefined;