reamkit 1.27.0 → 1.29.0

package/dist/esm/pdf-reader/math-rows.d.ts

@@ -0,0 +1,23 @@
+import { MathNode } from '../core/document-model/index.js';
+import { TextRun } from './content.js';
+/** A matrix found on the page: what to draw, where, and which runs it used. */
+export interface MathBlock {
+    /** The math object — a row of delimiters and whatever stands between them. */
+    readonly math: MathNode;
+    /** The top baseline it was drawn on, for ordering the page's blocks. */
+    readonly top: number;
+    /** Where it stands across the page. */
+    readonly x: number;
+    readonly width: number;
+    /** The runs it consumed, which the prose reading must not read again. */
+    readonly used: ReadonlySet<TextRun>;
+}
+/**
+ * The matrices a page's rows hold (§22.1.2.68 `m:m`).
+ *
+ * @param runs     The column's runs.
+ * @param fontSize The text's own size, which says how far apart the lines of
+ *                 PROSE stand — a display's sub-lines stand closer.
+ * @returns One entry per matrix found, in page order.
+ */
+export declare function matrixBlocks(runs: ReadonlyArray<TextRun>, fontSize: number): Array<MathBlock>;

package/dist/esm/pdf-reader/math-rows.js

@@ -0,0 +1,198 @@
+//#region src/pdf-reader/math-rows.ts
+/** The brackets a matrix may be written in, opening → closing. */
+var BRACKETS = new Map([
+	["(", ")"],
+	["[", "]"],
+	["{", "}"],
+	["⟨", "⟩"],
+	["|", "|"]
+]);
+/**
+* The matrices a page's rows hold (§22.1.2.68 `m:m`).
+*
+* @param runs     The column's runs.
+* @param fontSize The text's own size, which says how far apart the lines of
+*                 PROSE stand — a display's sub-lines stand closer.
+* @returns One entry per matrix found, in page order.
+*/
+function matrixBlocks(runs, fontSize) {
+	const out = [];
+	for (const cluster of clusters(baselines(runs, fontSize), fontSize)) {
+		const found = matrixFrom(cluster);
+		if (found) out.push(found);
+	}
+	return out;
+}
+/** The baseline a row of runs stands on. */
+var baselineOf = (row) => Math.max(...row.map((r) => r.y));
+/**
+* The runs grouped by the baseline they were DRAWN on, top to bottom.
+*
+* Tighter than the reading's own rows, which allow a line half an em of drift
+* so that a footnote mark stays with its word: the sub-lines of a display stand
+* six points apart in a ten-point face, and grouped that loosely
+* bug1997343.pdf's brackets joined the row of numbers under them.
+*/
+function baselines(runs, fontSize) {
+	const tol = Math.max(1, fontSize * SAME_BASELINE);
+	const out = [];
+	for (const run of [...runs].sort((a, b) => b.y - a.y || a.x - b.x)) {
+		const last = out[out.length - 1];
+		if (last && Math.abs(baselineOf(last) - run.y) <= tol) last.push(run);
+		else out.push([run]);
+	}
+	return out;
+}
+/** How far off a baseline, in ems, a run may sit and still be ON it. */
+var SAME_BASELINE = .15;
+/**
+* The runs of a page grouped into the SUB-LINES of one display: rows standing
+* closer together than a line of prose does, three or more of them (two rows
+* and the brackets between).
+*/
+function clusters(rows, fontSize) {
+	const out = [];
+	let run = [];
+	for (const row of rows) {
+		const last = run[run.length - 1];
+		if (last && baselineOf(last) - baselineOf(row) >= fontSize * SUBLINE_GAP) {
+			if (run.length >= MIN_SUBLINES) out.push(run);
+			run = [];
+		}
+		run.push(row);
+	}
+	if (run.length >= MIN_SUBLINES) out.push(run);
+	return out;
+}
+/** How far apart, in ems, two baselines have to stand to be separate LINES. */
+var SUBLINE_GAP = .9;
+/** A matrix is a row of cells above another, and the brackets between them. */
+var MIN_SUBLINES = 3;
+/** Build the matrix a cluster of sub-lines holds, or nothing where it holds none. */
+function matrixFrom(cluster) {
+	const middle = cluster.find((row) => pairsOf(row).length > 0);
+	if (!middle) return void 0;
+	const pairs = pairsOf(middle);
+	const cells = cluster.filter((row) => row !== middle);
+	if (cells.length === 0) return void 0;
+	const children = [];
+	let used = /* @__PURE__ */ new Set();
+	let at = -Infinity;
+	for (const pair of pairs) {
+		for (const run of middle) if (run.x >= at && run.endX <= pair.open.x && run.text.trim().length > 0) {
+			children.push({
+				type: "run",
+				text: spaced(run.text)
+			});
+			used.add(run);
+		}
+		const inside = matrixInside(cluster, middle, pair);
+		if (!inside) return void 0;
+		children.push({
+			type: "delimiter",
+			begChr: pair.open.text.trim(),
+			endChr: pair.close.text.trim(),
+			children: [inside.matrix]
+		});
+		used = new Set([
+			...used,
+			...inside.used,
+			pair.open,
+			pair.close
+		]);
+		at = pair.close.endX;
+	}
+	for (const run of middle) if (run.x >= at && run.text.trim().length > 0) {
+		children.push({
+			type: "run",
+			text: spaced(run.text)
+		});
+		used.add(run);
+	}
+	if (children.length === 0) return void 0;
+	for (const row of cluster) for (const run of row) if (!used.has(run)) return void 0;
+	const all = [...used];
+	return {
+		math: {
+			type: "row",
+			children
+		},
+		top: baselineOf(cells[0] ?? middle),
+		x: Math.min(...all.map((r) => r.x)),
+		width: Math.max(...all.map((r) => r.endX)) - Math.min(...all.map((r) => r.x)),
+		used
+	};
+}
+/**
+* An operator standing between two matrices, with the air the page gave it.
+* The file sets `(1 2 / 3 4)(1 1 / 0 1) = (1 3 / 3 7)` with the equals sign
+* clear of both brackets; set tight against them it reads as one word.
+*/
+var spaced = (text) => ` ${text.trim()} `;
+/** The bracket pairs a row holds, left to right and never nested. */
+function pairsOf(row) {
+	const out = [];
+	let open;
+	for (const run of [...row].sort((a, b) => a.x - b.x)) {
+		const text = run.text.trim();
+		if (open === void 0) {
+			if (BRACKETS.has(text)) open = run;
+			continue;
+		}
+		if (text === BRACKETS.get(open.text.trim())) {
+			out.push({
+				open,
+				close: run
+			});
+			open = void 0;
+		}
+	}
+	return out;
+}
+/**
+* The grid inside one bracket pair: every sub-line's runs that fall between the
+* brackets, clustered into columns by where they stand.
+*/
+function matrixInside(cluster, middle, pair) {
+	const used = /* @__PURE__ */ new Set();
+	const rows = [];
+	for (const row of cluster) {
+		const inside = row.filter((run) => run !== pair.open && run !== pair.close && run.x >= pair.open.x && run.endX <= pair.close.endX && run.text.trim().length > 0);
+		if (inside.length === 0) continue;
+		if (row === middle && inside.some((run) => BRACKETS.has(run.text.trim()))) return void 0;
+		inside.sort((a, b) => a.x - b.x);
+		for (const run of inside) used.add(run);
+		rows.push(inside);
+	}
+	if (rows.length < 2) return void 0;
+	const size = Math.max(...rows.flat().map((r) => r.fontSizePt || 10));
+	const centres = [];
+	const columnOf = (run) => {
+		const centre = (run.x + run.endX) / 2;
+		const found = centres.findIndex((c) => Math.abs(c - centre) <= size / 2);
+		if (found >= 0) return found;
+		centres.push(centre);
+		return centres.length - 1;
+	};
+	const grid = rows.map((row) => {
+		const cells = [];
+		for (const run of row) {
+			const at = columnOf(run);
+			(cells[at] ??= []).push(run.text.trim());
+		}
+		return cells;
+	});
+	const width = Math.max(...grid.map((row) => row.length));
+	return {
+		matrix: {
+			type: "matrix",
+			rows: grid.map((row) => Array.from({ length: width }, (_, i) => ({
+				type: "run",
+				text: (row[i] ?? []).join("")
+			})))
+		},
+		used
+	};
+}
+//#endregion
+export { matrixBlocks };

