reamkit 1.29.0 → 1.30.0

package/dist/esm/pdf-reader/image-decode.js

@@ -41,6 +41,8 @@ function decodePdfImage(file, stream, fillHex) {
 	const last = filters[filters.length - 1];
 	if (last === "DCTDecode" || last === "DCT") {
 		const jpegBytes = applyChainExceptLast(filters, stream.data);
+		const inks = cmykJpeg(file, d, jpegBytes, width, height);
+		if (inks) return inks;
 		const masked = hasSMask(file, d) ? maskedJpeg(file, d, jpegBytes, width, height) : void 0;
 		if (masked) return masked;
 		const degraded = hasSMask(file, d) ? "image transparency dropped (JPEG could not be decoded to attach its mask)" : void 0;
@@ -74,7 +76,7 @@ function decodePdfImage(file, stream, fillHex) {
 	}
 	const decoded = last === "CCITTFaxDecode" || last === "CCF" ? decodeCcittImage(file, stream, filters, width, height) : decodeToSamples(file, stream, filters, width, height);
 	if (typeof decoded === "string") return fail("dropped", decoded);
-	const alpha = decodeSMask(file, d, width, height);
+	const alpha = decodeSMask(file, d, width, height) ?? decoded.keyed;
 	const { color, samples } = alpha ? combineAlpha(decoded, alpha) : decoded;
 	return {
 		ok: true,
@@ -92,7 +94,40 @@ function decodeToSamples(file, stream, filters, width, height) {
 	if (!cs) return "unsupported image colour space";
 	const bpc = intOf(file.get(d, "BitsPerComponent")) || intOf(file.get(d, "BPC")) || 8;
 	const decodeArr = decodeArrayOf(file, d);
-	return toColor(cs, unpackSamples(raw, width, height, cs.components, bpc), width * height, bpc, decodeArr);
+	const integers = unpackSamples(raw, width, height, cs.components, bpc);
+	const keyed = colorKey(file, d, integers, cs.components, width * height);
+	return {
+		...toColor(cs, integers, width * height, bpc, decodeArr),
+		...keyed ? { keyed } : {}
+	};
+}
+/**
+* §8.9.6.4 — colour key masking: `/Mask` as an array of a range per colour
+* component, and a sample whose every component falls inside its range is
+* not painted. The ranges are in the image's own sample values, before any
+* `/Decode`. colorkeymask.pdf keys out every sample of full red, and painted
+* whole its red bar stood beside the green and blue ones the page shows.
+*
+* @returns The alpha it comes to, or `undefined` where no sample is keyed out.
+*/
+function colorKey(file, d, samples, n, px) {
+	const mask = file.resolve(d.get("Mask") ?? PDF_NULL);
+	if (!Array.isArray(mask) || mask.length < 2 * n) return void 0;
+	const ranges = mask.slice(0, 2 * n).map((v) => file.resolve(v));
+	if (!ranges.every((v) => typeof v === "number")) return void 0;
+	const data = new Uint8Array(px).fill(255);
+	let keyed = false;
+	for (let i = 0; i < px; i++) {
+		let inside = true;
+		for (let c = 0; c < n && inside; c++) {
+			const v = samples[i * n + c];
+			inside = v >= ranges[2 * c] && v <= ranges[2 * c + 1];
+		}
+		if (!inside) continue;
+		data[i] = 0;
+		keyed = true;
+	}
+	return keyed ? { data } : void 0;
 }
 /**
 * §7.4.7 — a `/JBIG2Decode` image: the stream's own segments, plus the shared
@@ -579,7 +614,7 @@ function unpackSamples(raw, width, height, ncomp, bpc) {
 */
 function maskedJpeg(file, d, jpegBytes, width, height) {
 	const image = decodeJpeg(jpegBytes);
-	if (!image) return void 0;
+	if (!image || image.components === 4) return void 0;
 	const alpha = decodeSMask(file, d, image.width, image.height);
 	if (!alpha) return void 0;
 	const { color: pngColor, samples } = combineAlpha(image.components === 1 ? {
@@ -624,7 +659,7 @@ function decodeSMask(file, d, width, height) {
 /** A DCT-coded mask decoded to samples, or `undefined` past the baseline decoder. */
 function jpegSamples(bytes) {
 	const decoded = decodeJpeg(bytes);
-	if (!decoded) return void 0;
+	if (!decoded || decoded.components === 4) return void 0;
 	return decoded.components === 1 ? {
 		color: "gray",
 		samples: decoded.samples
@@ -633,6 +668,37 @@ function jpegSamples(bytes) {
 		samples: decoded.samples
 	};
 }
+/**
+* §8.6.4.4 — a four-ink JPEG taken apart and given back as the colours it
+* paints, through the image's colour space and its `/Decode` (§8.9.5.2) as any
+* other sampled CMYK image is, with an `/SMask` folded in where it has one.
+*
+* @returns The picture as a PNG, or `undefined` where the JPEG is not four
+*          inks or is past the baseline decoder — it then travels as it is.
+*/
+function cmykJpeg(file, d, jpegBytes, width, height) {
+	const image = decodeJpeg(jpegBytes);
+	if (image?.components !== 4) return void 0;
+	const cs = resolveColorSpace(file, d.get("ColorSpace") ?? d.get("CS"));
+	const inks = cs?.components === 4 ? cs : {
+		kind: "cmyk",
+		components: 4
+	};
+	const px = image.width * image.height;
+	const color = toColor(inks, Uint16Array.from(image.samples), px, 8, decodeArrayOf(file, d));
+	const alpha = hasSMask(file, d) ? decodeSMask(file, d, image.width, image.height) : void 0;
+	const { color: pngColor, samples } = alpha ? combineAlpha(color, alpha) : {
+		color: color.color,
+		samples: color.samples
+	};
+	return {
+		ok: true,
+		bytes: encodePng(image.width, image.height, pngColor, samples),
+		format: "png",
+		widthPx: width,
+		heightPx: height
+	};
+}
 function combineAlpha(color, alpha) {
 	const px = alpha.data.length;
 	if (color.color === "gray") {

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

@@ -22,6 +22,11 @@ export interface PdfImage {
      * centre, which is what every downstream format does with one.
      */
     readonly rotationDeg?: number;
+    /**
+     * §8.9.5 — the CTM MIRRORS the picture: its first row stands at the foot of
+     * the box. Drawn as a flip top to bottom, and then the turn above.
+     */
+    readonly flipV?: boolean;
     /**
      * §8.5.4 — the fraction of each of the picture's OWN edges a clip cut away,
      * where one bounded it: `a:srcRect` in DrawingML terms. Absent is whole.

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

@@ -3,7 +3,7 @@ import { FEATURES } from "../core/ir/features.js";
 import { encodePng } from "../core/png-encode.js";
 import { buildAlphaMap, sampledShading } from "./shading.js";
 import { interpretContent, multiply } from "./content.js";
-import { collectPageAppearances } from "./annots.js";
+import { appearanceContent, collectPageAppearances } from "./annots.js";
 import { hiddenProperties, hiddenXObject } from "./optional-content.js";
 import { buildFonts } from "./text.js";
 import { decodePdfImage } from "./image-decode.js";
@@ -139,7 +139,7 @@ function collectPageImages(file, page) {
 		0
 	], 0, void 0, []);
 	collectPageAppearances(file, page).forEach((appearance, index) => {
-		walk(appearance.resources ?? page.resources, file.streamData(appearance.stream), appearance.ctm, 1, void 0, [Number.MAX_SAFE_INTEGER, index]);
+		walk(appearance.resources ?? page.resources, appearanceContent(file, appearance), appearance.ctm, 1, void 0, [Number.MAX_SAFE_INTEGER, index]);
 	});
 	return {
 		images,
@@ -150,6 +150,7 @@ function geometry(ctm, decoded, mcid, clip, alpha) {
 	const widthPt = Math.hypot(ctm[0], ctm[1]) || 1;
 	const heightPt = Math.hypot(ctm[2], ctm[3]) || 1;
 	const angle = Math.atan2(ctm[1], ctm[0]) * 180 / Math.PI;
+	const mirrored = ctm[0] * ctm[3] - ctm[1] * ctm[2] < 0;
 	const box = clippedUnitBox(ctm, clip);
 	const u = (box.u0 + box.u1) / 2;
 	const v = (box.v0 + box.v1) / 2;
@@ -172,6 +173,7 @@ function geometry(ctm, decoded, mcid, clip, alpha) {
 		y: cy - shownH / 2,
 		...crop ? { crop } : {},
 		...Math.abs(angle) > .5 ? { rotationDeg: angle } : {},
+		...mirrored ? { flipV: true } : {},
 		...mcid !== void 0 ? { mcid } : {},
 		...alpha !== void 0 ? { alpha } : {}
 	};

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

@@ -5,7 +5,7 @@ export interface Jbig2Bitmap {
     readonly data: Uint8Array;
 }
 /** A context's state: the Table E.1 index and which symbol is currently more probable. */
-interface Cx {
+export interface Cx {
     i: Uint8Array;
     mps: Uint8Array;
 }
@@ -71,6 +71,19 @@ 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;
+/**
+ * §B.5 — the prefix every line of standard table B.`n` is written with, the
+ * way the spec prints it: a string of bits beside the values the line covers.
+ *
+ * @param n The table's number, 1–15.
+ * @returns Its lines, shortest prefix first, each with its prefix.
+ */
+export declare function standardTableCodes(n: number): Array<{
+    prefix: string;
+    rangeLow: number;
+    rangeLen: number;
+    kind?: 'lower' | 'oob';
+}>;
 /**
  * §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.
@@ -94,6 +107,32 @@ export declare function decodeRefinement(mq: MQDecoder, cx: Cx, width: number, h
  * @returns The number of bits an id takes.
  */
 export declare function symbolCodeLength(symbols: number): number;
+/**
+ * §7.4.3.1.1 — the statistics a symbol dictionary codes its bitmaps with: the
+ * generic region's contexts and the refinement's. A dictionary may keep them
+ * when it is done (bit 9) and a later one start from them (bit 8) instead of
+ * from nothing.
+ */
+export interface BitmapContexts {
+    readonly generic: Cx;
+    readonly refine: Cx;
+}
+/**
+ * §7.4.3.2 step 3 — the statistics a symbol dictionary starts from.
+ *
+ * One that says it USES the coding context starts where the LAST dictionary it
+ * refers to was left, among those that kept theirs: the bitmaps it codes were
+ * coded against those. Started fresh, every shape of
+ * bitmap-symbol-context-reuse.pdf decoded to paper and the sheet came back
+ * blank. It starts from a copy — two dictionaries may start from the same
+ * one, and the second must not start where the first left off.
+ *
+ * @param used     Whether the dictionary's flags say it uses the context (bit 8).
+ * @param referred The segments it refers to, in the order it names them.
+ * @param kept     What each dictionary that retained its context was left with.
+ * @returns The contexts to decode with.
+ */
+export declare function startingContexts(used: boolean, referred: ReadonlyArray<number>, kept: ReadonlyMap<number, BitmapContexts>): BitmapContexts;
 /**
  * Decode an embedded JBIG2 image.
  *

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

@@ -726,8 +726,11 @@ function huffDecode(r, t) {
 * §B.5 Tables B.1–B.15 — the standard tables, as `[prefLen, rangeLen,
 * rangeLow]` with `'lower'` and `'oob'` on the two lines that need them.
 *
-* They are transcribed rather than derived, and the corpus is what checks
-* them: a table off by one line decodes rubble, and the suite says so at once.
+* They are transcribed rather than derived, and a transcription can lose a
+* line without a sound: B.7 came over four lines short and B.10 with five
+* prefixes a bit or two long, and only the files that read through those two
+* ever noticed. Every table is a complete prefix code — its lengths sum to
+* exactly one, by Kraft — and that is what the tests hold each of them to.
 */
 var STANDARD_TABLES = [
 	[
@@ -1020,18 +1023,38 @@ var STANDARD_TABLES = [
 		},
 		{
 			prefLen: 4,
-			rangeLen: 9,
+			rangeLen: 5,
 			rangeLow: 0
 		},
 		{
 			prefLen: 5,
-			rangeLen: 10,
+			rangeLen: 5,
+			rangeLow: 32
+		},
+		{
+			prefLen: 5,
+			rangeLen: 6,
+			rangeLow: 64
+		},
+		{
+			prefLen: 4,
+			rangeLen: 7,
+			rangeLow: 128
+		},
+		{
+			prefLen: 3,
+			rangeLen: 8,
+			rangeLow: 256
+		},
+		{
+			prefLen: 3,
+			rangeLen: 9,
 			rangeLow: 512
 		},
 		{
 			prefLen: 3,
 			rangeLen: 10,
-			rangeLow: 1536
+			rangeLow: 1024
 		},
 		{
 			prefLen: 5,
@@ -1042,7 +1065,7 @@ var STANDARD_TABLES = [
 		{
 			prefLen: 5,
 			rangeLen: 32,
-			rangeLow: 2560
+			rangeLow: 2048
 		}
 	],
 	[
@@ -1330,27 +1353,27 @@ var STANDARD_TABLES = [
 			rangeLow: 102
 		},
 		{
-			prefLen: 7,
+			prefLen: 6,
 			rangeLen: 6,
 			rangeLow: 134
 		},
 		{
-			prefLen: 8,
+			prefLen: 6,
 			rangeLen: 7,
 			rangeLow: 198
 		},
 		{
-			prefLen: 8,
+			prefLen: 6,
 			rangeLen: 8,
 			rangeLow: 326
 		},
 		{
-			prefLen: 8,
+			prefLen: 6,
 			rangeLen: 9,
 			rangeLow: 582
 		},
 		{
-			prefLen: 8,
+			prefLen: 6,
 			rangeLen: 10,
 			rangeLow: 1094
 		},
@@ -1879,15 +1902,15 @@ function decodeTextRegion(mq, symbols, p, stripsLog, lent) {
 *
 * @param input The symbols this dictionary inherits from the ones it refers to.
 */
-function decodeSymbolDictionary(mq, input, newCount, exportCount, template, at, refAgg, rTemplate, rAt) {
+function decodeSymbolDictionary(mq, input, newCount, exportCount, template, at, refAgg, rTemplate, rAt, contexts = freshBitmapContexts()) {
 	const iadh = new IntDecoder(mq);
 	const iadw = new IntDecoder(mq);
 	const iaex = new IntDecoder(mq);
 	const iaai = new IntDecoder(mq);
 	const iardx = new IntDecoder(mq);
 	const iardy = new IntDecoder(mq);
-	const genericCx = newContexts(65536);
-	const refineCx = newContexts(8192);
+	const genericCx = contexts.generic;
+	const refineCx = contexts.refine;
 	const newSymbols = [];
 	const num = (v) => v === OOB ? 0 : v;
 	const codeLen = symbolCodeLength(input.length + newCount);
@@ -2365,6 +2388,41 @@ function compose(dst, src, x0, y0, op) {
 		}
 	}
 }
+function freshBitmapContexts() {
+	return {
+		generic: newContexts(65536),
+		refine: newContexts(8192)
+	};
+}
+/**
+* §7.4.3.2 step 3 — the statistics a symbol dictionary starts from.
+*
+* One that says it USES the coding context starts where the LAST dictionary it
+* refers to was left, among those that kept theirs: the bitmaps it codes were
+* coded against those. Started fresh, every shape of
+* bitmap-symbol-context-reuse.pdf decoded to paper and the sheet came back
+* blank. It starts from a copy — two dictionaries may start from the same
+* one, and the second must not start where the first left off.
+*
+* @param used     Whether the dictionary's flags say it uses the context (bit 8).
+* @param referred The segments it refers to, in the order it names them.
+* @param kept     What each dictionary that retained its context was left with.
+* @returns The contexts to decode with.
+*/
+function startingContexts(used, referred, kept) {
+	const last = used ? referred.map((n) => kept.get(n)).filter((c) => c !== void 0).at(-1) : void 0;
+	if (last === void 0) return freshBitmapContexts();
+	return {
+		generic: {
+			i: last.generic.i.slice(),
+			mps: last.generic.mps.slice()
+		},
+		refine: {
+			i: last.refine.i.slice(),
+			mps: last.refine.mps.slice()
+		}
+	};
+}
 /**
 * Decode an embedded JBIG2 image.
 *
@@ -2391,6 +2449,7 @@ function decodeJbig2(data, globals, width, height) {
 	const symbolsBySegment = /* @__PURE__ */ new Map();
 	const patternsBySegment = /* @__PURE__ */ new Map();
 	const tablesBySegment = /* @__PURE__ */ new Map();
+	const contextsBySegment = /* @__PURE__ */ new Map();
 	const run = (bytes) => {
 		for (const seg of parseSegments(bytes)) {
 			const r = new Reader(bytes.subarray(seg.start, seg.end));
@@ -2496,7 +2555,8 @@ function decodeJbig2(data, globals, width, height) {
 					const refAgg = (flags & 2) !== 0;
 					const template = flags >> 10 & 3;
 					const rTemplate = flags >> 12 & 1;
-					flags & 256;
+					const ctxUsed = (flags & 256) !== 0;
+					const ctxRetained = (flags & 512) !== 0;
 					const at = [];
 					if (!huff) {
 						const n = template === 0 ? 4 : 1;
@@ -2529,7 +2589,9 @@ function decodeJbig2(data, globals, width, height) {
 						} : 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));
+					const contexts = startingContexts(ctxUsed, seg.referred, contextsBySegment);
+					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, contexts));
+					if (ctxRetained) contextsBySegment.set(seg.number, contexts);
 					continue;
 				}
 				if (seg.type === 4 || seg.type === 6 || seg.type === 7) {

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

@@ -1,9 +1,12 @@
-/** A decoded JPEG: 8-bit interleaved samples, one or three components. */
+/** A decoded JPEG: 8-bit interleaved samples, one, three or four components. */
 export interface DecodedJpeg {
     readonly width: number;
     readonly height: number;
-    /** 1 = grayscale, 3 = RGB (already converted from YCbCr where it applies). */
-    readonly components: 1 | 3;
+    /**
+     * 1 = grayscale, 3 = RGB (already converted from YCbCr where it applies),
+     * 4 = CMYK as the stream stores it (converted from YCCK where it applies).
+     */
+    readonly components: 1 | 3 | 4;
     /** `width * height * components` bytes, row-major. */
     readonly samples: Uint8Array;
 }

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

@@ -151,7 +151,7 @@ function readFrame(bytes, p) {
 	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;
+	if (count !== 1 && count !== 3 && count !== 4) return void 0;
 	const comps = [];
 	let maxH = 1;
 	let maxV = 1;
@@ -393,6 +393,15 @@ function assemble(frame, adobeTransform) {
 		components: 1,
 		samples
 	};
+	if (n === 4) {
+		if (adobeTransform === 2) ycckToCmyk(samples);
+		return {
+			width,
+			height,
+			components: 4,
+			samples
+		};
+	}
 	if (adobeTransform !== 0) ycbcrToRgb(samples);
 	return {
 		width,
@@ -401,6 +410,17 @@ function assemble(frame, adobeTransform) {
 		samples
 	};
 }
+/** Adobe's YCCK → CMYK, in place: the YCbCr → RGB conversion, complemented. */
+function ycckToCmyk(s) {
+	for (let i = 0; i < s.length; i += 4) {
+		const y = s[i];
+		const cb = s[i + 1] - 128;
+		const cr = s[i + 2] - 128;
+		s[i] = 255 - clamp(y + 1.402 * cr);
+		s[i + 1] = 255 - clamp(y - .344136 * cb - .714136 * cr);
+		s[i + 2] = 255 - clamp(y + 1.772 * cb);
+	}
+}
 /** ITU-T T.871 §7 — the JFIF YCbCr → RGB conversion, in place. */
 function ycbcrToRgb(s) {
 	for (let i = 0; i < s.length; i += 3) {

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

@@ -1,3 +1,4 @@
+import { PdfVector } from './vector.js';
 import { PdfFile } from './document.js';
 import { Reconstruction } from './flow-build.js';
 /** §9.10.2 — a glyph the face maps to no character (see `./font`). */
@@ -33,8 +34,14 @@ export declare function reconstructByLayout(file: PdfFile, mode?: 'flow' | 'posi
  * 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.
+ * A line of a right-to-left script starts at the RIGHT and ends at the left,
+ * and is read the other way round: ArabicCIDTrueType.pdf sets four lines, each
+ * flush right and shorter than the one before, and read as a left-to-right
+ * setting every pair of them ran together as one paragraph.
+ *
+ * @param prev   The line before: where it starts, how wide it is, its face,
+ *               and its text when it has any.
+ * @param next   The line after — where it starts, and how wide it is.
  * @param column The measure both were set in, when it is known.
  * @returns Whether the first line ended a paragraph.
  */
@@ -42,9 +49,26 @@ export declare function endedParagraph(prev: {
     x: number;
     width: number;
     fontSize: number;
+    text?: string;
 }, next: {
     x: number;
+    width?: number;
 }, column: {
     left: number;
     right: number;
 } | undefined): boolean;
+/**
+ * §9.6.6 — the glyphs a page draws for want of characters, gathered into the
+ * WORDS they stand in: a traced glyph that stands against the one before it,
+ * on its line and in its colour, is drawn as one shape with it.
+ *
+ * Every mark kept apart is a shape of its own in the document, anchored to
+ * the page — and a paper set in a subset whose glyphs name nothing is nothing
+ * but such marks: TAMReview.pdf came back as forty-two thousand shapes, a
+ * package no reader would open in under three minutes. The picture is the
+ * same either way.
+ *
+ * @param vectors The page's painted paths, in painting order.
+ * @returns The same paths, each run of traced glyphs made one.
+ */
+export declare function drawnWords(vectors: ReadonlyArray<PdfVector>): Array<PdfVector>;