reamkit 1.27.0 → 1.28.0

package/dist/esm/pdf-reader/annot-draw.js

@@ -19,7 +19,9 @@ var DEFAULT_BORDER_PT = 1;
 function drawnAppearance(file, annot) {
 	const subtype = file.get(annot, "Subtype");
 	if (!(subtype instanceof PdfName)) return void 0;
-	if (subtype.value === "Widget") return typedValue(file, annot);
+	if (subtype.value === "Widget") return typedValue(file, annot) ?? checkedBox(file, annot);
+	const markup = markupShape(file, annot, subtype.value);
+	if (markup) return markup;
 	const pen = borderWidth(file, annot);
 	const drawing = pathFor(file, annot, subtype.value, pen);
 	if (!drawing || drawing.ops.length === 0) return void 0;
@@ -37,6 +39,117 @@ function drawnAppearance(file, annot) {
 	return new PdfStream(/* @__PURE__ */ new Map(), new TextEncoder().encode(body));
 }
 /**
+* §12.7.4.2 — a check box or radio button whose appearance was never generated.
+*
+* Its state is `/AS`, or `/V` where the widget states none, and `/Off` means
+* exactly that: nothing is drawn. Anything else is the ON state, and what a
+* viewer draws for it is the caption `/MK /CA` — one character of ZapfDingbats,
+* `4` (a check) by default, `l` (a filled circle) for the radio buttons that
+* ask for it.
+*
+* The border and background come from `/MK`, and where the file gives none
+* neither is drawn: checkbox_no_appearance.pdf states no `/MK` at all, and
+* poppler draws its ticked box as a bare check mark on the paper.
+*/
+function checkedBox(file, annot) {
+	if (inherited(file, annot, "FT") !== "Btn") return void 0;
+	const as = file.get(annot, "AS");
+	const state = as instanceof PdfName ? as.value : inherited(file, annot, "V");
+	const rect = rectangle(file.get(annot, "Rect"));
+	if (!rect) return void 0;
+	const [x0, y0, x1, y1] = rect;
+	const w = x1 - x0;
+	const h = y1 - y0;
+	if (!(w > 0) || !(h > 0)) return void 0;
+	const mk = file.get(annot, "MK");
+	const border = mk instanceof Map ? colorOf(file.get(mk, "BC")) : void 0;
+	const ground = mk instanceof Map ? colorOf(file.get(mk, "BG")) : void 0;
+	const pen = borderWidth(file, annot);
+	const ops = ["q"];
+	if (ground !== void 0) ops.push(`${ground} rg`, `${num(x0)} ${num(y0)} ${num(w)} ${num(h)} re`, "f");
+	if (border !== void 0 && pen > 0) ops.push(`${border} RG`, `${num(pen)} w`, `${num(x0 + pen / 2)} ${num(y0 + pen / 2)} ${num(w - pen)} ${num(h - pen)} re`, "S");
+	if (state !== void 0 && state !== "Off") {
+		const stated = mk instanceof Map ? file.get(mk, "CA") : void 0;
+		const caption = typeof stated === "string" && stated.length > 0 ? stated[0] : "4";
+		const ink = defaultAppearance(file, annot).color;
+		const side = Math.min(w, h) * CAPTION_EM;
+		const cx = x0 + w / 2;
+		const cy = y0 + h / 2;
+		if (caption === "l" || caption === "n") {
+			ops.push(`${ink} rg`);
+			ops.push(...caption === "n" ? [`${num(cx - side / 2)} ${num(cy - side / 2)} ${num(side)} ${num(side)} re`] : circleOps(cx, cy, side / 2), "f");
+		} else {
+			const pen = Math.max(.6, side * CHECK_PEN_EM);
+			ops.push(`${ink} RG`, `${num(pen)} w`, "1 J", "1 j", `${num(cx - side * .4)} ${num(cy + side * .05)} m`, `${num(cx - side * .12)} ${num(cy - side * .32)} l`, `${num(cx + side * .42)} ${num(cy + side * .36)} l`, "S");
+		}
+	}
+	ops.push("Q");
+	if (ops.length <= 2) return void 0;
+	return new PdfStream(/* @__PURE__ */ new Map(), new TextEncoder().encode(ops.join("\n")));
+}
+/** How much of the box the mark fills, and how thick the check's pen is. */
+var CAPTION_EM = .8;
+var CHECK_PEN_EM = .13;
+/** A circle of `r` about `(cx, cy)`, as the four Bézier arcs that draw one. */
+function circleOps(cx, cy, r) {
+	const k = r * .5523;
+	return [
+		`${num(cx - r)} ${num(cy)} m`,
+		`${num(cx - r)} ${num(cy + k)} ${num(cx - k)} ${num(cy + r)} ${num(cx)} ${num(cy + r)} c`,
+		`${num(cx + k)} ${num(cy + r)} ${num(cx + r)} ${num(cy + k)} ${num(cx + r)} ${num(cy)} c`,
+		`${num(cx + r)} ${num(cy - k)} ${num(cx + k)} ${num(cy - r)} ${num(cx)} ${num(cy - r)} c`,
+		`${num(cx - k)} ${num(cy - r)} ${num(cx - r)} ${num(cy - k)} ${num(cx - r)} ${num(cy)} c`
+	];
+}
+/**
+* §12.5.6.10 — a text markup drawn as a MARK on the paper.
+*
+* The usual reading puts it on the runs it covers, which is right for a page
+* with words on it. bug1538111.pdf has none: four markup annotations over an
+* empty page, and read as marks about text that is not there they came back as
+* nothing at all. Drawn, each is what its subtype says over its own quads.
+*/
+function markupShape(file, annot, kind) {
+	const markup = textMarkupOf(file, annot);
+	if (!markup) return void 0;
+	const rgb = colorOf(file.get(annot, "C")) ?? "0 0 0";
+	const ops = [
+		"q",
+		`${rgb} rg`,
+		`${rgb} RG`
+	];
+	for (const q of markup.quads) {
+		const left = q.x0;
+		const right = q.x1;
+		const bottom = q.y0;
+		const h = q.h;
+		if (!(right > left) || !(h > 0)) continue;
+		if (kind === "Highlight") {
+			ops.push(`${num(left)} ${num(bottom)} ${num(right - left)} ${num(h)} re`, "f");
+			continue;
+		}
+		const pen = Math.max(.5, h * MARK_PEN_EM);
+		if (kind === "Squiggly") {
+			const amp = Math.max(.75, h * SQUIGGLE_AMP_EM);
+			const step = amp * 2;
+			ops.push(`${num(pen)} w`, `${num(left)} ${num(bottom + amp)} m`);
+			let up = true;
+			for (let x = left + step; x < right; x += step, up = !up) ops.push(`${num(x)} ${num(bottom + (up ? amp * 2 : 0))} l`);
+			ops.push("S");
+			continue;
+		}
+		const y = kind === "StrikeOut" ? bottom + h / 2 : bottom + pen;
+		ops.push(`${num(pen)} w`, `${num(left)} ${num(y)} m`, `${num(right)} ${num(y)} l`, "S");
+	}
+	if (ops.length <= 3) return void 0;
+	ops.push("Q");
+	return new PdfStream(/* @__PURE__ */ new Map(), new TextEncoder().encode(ops.join("\n")));
+}
+/** How thick a drawn underline or strike is, as a share of the line's height. */
+var MARK_PEN_EM = .05;
+/** How far a squiggle rises above its baseline, likewise. */
+var SQUIGGLE_AMP_EM = .07;
+/**
 * §12.7.2 `/DR` — the resources a generated field appearance draws with.
 *
 * The `/DA` string names a font (`/Helv 12 Tf`) and that name means nothing

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

@@ -9,18 +9,4 @@ export interface Appearance {
     /** The appearance's `/Resources`, when it states its own. */
     readonly resources: PdfDict | undefined;
 }