package/dist/esm/pdf-reader/predefined-cmap.d.ts

@@ -0,0 +1,21 @@
+/** How a named CMap breaks a string into codes, and what those codes mean. */
+export interface PredefinedCMap {
+    /** The `TextDecoder` label the code bytes are in. */
+    readonly charset: string;
+    /** Whether a byte begins a TWO-byte code; anything else stands alone. */
+    readonly leadsPair: (byte: number) => boolean;
+    /** §9.7.5.2 — a `…-V` CMap sets its text down the page. */
+    readonly vertical: boolean;
+}
+/**
+ * What a predefined CMap name comes to.
+ *
+ * @param name The `/Encoding` name, as the font states it.
+ * @returns Its encoding and code structure, or `undefined` for `Identity` and
+ *          for any name whose encoding this cannot decode.
+ */
+export declare function predefinedCMap(name: string): PredefinedCMap | undefined;
+/** Split a shown string the way this CMap's codespace says (§9.7.6.2). */
+export declare function splitPredefined(cmap: PredefinedCMap, bytes: Uint8Array): Array<number>;
+/** The character one code stands for: its own bytes, read in the CMap's encoding. */
+export declare function decodePredefined(cmap: PredefinedCMap, code: number): string;

package/dist/esm/pdf-reader/predefined-cmap.js

