reamkit 1.26.0 → 1.28.0

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

@@ -1,5 +1,9 @@
+import { CieSpace } from './cie-color.js';
+import { IccTransform } from './icc.js';
+import { PdfFunction } from './function.js';
 import { ShapeGradient } from '../core/vector.js';
-import { PdfFile, PdfPage } from './document.js';
+import { PdfDict } from '../pdf/objects.js';
+import { PdfFile } from './document.js';
 /**
  * Resolve a page's `/Pattern` resources into gradient fills (E-PDF EP16c, ISO
  * 32000-1 §8.7.4.5). Every `PatternType` 2 (shading) pattern is evaluated — its
@@ -8,9 +12,76 @@ import { PdfFile, PdfPage } from './document.js';
  * filled with `/Pattern cs /Pn scn`. The bare `sh` operator (clip-bounded) is
  * not captured.
  *
+ * @param file      The owning file.
+ * @param resources The resource dictionary in force — a page's, or the form or
+ *                  annotation appearance's own.
  * @returns A map from pattern resource name to its {@link ShapeGradient}.
  */
-export declare function buildShadingMap(file: PdfFile, page: PdfPage): Map<string, 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.
@@ -20,11 +91,44 @@ export declare function buildShadingMap(file: PdfFile, page: PdfPage): Map<strin
  * a green band at `ca` 0.6, meant to be read THROUGH: painted solid, the floor
  * plan under each band disappears.
  *
- * @param file The owning file.
- * @param page The page whose `/ExtGState` resources are wanted.
- * @returns Name → fill alpha, for the states that state one below 1.
+ * §11.3.5 `/BM` comes off the same dictionary. A blend nothing downstream can
+ * perform is still worth knowing: `Multiply` and `Darken` both let dark ink
+ * under the paint show through, which is what a highlighter IS, and a mark that
+ * only darkens belongs UNDER the words rather than over them.
+ *
+ * @param file      The owning file.
+ * @param resources The resource dictionary in force — a page's, or the form or
+ *                  annotation appearance's own, since `gs` resolves against
+ *                  whichever is current.
+ * @returns Name → the fill alpha and blend worth carrying, for the states that
+ *          state one.
  */
-export declare function buildAlphaMap(file: PdfFile, page: PdfPage): Map<string, number>;
+export declare function buildAlphaMap(file: PdfFile, resources: PdfDict | undefined): Map<string, GsPaint>;
+/**
+ * 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, 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;
+    /**
+     * §11.3.5 `/BM` — a blend NOTHING downstream can perform, named so the loss
+     * report can say which. `Normal` is no blend at all and is never named here.
+     */
+    readonly blend?: string;
+    /**
+     * §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;
+}
 /**
  * §8.6 — how many components a colour space takes, and what they mean.
  *
@@ -35,6 +139,33 @@ export declare function buildAlphaMap(file: PdfFile, page: PdfPage): Map<string,
 export interface ColorSpaceInfo {
     readonly kind: 'gray' | 'rgb' | 'cmyk' | 'tint';
     readonly components: number;
+    /**
+     * §8.6.5.6/§8.6.5.7 — the CIE parameters, for a `CalGray` or `CalRGB` space.
+     * Its numbers look like a device space's and are not: they mean what comes
+     * 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
+     * states a transform this cannot run, and then a tint is only "this much ink".
+     */
+    readonly tint?: {
+        readonly transform: PdfFunction;
+        readonly alternate: ColorSpaceInfo;
+    };
 }
-/** The spaces a page's `/ColorSpace` resources name, by name. */
-export declare function buildColorSpaceMap(file: PdfFile, page: PdfPage): Map<string, ColorSpaceInfo>;
+/**
+ * The spaces a `/ColorSpace` resource dictionary names, by name.
+ *
+ * @param file      The owning file.
+ * @param resources The resource dictionary in force.
+ * @returns Name → what the space comes to, for the spaces that are read.
+ */
+export declare function buildColorSpaceMap(file: PdfFile, resources: PdfDict | undefined): Map<string, ColorSpaceInfo>;

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

@@ -1,4 +1,7 @@
 import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { cieToSrgb } from "./cie-color.js";
+import { iccTransform } from "./icc.js";
+import { readFunction } from "./function.js";
 //#region src/pdf-reader/shading.ts
 /**
 * Resolve a page's `/Pattern` resources into gradient fills (E-PDF EP16c, ISO
@@ -8,12 +11,15 @@ import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
 * filled with `/Pattern cs /Pn scn`. The bare `sh` operator (clip-bounded) is
 * not captured.
 *
+* @param file      The owning file.
+* @param resources The resource dictionary in force — a page's, or the form or
+*                  annotation appearance's own.
 * @returns A map from pattern resource name to its {@link ShapeGradient}.
 */