-/**
- * Every annotation appearance the page shows, in `/Annots` order — which is
- * the order they paint in, over the page's own content.
- *
- * A `Popup` is a note's window and is never part of the page. An annotation
- * flagged Hidden or NoView paints nothing. An `/AP` `/N` may be a stream or a
- * dictionary of states, in which case `/AS` names the one in force. An
- * annotation with no appearance at all gets one written for it from its own
- * geometry, where its subtype says exactly what that is ({@link drawnAppearance}).
- *
- * @param file The owning file, for resolving references.
- * @param page The page whose annotations are wanted.
- * @returns The appearances, each with the matrix that places it on the page.
- */
 export declare function collectPageAppearances(file: PdfFile, page: PdfPage): Array<Appearance>;

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

@@ -19,6 +19,18 @@ var FLAG_NOVIEW = 32;
 * @param page The page whose annotations are wanted.
 * @returns The appearances, each with the matrix that places it on the page.
 */
+/** Whether the page's own content stream shows any glyphs at all. */
+function pageHasText(file, page) {
+	const had = textful.get(page.dict);
+	if (had !== void 0) return had;
+	const content = file.pageContent(page);
+	let found = false;
+	for (let i = 0; i + 1 < content.length && !found; i++) found = content[i] === 66 && content[i + 1] === 84;
+	textful.set(page.dict, found);
+	return found;
+}
+/** One answer per page: the collector is called from three passes. */
+var textful = /* @__PURE__ */ new WeakMap();
 function collectPageAppearances(file, page) {
 	const annots = file.get(page.dict, "Annots");
 	if (!Array.isArray(annots)) return [];
@@ -28,7 +40,7 @@ function collectPageAppearances(file, page) {
 		if (!(annot instanceof Map)) continue;
 		const subtype = file.get(annot, "Subtype");
 		if (subtype instanceof PdfName && subtype.value === "Popup") continue;
-		if (textMarkupOf(file, annot)) continue;
+		if (textMarkupOf(file, annot) && pageHasText(file, page)) continue;
 		const flags = file.get(annot, "F");
 		if (typeof flags === "number" && (flags & FLAG_HIDDEN || flags & FLAG_NOVIEW)) continue;
 		const stream = normalAppearance(file, annot);

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

@@ -3,7 +3,7 @@
  * §7.4.6), pulled from the filter's `/DecodeParms`.
  */
 export interface CcittParams {
-    /** `/K` — `<0` Group 4, `0` Group 3 1-D, `>0` Group 3 2-D (unsupported). */
+    /** `/K` — `<0` Group 4, `0` Group 3 1-D, `>0` Group 3 mixed 1-D/2-D. */
     readonly k: number;
     /** `/Columns` (pixels per row). */
     readonly columns: number;
@@ -19,8 +19,7 @@ export interface CcittParams {
  * @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.
  */
 export declare function decodeCcitt(data: Uint8Array, params: CcittParams): Uint8Array | undefined;
 /**

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

@@ -6,8 +6,7 @@
 * @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);
@@ -48,14 +47,18 @@ function decodeCcittPlanes(data, columns, rows, count) {
 }
 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 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;
@@ -182,6 +185,29 @@ var BitReader = class {
 		}
 	}
 	/**
+	* 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.
 	*/
@@ -214,6 +240,8 @@ var BitReader = class {
 		}
 	}
 };
+/** 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

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;