@@ -0,0 +1,102 @@
+//#region src/pdf-reader/predefined-cmap.ts
+/** Shift-JIS: 81–9F and E0–FC lead a pair; 00–80 and A0–DF stand alone. */
+var shiftJis = (b) => b >= 129 && b <= 159 || b >= 224 && b <= 252;
+/** The EUC family: A1–FE lead a pair, and 8E/8F introduce one as well. */
+var euc = (b) => b >= 161 || b === 142 || b === 143;
+/** Big5, GBK and UHC: everything from 81 up leads a pair. */
+var highLeads = (b) => b >= 129;
+/** Two bytes always, big-endian — the UCS-2 and UTF-16 CMaps. */
+var always = () => true;
+/** The families, longest name first so `90ms-RKSJ` is not read as `RKSJ`. */
+var FAMILIES = [
+	{
+		match: /RKSJ/u,
+		charset: "shift_jis",
+		leadsPair: shiftJis
+	},
+	{
+		match: /-EUC(-|$)|^EUC-/u,
+		charset: "euc-jp",
+		leadsPair: euc
+	},
+	{
+		match: /^(ETen|ETenms|B5pc|HKscs-B5|CNS-EUC)/u,
+		charset: "big5",
+		leadsPair: highLeads
+	},
+	{
+		match: /^(GBK|GBpc|GBK2K|GB-EUC|GBKp)/u,
+		charset: "gbk",
+		leadsPair: highLeads
+	},
+	{
+		match: /^(KSC|KSCms|KSCpc)/u,
+		charset: "euc-kr",
+		leadsPair: highLeads
+	},
+	{
+		match: /UCS2|UTF16/u,
+		charset: "utf-16be",
+		leadsPair: always
+	}
+];
+/**
+* What a predefined CMap name comes to.
+*
+* @param name The `/Encoding` name, as the font states it.
+* @returns Its encoding and code structure, or `undefined` for `Identity` and
+*          for any name whose encoding this cannot decode.
+*/
+function predefinedCMap(name) {
+	if (name.startsWith("Identity")) return void 0;
+	const vertical = name.endsWith("-V");
+	const family = FAMILIES.find((f) => f.match.test(name));
+	if (!family) return void 0;
+	if (!canDecode(family.charset)) return void 0;
+	return {
+		charset: family.charset,
+		leadsPair: family.leadsPair,
+		vertical
+	};
+}
+/** Split a shown string the way this CMap's codespace says (§9.7.6.2). */
+function splitPredefined(cmap, bytes) {
+	const out = [];
+	for (let i = 0; i < bytes.length;) {
+		const b = bytes[i];
+		if (cmap.leadsPair(b) && i + 1 < bytes.length) {
+			out.push(b << 8 | bytes[i + 1]);
+			i += 2;
+		} else {
+			out.push(b);
+			i++;
+		}
+	}
+	return out;
+}
+/** The character one code stands for: its own bytes, read in the CMap's encoding. */
+function decodePredefined(cmap, code) {
+	const bytes = code > 255 ? Uint8Array.from([code >> 8, code & 255]) : Uint8Array.from([code]);
+	try {
+		return new TextDecoder(cmap.charset, { fatal: false }).decode(bytes);
+	} catch {
+		return "";
+	}
+}
+/** Whether this runtime's `TextDecoder` carries the legacy encoding. */
+function canDecode(charset) {
+	const had = supported.get(charset);
+	if (had !== void 0) return had;
+	let ok = false;
+	try {
+		new TextDecoder(charset);
+		ok = true;
+	} catch {
+		ok = false;
+	}
+	supported.set(charset, ok);
+	return ok;
+}
+var supported = /* @__PURE__ */ new Map();
+//#endregion
+export { decodePredefined, predefinedCMap, splitPredefined };

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