-function buildShadingMap(file, page) {
+function buildShadingMap(file, resources) {
 	const out = /* @__PURE__ */ new Map();
-	if (!page.resources) return out;
-	const patterns = file.get(page.resources, "Pattern");
+	if (!resources) return out;
+	const patterns = file.get(resources, "Pattern");
 	if (!(patterns instanceof Map)) return out;
 	for (const [nm, value] of patterns) {
 		const pat = file.resolve(value);
@@ -25,10 +31,34 @@ function buildShadingMap(file, page) {
 	}
 	return out;
 }
+/**
+* §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.
+*/
+function gradientShading(file, sh) {
+	return parseShading(file, sh);
+}
+/**
+* §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.
+*/
+function shadingTypeOf(file, sh) {
+	return numOf(file.get(sh, "ShadingType"));
+}
 function parseShading(file, sh) {
 	const type = numOf(file.get(sh, "ShadingType"));
 	if (type !== 2 && type !== 3) return void 0;
-	const stops = parseFunction(file, sh.get("Function"));
+	const stops = parseFunction(file, sh.get("Function"), shadingSpace(file, sh));
 	if (!stops || stops.length === 0) return void 0;
 	if (type === 3) return {
 		kind: "radial",
@@ -41,14 +71,14 @@ function parseShading(file, sh) {
 		stops
 	};
 }
-function parseFunction(file, value) {
+function parseFunction(file, value, space) {
 	const resolved = value !== void 0 ? file.resolve(value) : void 0;
 	const dict = dictOf(resolved);
 	if (!dict) return void 0;
 	const type = numOf(file.get(dict, "FunctionType"));
 	if (type === 2) {
-		const c0 = colorOf(numArray(file, dict.get("C0")) ?? [0]);
-		const c1 = colorOf(numArray(file, dict.get("C1")) ?? [1]);
+		const c0 = colorOf(numArray(file, dict.get("C0")) ?? [0], space);
+		const c1 = colorOf(numArray(file, dict.get("C1")) ?? [1], space);
 		return [{
 			offset: 0,
 			colorHex: c0
@@ -73,16 +103,100 @@ function parseFunction(file, value) {
 		const stops = [];
 		const span = d1 - d0 || 1;
 		for (let i = 0; i < subs.length; i++) {
-			const sub = parseFunction(file, subs[i]);
-			if (!sub || sub.length < 2) continue;
-			pushStop(stops, ((edges[i] ?? d0) - d0) / span, sub[0].colorHex);
-			pushStop(stops, ((edges[i + 1] ?? d1) - d0) / span, sub[sub.length - 1].colorHex);
+			const sub = parseFunction(file, subs[i], space);
+			if (!sub || sub.length === 0) continue;
+			const lo = ((edges[i] ?? d0) - d0) / span;
+			const hi = ((edges[i + 1] ?? d1) - d0) / span;
+			for (const stop of sub) pushStop(stops, lo + stop.offset * (hi - lo), stop.colorHex);
 		}
 		return stops.length > 0 ? stops : void 0;
 	}
-	if (type === 0 && resolved instanceof PdfStream) return sampleFunction(file, resolved);
+	if (type === 0 && resolved instanceof PdfStream) return sampleFunction(file, resolved, space);
+	if (type === 4) {
+		const fn = readFunction(file, resolved);
+		if (!fn) return void 0;
+		const domain = numArray(file, dict.get("Domain")) ?? [0, 1];
+		const d0 = domain[0] ?? 0;
+		const d1 = domain[1] ?? 1;
+		const stops = [];
+		for (let s = 0; s < PS_STOPS; s++) {
+			const off = s / (PS_STOPS - 1);
+			pushStop(stops, off, colorOf(fn([d0 + off * (d1 - d0)]), space));
+		}
+		return stops.length > 0 ? stops : void 0;
+	}
+}
+/**
+* §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.
+*/
+function sampledShading(file, shading) {
+	if (numOf(file.get(shading, "ShadingType")) !== 1) return void 0;
+	const space = shadingSpace(file, shading);
+	const fn = readFunction(file, shading.get("Function"));
+	if (!fn) return void 0;
+	const d = numArray(file, shading.get("Domain")) ?? [
+		0,
+		1,
+		0,
+		1
+	];
+	if (d.length < 4) return void 0;
+	const domain = [
+		d[0],
+		d[1],
+		d[2],
+		d[3]
+	];
+	const size = SAMPLED_SIDE;
+	const rgb = new Uint8Array(size * size * 3);
+	for (let row = 0; row < size; row++) {
+		const y = domain[3] - (row + .5) / size * (domain[3] - domain[2]);
+		for (let col = 0; col < size; col++) {
+			const hex = colorOf(fn([domain[0] + (col + .5) / size * (domain[1] - domain[0]), y]), space);
+			const at = (row * size + col) * 3;
+			rgb[at] = Number.parseInt(hex.slice(0, 2), 16);
+			rgb[at + 1] = Number.parseInt(hex.slice(2, 4), 16);
+			rgb[at + 2] = Number.parseInt(hex.slice(4, 6), 16);
+		}
+	}
+	return {
+		rgb,
+		size,
+		domain
+	};
+}
+/**
+* §8.7.4.5 — the colour space a shading's function lands in.
+*
+* The components alone do not say: a `/Separation` function gives ONE number
+* and that number is a strength of ink, not a grey level.
+* function_based_shading_cmyk.pdf's third square is a spot colour whose full
+* tint is a warm red, and read as grey it came back a black-to-white ramp.
+*/
+function shadingSpace(file, sh) {
+	const cs = sh.get("ColorSpace");
+	return cs === void 0 ? void 0 : colorSpaceAt(file, file.resolve(cs), 0);
 }
-function sampleFunction(file, stream) {
+/** How many samples a side a function-based shading is drawn at. */
+var SAMPLED_SIDE = 128;
+/** How many places a type-4 gradient is sampled at along its domain. */
+var PS_STOPS = 16;
+function sampleFunction(file, stream, space) {
 	const d = stream.dict;
 	const size = numArray(file, d.get("Size"));
 	const range = numArray(file, d.get("Range"));
@@ -129,18 +243,63 @@ function numArray(file, v) {
 	if (!Array.isArray(r)) return void 0;
 	return r.map((x) => typeof x === "number" ? x : 0);
 }
-function colorOf(c) {
-	if (c.length >= 4) {
-		const k = c[3];
-		return hex255(255 * (1 - c[0]) * (1 - k), 255 * (1 - c[1]) * (1 - k), 255 * (1 - c[2]) * (1 - k));
+function colorOf(c, space) {
+	return spaceColor(c, space) ?? spaceColor(c, void 0) ?? grayHex(c[0] ?? 0);
+}
+/**
+* §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.
+*/
+function spaceColor(nums, space) {
+	if (nums.length === 0) return void 0;
+	if (space?.icc && nums.length >= space.components) {
+		const [r, g, b] = space.icc(nums);
+		return rgbHex(r, g, b);
+	}
+	if (space?.cie) {
+		const [r, g, b] = cieToSrgb(space.cie, nums);
+		return rgbHex(r, g, b);
+	}
+	switch (space?.kind ?? (nums.length === 3 ? "rgb" : nums.length === 4 ? "cmyk" : void 0)) {
+		case "rgb": return nums.length >= 3 ? rgbHex(nums[0], nums[1], nums[2]) : void 0;
+		case "cmyk": return nums.length >= 4 ? cmykHex(nums[0], nums[1], nums[2], nums[3]) : void 0;
+		case "gray": return grayHex(nums[0]);
+		case "tint":
+			if (space?.tint) {
+				const hex = spaceColor(space.tint.transform(nums), space.tint.alternate);
+				if (hex !== void 0) return hex;
+			}
+			return grayHex(1 - Math.max(...nums));
+		default: return;
 	}
-	if (c.length === 3) return hex255(c[0] * 255, c[1] * 255, c[2] * 255);
-	const g = (c[0] ?? 0) * 255;
-	return hex255(g, g, g);
 }
-function hex255(r, g, b) {
-	const h = (x) => Math.max(0, Math.min(255, Math.round(x))).toString(16).padStart(2, "0");
-	return (h(r) + h(g) + h(b)).toUpperCase();
+function clamp255(v) {
+	return Math.max(0, Math.min(255, Math.round(v * 255)));
+}
+function hex2(v) {
+	return clamp255(v).toString(16).padStart(2, "0");
+}
+/** Three channels, each 0..1, as 6 upper-case hex digits. */
+function rgbHex(r, g, b) {
+	return (hex2(r) + hex2(g) + hex2(b)).toUpperCase();
+}
+/** One grey level, 0..1, as 6 upper-case hex digits. */
+function grayHex(v) {
+	return rgbHex(v, v, v);
+}
+/** §8.6.4.4 — four inks, each 0..1, as 6 upper-case hex digits. */
+function cmykHex(c, m, y, k) {
+	return rgbHex((1 - c) * (1 - k), (1 - m) * (1 - k), (1 - y) * (1 - k));
 }
 function pushStop(stops, offset, colorHex) {
 	const o = Math.max(0, Math.min(1, offset));
@@ -162,37 +321,70 @@ function pushStop(stops, offset, colorHex) {
 * a green band at `ca` 0.6, meant to be read THROUGH: painted solid, the floor
 * plan under each band disappears.
 *
-* @param file The owning file.
-* @param page The page whose `/ExtGState` resources are wanted.
-* @returns Name → fill alpha, for the states that state one below 1.
+* §11.3.5 `/BM` comes off the same dictionary. A blend nothing downstream can
+* perform is still worth knowing: `Multiply` and `Darken` both let dark ink
+* under the paint show through, which is what a highlighter IS, and a mark that
+* only darkens belongs UNDER the words rather than over them.
+*
+* @param file      The owning file.
+* @param resources The resource dictionary in force — a page's, or the form or
+*                  annotation appearance's own, since `gs` resolves against
+*                  whichever is current.
+* @returns Name → the fill alpha and blend worth carrying, for the states that
+*          state one.
 */
-function buildAlphaMap(file, page) {
+function buildAlphaMap(file, resources) {
 	const out = /* @__PURE__ */ new Map();
-	if (!page.resources) return out;
-	const states = file.get(page.resources, "ExtGState");
+	if (!resources) return out;
+	const states = file.get(resources, "ExtGState");
 	if (!(states instanceof Map)) return out;
 	for (const [name, value] of states) {
 		const state = file.resolve(value);
 		if (!(state instanceof Map)) continue;
 		const ca = file.resolve(state.get("ca") ?? PDF_NULL);
-		if (typeof ca === "number" && ca >= 0 && ca < 1) out.set(name, ca);
+		const alpha = typeof ca === "number" && ca >= 0 && ca <= 1 ? ca : void 0;
+		const bm = file.resolve(state.get("BM") ?? PDF_NULL);
+		const first = Array.isArray(bm) ? file.resolve(bm[0] ?? PDF_NULL) : bm;
+		const mode = first instanceof PdfName ? first.value : void 0;
+		const darkens = mode === "Multiply" || mode === "Darken";
+		const blend = mode !== void 0 && mode !== "Normal" && mode !== "Compatible" && !darkens ? mode : void 0;
+		const statesMask = state.has("SMask");
+		const masked = statesMask ? file.resolve(state.get("SMask") ?? PDF_NULL) instanceof Map : void 0;
+		if (alpha === void 0 && mode === void 0 && !statesMask) continue;
+		out.set(name, {
+			...alpha !== void 0 ? { alpha } : {},
+			...mode !== void 0 ? {
+				statesBlend: true,
+				darkens
+			} : {},
+			...blend !== void 0 ? { blend } : {},
+			...masked !== void 0 ? { masked } : {}
+		});
 	}
 	return out;
 }
-/** The spaces a page's `/ColorSpace` resources name, by name. */
-function buildColorSpaceMap(file, page) {
+/**
+* The spaces a `/ColorSpace` resource dictionary names, by name.
+*
+* @param file      The owning file.
+* @param resources The resource dictionary in force.
+* @returns Name → what the space comes to, for the spaces that are read.
+*/
+function buildColorSpaceMap(file, resources) {
 	const out = /* @__PURE__ */ new Map();
-	if (!page.resources) return out;
-	const spaces = file.get(page.resources, "ColorSpace");
+	if (!resources) return out;
+	const spaces = file.get(resources, "ColorSpace");
 	if (!(spaces instanceof Map)) return out;
 	for (const [name, value] of spaces) {
-		const info = colorSpaceInfo(file, file.resolve(value));
+		const info = colorSpaceAt(file, file.resolve(value), 0);
 		if (info) out.set(name, info);
 	}
 	return out;
 }
+/** An alternate space may name another; this is where that stops. */
+var MAX_ALTERNATE = 4;
 /** What a colour space object comes to, or `undefined` for one not read. */
-function colorSpaceInfo(file, cs) {
+function colorSpaceAt(file, cs, depth) {
 	if (cs instanceof PdfName) return byFamily(cs.value, 0);
 	if (!Array.isArray(cs) || cs.length === 0) return void 0;
 	const head = file.resolve(cs[0]);
@@ -200,18 +392,96 @@ function colorSpaceInfo(file, cs) {
 	if (head.value === "ICCBased") {
 		const stream = file.resolve(cs[1] ?? PDF_NULL);
 		const n = stream instanceof PdfStream ? file.get(stream.dict, "N") : void 0;
-		return byFamily("ICCBased", typeof n === "number" ? n : 3);
+		const base = byFamily("ICCBased", typeof n === "number" ? n : 3);
+		if (!base || !(stream instanceof PdfStream)) return base;
+		let icc;
+		try {
+			icc = iccTransform(file.streamData(stream));
+		} catch {
+			icc = void 0;
+		}
+		return icc ? {
+			...base,
+			icc
+		} : base;
 	}
 	if (head.value === "Indexed") return;
+	if (head.value === "CalRGB") {
+		const params = file.resolve(cs[1] ?? PDF_NULL);
+		const cie = params instanceof Map ? cieParams(file, params, true) : void 0;
+		const base = {
+			kind: "rgb",
+			components: 3
+		};
+		return cie ? {
+			...base,
+			cie
+		} : base;
+	}
+	if (head.value === "CalGray") {
+		const params = file.resolve(cs[1] ?? PDF_NULL);
+		const cie = params instanceof Map ? cieParams(file, params, false) : void 0;
+		const base = {
+			kind: "gray",
+			components: 1
+		};
+		return cie ? {
+			...base,
+			cie
+		} : base;
+	}
 	if (head.value === "Separation" || head.value === "DeviceN") {
 		const names = file.resolve(cs[1] ?? PDF_NULL);
+		const n = head.value === "Separation" ? 1 : Array.isArray(names) ? names.length : 1;
+		const alternate = depth < MAX_ALTERNATE ? colorSpaceAt(file, file.resolve(cs[2] ?? PDF_NULL), depth + 1) : void 0;
+		const transform = readFunction(file, cs[3]);
+		if (alternate && transform && alternate.kind !== "tint") return {
+			kind: "tint",
+			components: n,
+			tint: {
+				transform,
+				alternate
+			}
+		};
 		return {
 			kind: "tint",
-			components: head.value === "Separation" ? 1 : Array.isArray(names) ? names.length : 1
+			components: n
 		};
 	}
 	return byFamily(head.value, 0);
 }
+/** §8.6.5.6/§8.6.5.7 — the white point, gamma and matrix a CIE space states. */
+function cieParams(file, params, rgb) {
+	const nums = (v) => Array.isArray(v) ? v.map((x) => file.resolve(x)).filter((x) => typeof x === "number") : [];
+	const white = nums(file.get(params, "WhitePoint"));
+	if (white.length < 3 || !(white[1] > 0)) return void 0;
+	const gammaRaw = file.get(params, "Gamma");
+	const gamma = typeof gammaRaw === "number" ? [gammaRaw] : nums(gammaRaw);
+	const matrix = nums(file.get(params, "Matrix"));
+	return {
+		white: [
+			white[0],
+			white[1],
+			white[2]
+		],
+		gamma: gamma.length > 0 ? gamma : rgb ? [
+			1,
+			1,
+			1
+		] : [1],
+		...rgb ? { matrix: matrix.length === 9 ? matrix : [
+			1,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			1
+		] } : {}
+	};
+}
 function byFamily(family, n) {
 	switch (family) {
 		case "DeviceGray":
@@ -246,4 +516,4 @@ function byFamily(family, n) {
 	}
 }
 //#endregion
-export { buildAlphaMap, buildColorSpaceMap, buildShadingMap };
+export { buildAlphaMap, buildColorSpaceMap, buildShadingMap, cmykHex, gradientShading, grayHex, rgbHex, sampledShading, shadingTypeOf, spaceColor };

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

@@ -0,0 +1,8 @@
+/**
+ * One face's metrics: `name code width` triples, where the name is the
+ * glyph's own, the code is the one Adobe's built-in encoding gives it, and
+ * the width is its advance in 1000ths of an em.
+ */
+export declare const STANDARD_METRICS: Readonly<Record<string, string>>;
+/** Every Courier is 600 wide, every glyph — it is a typewriter face. */
+export declare const COURIER_WIDTH = 600;