@@ -13,17 +13,14 @@ import { FlowDoc } from '../core/ir/flow.js';
  *                 opens permissions-only encryption.
  * @param filters  Decoders for `/Filter` names this reader does not implement
  *                 (§7.4); see {@link StreamFilters}.
- * @param layout   `'auto'` (the default) lets the FILE decide: a page that is
- *                 mostly marks is reproduced, one that is mostly lines is re-set,
- *                 and the reader records which it chose. `'flow'` reads a
- *                 re-flowable document out of the page —
- *                 paragraphs and tables in reading order, from the structure
- *                 tree where there is one. `'positional'` keeps the page: every
- *                 line stands where its glyphs do, beside the artwork, which is
- *                 what a form or a drawing needs and what a paragraph cannot be.
  * @returns The reconstructed FlowDoc and its accumulated {@link Loss} report.
+ *
+ * Which of the two readings a file gets is the FILE's to decide and no
+ * caller's: a page that is mostly marks is reproduced where it stands, one
+ * that is mostly lines is re-set as a document, and the reader records which
+ * it chose. There is no override — see the note on {@link readingOf}.
  */
-export declare function readPdf(bytes: Uint8Array, password?: string, layout?: 'flow' | 'positional' | 'auto', filters?: StreamFilters): ReadResult<FlowDoc>;
+export declare function readPdf(bytes: Uint8Array, password?: string, filters?: StreamFilters): ReadResult<FlowDoc>;
 /**
  * The `pdfReader` adapter: a {@link DocumentReader} that sniffs the `%PDF-`
  * header and parses the bytes into a {@link FlowDoc} (E-PDF EP5).

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

@@ -40,17 +40,14 @@ function endsLikePdf(bytes) {
 *                 opens permissions-only encryption.
 * @param filters  Decoders for `/Filter` names this reader does not implement
 *                 (§7.4); see {@link StreamFilters}.
-* @param layout   `'auto'` (the default) lets the FILE decide: a page that is
-*                 mostly marks is reproduced, one that is mostly lines is re-set,
-*                 and the reader records which it chose. `'flow'` reads a
-*                 re-flowable document out of the page —
-*                 paragraphs and tables in reading order, from the structure
-*                 tree where there is one. `'positional'` keeps the page: every
-*                 line stands where its glyphs do, beside the artwork, which is
-*                 what a form or a drawing needs and what a paragraph cannot be.
 * @returns The reconstructed FlowDoc and its accumulated {@link Loss} report.
+*
+* Which of the two readings a file gets is the FILE's to decide and no
+* caller's: a page that is mostly marks is reproduced where it stands, one
+* that is mostly lines is re-set as a document, and the reader records which
+* it chose. There is no override — see the note on {@link readingOf}.
 */
-function readPdf(bytes, password = "", layout = "auto", filters = {}) {
+function readPdf(bytes, password = "", filters = {}) {
 	const file = PdfFile.parse(bytes, password, filters);
 	const losses = [];
 	if (file.encryptionUnsupported) losses.push({
@@ -63,11 +60,11 @@ function readPdf(bytes, password = "", layout = "auto", filters = {}) {
 		feature: FEATURES.text,
 		detail: `PDF stream filter /${name} is not supported; streams using it are unreadable`
 	});
-	const reading = layout === "auto" ? readingOf(file) : layout;
-	if (layout === "auto") losses.push({
+	const reading = readingOf(file);
+	losses.push({
 		severity: "degraded",
 		feature: FEATURES.text,
-		detail: reading === "positional" ? "PDF read as a PAGE (placed): its artwork outweighs its prose, so every line stands where its glyphs stand — pass pdfLayout: \"flow\" to re-set it as a document instead" : "PDF read as a DOCUMENT (flowing): its prose outweighs its artwork, so the words re-set and the artwork takes its turn in reading order — pass pdfLayout: \"positional\" to reproduce the page instead"
+		detail: reading === "positional" ? "PDF read as a PAGE (placed): its artwork outweighs its prose, so every line stands where its glyphs stand" : "PDF read as a DOCUMENT (flowing): its prose outweighs its artwork, so the words re-set and the artwork takes its turn in reading order"
 	});
 	const tagged = reading === "positional" ? void 0 : reconstructTaggedPdf(file);
 	const reconstruction = tagged ?? reconstructByLayout(file, reading);
@@ -77,11 +74,6 @@ function readPdf(bytes, password = "", layout = "auto", filters = {}) {
 		detail: "untagged PDF — text and headings reconstructed heuristically from glyph positions; structure is approximate"
 	});
 	losses.push(...reconstruction.losses);
-	losses.push({
-		severity: "dropped",
-		feature: FEATURES.images,
-		detail: "PDF bare-shading (sh) vector regions are not reconstructed"
-	});
 	return {
 		doc: reconstruction.doc,
 		losses
@@ -105,22 +97,43 @@ function readPdf(bytes, password = "", layout = "auto", filters = {}) {
 * records which reading it took and why, and the caller can name the other.
 */
 function readingOf(file) {
-	/** Below this many marks a page is prose with decoration, whatever the ratio. */
-	const ENOUGH_MARKS = 20;
+	/**
+	* Below this many marks a page is prose with decoration, whatever the ratio.
+	*
+	* It stood at twenty, and calgray.pdf is a five-by-four grid of grey swatches
+	* with a label in each: twenty boxes, of which the one painted white is not a
+	* mark anybody can see. Nineteen — one short — and all three pages of it were
+	* read as prose, the labels of each row run together into a line and the
+	* sheet spilling onto a second page. Nineteen boxes in a grid are not a page
+	* of prose with a rule under its heading.
+	*/
+	const ENOUGH_MARKS = 12;
 	/** Twice as many marks as lines is a page that is drawn rather than written. */
 	const DRAWN = 2;
+	/** Below this many runs, an angle is a stamp or a watermark and not the page. */
+	const ENOUGH_TURNED = 8;
 	const ratios = [];
 	for (const page of file.pages()) {
 		let marks = 0;
 		let lines = 0;
+		let turned = 0;
+		let runs = 0;
 		try {
 			marks = collectPageVectors(file, page, []).vectors.length;
 			const ys = /* @__PURE__ */ new Set();
-			for (const run of extractPageText(file, page)) ys.add(Math.round(run.y));
+			for (const run of extractPageText(file, page)) {
+				ys.add(Math.round(run.y));
+				runs++;
+				if (run.angleDeg !== void 0) turned++;
+			}
 			lines = ys.size;
 		} catch {
 			continue;
 		}
+		if (runs >= ENOUGH_TURNED && turned > runs * .5) {
+			ratios.push(DRAWN);
+			continue;
+		}
 		if (marks < ENOUGH_MARKS) {
 			ratios.push(0);
 			continue;
@@ -145,7 +158,7 @@ var pdfReader = {
 		FEATURES.images
 	]),
 	sniff: sniffPdf,
-	read: (bytes, opts) => readPdf(bytes, typeof opts?.password === "string" ? opts.password : "", opts?.pdfLayout === "positional" ? "positional" : opts?.pdfLayout === "flow" ? "flow" : "auto", isFilters(opts?.filters) ? opts.filters : {})
+	read: (bytes, opts) => readPdf(bytes, typeof opts?.password === "string" ? opts.password : "", isFilters(opts?.filters) ? opts.filters : {})
 };
 /** A caller's `filters` option, when it is the shape the reader can use. */
 function isFilters(value) {

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

@@ -1,4 +1,5 @@
 import { CieSpace } from './cie-color.js';
+import { IccTransform } from './icc.js';
 import { PdfFunction } from './function.js';
 import { ShapeGradient } from '../core/vector.js';
 import { PdfDict } from '../pdf/objects.js';
@@ -17,6 +18,70 @@ import { PdfFile } from './document.js';
  * @returns A map from pattern resource name to its {@link ShapeGradient}.
  */
 export declare function buildShadingMap(file: PdfFile, resources: PdfDict | undefined): Map<string, ShapeGradient>;
+/**
+ * §8.7.4.5.2 — an axial or radial shading as a gradient, for a bare `sh`.
+ *
+ * A `sh` paints the CLIP rather than a path, so what it needs is not a fill for
+ * a shape the page drew but the gradient itself, to fill the region with. It is
+ * the same reading `buildShadingMap` does for a pattern.
+ *
+ * @param file The owning file.
+ * @param sh   The shading dictionary.
+ * @returns The gradient, or `undefined` for a type this does not read.
+ */
+export declare function gradientShading(file: PdfFile, sh: PdfDict): ShapeGradient | undefined;
+/**
+ * §8.7.4.5 — which kind of shading this is, as the file states it.
+ *
+ * @param file The owning file.
+ * @param sh   The shading dictionary.
+ * @returns Its `/ShadingType`, or 0 where the file states none.
+ */
+export declare function shadingTypeOf(file: PdfFile, sh: PdfDict): number;
+/**
+ * §8.7.4.5.3 — a FUNCTION-BASED shading, sampled into a picture.
+ *
+ * Type 1 is not a ramp between two points: it is a function of two variables
+ * over a rectangle, and no gradient can stand for one. Painted by a bare `sh`
+ * it fills the clip, and nothing here lifted it at all —
+ * function_based_shading.pdf is nine such squares and 43% of the page's ink,
+ * and reconstructed to a blank sheet.
+ *
+ * Sampled it is exactly a picture, which every format downstream can show. The
+ * grid is fixed: the function is smooth by construction (§8.7.4.5.3 gives it a
+ * `/Domain` and nothing else), so more samples buy nothing a reader can see.
+ *
+ * @param file    The owning file.
+ * @param shading The shading dictionary.
+ * @returns The picture and the domain it covers, or `undefined` for a shading
+ *          of another type or one whose function cannot be run.
+ */
+export declare function sampledShading(file: PdfFile, shading: PdfDict): {
+    rgb: Uint8Array;
+    size: number;
+    domain: [number, number, number, number];
+} | undefined;
+/**
+ * §8.6.8 — the colour a run of `sc` / `scn` components comes to.
+ *
+ * The space in force decides, and where it was not read the COUNT is the next
+ * best witness: three numbers are RGB and four are CMYK on every device space
+ * there is. One number is the ambiguous case — grey in a device space, but the
+ * strength of a colorant in a Separation, where 1 is the ink at full and reads
+ * dark — so a lone component is only taken where the space said what it means.
+ *
+ * @param nums  The components, as the page or a shading's function states them.
+ * @param space The space in force, where it was read.
+ * @returns The colour as 6 hex digits, or `undefined` where the numbers do not
+ *          say what colour they are.
+ */
+export declare function spaceColor(nums: ReadonlyArray<number>, space: ColorSpaceInfo | undefined): string | undefined;
+/** Three channels, each 0..1, as 6 upper-case hex digits. */
+export declare function rgbHex(r: number, g: number, b: number): string;
+/** One grey level, 0..1, as 6 upper-case hex digits. */
+export declare function grayHex(v: number): string;
+/** §8.6.4.4 — four inks, each 0..1, as 6 upper-case hex digits. */
+export declare function cmykHex(c: number, m: number, y: number, k: number): string;
 /**
  * §11.6.4.4 — the constant fill alpha (`/ca`) of every `/ExtGState` the page
  * names, by name.
@@ -39,10 +104,17 @@ export declare function buildShadingMap(file: PdfFile, resources: PdfDict | unde
  *          state one.
  */
 export declare function buildAlphaMap(file: PdfFile, resources: PdfDict | undefined): Map<string, GsPaint>;
-/** What a `/ExtGState` says about paint that the reconstruction can carry. */
+/**
+ * What a `/ExtGState` says about paint that the reconstruction can carry.
+ *
+ * Every field is absent when the state does not NAME that parameter, because a
+ * `gs` leaves what it does not name alone (§8.4.5).
+ */
 export interface GsPaint {
-    /** §11.6.4.4 `/ca` — the constant fill alpha, when it is below 1. */
+    /** §11.6.4.4 `/ca` — the constant fill alpha, where the state names one. */
     readonly alpha?: number;
+    /** §11.3.5 — whether `/BM` is named at all, since naming `/Normal` ends a blend. */
+    readonly statesBlend?: boolean;
     /** §11.3.5 `/BM` — the paint only darkens, so what it covers shows through. */
     readonly darkens?: boolean;
     /**
@@ -53,6 +125,7 @@ export interface GsPaint {
     /**
      * §11.6.5 `/SMask` — the paint's opacity varies from place to place, out of
      * another group's luminosity or alpha. Nothing downstream has a mask like it.
+     * `false` where the state names `/None`, which takes a mask off.
      */
     readonly masked?: boolean;
 }
@@ -72,6 +145,12 @@ export interface ColorSpaceInfo {
      * out of this transform.
      */
     readonly cie?: CieSpace;
+    /**
+     * §8.6.5.5 — the transform an `/ICCBased` profile states, where its form is
+     * one this reads. Its numbers mean what the PROFILE makes of them, which for
+     * anything but an sRGB-like profile is not what a device space would.
+     */
+    readonly icc?: IccTransform;
     /**
      * §8.6.6.4/§8.6.6.5 — for a `Separation` or `DeviceN`, the way OUT of it: the
      * tint transform and the space its numbers land in. Absent where the file