reamkit 1.29.0 → 1.30.0

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

@@ -71,6 +71,16 @@ export declare class Lexer {
      * `endstream` when a stream's `/Length` is missing or an unresolved reference.
      */
     indexOfAscii(needle: string, from: number): number;
+    /**
+     * Where `word` next stands as a keyword of its own — whitespace (or the
+     * start) before it, whitespace, a delimiter or the end after it — rather
+     * than as two bytes inside something else.
+     *
+     * @param word The keyword.
+     * @param from Where to start looking.
+     * @returns Its offset, or −1 where it does not stand anywhere after `from`.
+     */
+    indexOfKeyword(word: string, from: number): number;
     /**
      * §7.3.8.1 — read a stream's raw bytes. `pos` must sit right after the `stream`
      * keyword. The keyword is followed by CRLF (or a lone LF); the data then runs

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

@@ -252,6 +252,23 @@ var Lexer = class {
 		return -1;
 	}
 	/**
+	* Where `word` next stands as a keyword of its own — whitespace (or the
+	* start) before it, whitespace, a delimiter or the end after it — rather
+	* than as two bytes inside something else.
+	*
+	* @param word The keyword.
+	* @param from Where to start looking.
+	* @returns Its offset, or −1 where it does not stand anywhere after `from`.
+	*/
+	indexOfKeyword(word, from) {
+		for (let at = this.indexOfAscii(word, from); at >= 0; at = this.indexOfAscii(word, at + 1)) {
+			const before = this.byteAt(at - 1);
+			const after = this.byteAt(at + word.length);
+			if ((at === from || before < 0 || isWhitespace(before)) && (after < 0 || isWhitespace(after) || isDelimiter(after))) return at;
+		}
+		return -1;
+	}
+	/**
 	* §7.3.8.1 — read a stream's raw bytes. `pos` must sit right after the `stream`
 	* keyword. The keyword is followed by CRLF (or a lone LF); the data then runs
 	* for `length` bytes, or — when the length is unknown — up to `endstream`.

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

@@ -12,6 +12,16 @@ export interface PatternTint {
  * @param file      The owning file.
  * @param resources The resources the pattern is named in.
  * @param name      The pattern's resource name.
+ * @param paint     §8.7.3.3 — the colour an UNCOLOURED pattern (`/PaintType
+ *                  2`) is painted in, which the page gives with `scn` and its
+ *                  own content may not state.
  * @returns Its colour and coverage, or `undefined` when neither can be told.
  */
-export declare function patternTint(file: PdfFile, resources: PdfDict | undefined, name: string): PatternTint | undefined;
+export declare function patternTint(file: PdfFile, resources: PdfDict | undefined, name: string, paint?: string): PatternTint | undefined;
+/**
+ * A colour laid over white paper at `coverage` strength, as a 6-hex string.
+ *
+ * @param colorHex The colour at full strength.
+ * @param coverage How much of the paper it covers, `0..1`.
+ */
+export declare function tintedHex(colorHex: string, coverage: number): string;

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

@@ -12,9 +12,12 @@ var MAX_DEPTH = 4;
 * @param file      The owning file.
 * @param resources The resources the pattern is named in.
 * @param name      The pattern's resource name.
+* @param paint     §8.7.3.3 — the colour an UNCOLOURED pattern (`/PaintType
+*                  2`) is painted in, which the page gives with `scn` and its
+*                  own content may not state.
 * @returns Its colour and coverage, or `undefined` when neither can be told.
 */
-function patternTint(file, resources, name) {
+function patternTint(file, resources, name, paint) {
 	if (!resources) return void 0;
 	const patterns = file.get(resources, "Pattern");
 	if (!(patterns instanceof Map)) return void 0;
@@ -25,13 +28,28 @@ function patternTint(file, resources, name) {
 	const marks = [];
 	const colours = [];
 	collect(file, stream, resources, marks, colours, 0, /* @__PURE__ */ new Set());
-	const colorHex = colours[0];
+	const colorHex = file.get(stream.dict, "PaintType") === 2 ? paint : colours[0] ?? paint;
 	if (colorHex === void 0) return void 0;
 	return {
 		colorHex,
 		coverage: sample(marks, cell)
 	};
 }
+/**
+* A colour laid over white paper at `coverage` strength, as a 6-hex string.
+*
+* @param colorHex The colour at full strength.
+* @param coverage How much of the paper it covers, `0..1`.
+*/
+function tintedHex(colorHex, coverage) {
+	const k = Math.min(1, Math.max(0, coverage));
+	if (k >= 1) return colorHex;
+	const channel = (at) => {
+		const c = Number.parseInt(colorHex.slice(at, at + 2), 16);
+		return Math.round(255 - (255 - (Number.isFinite(c) ? c : 0)) * k).toString(16).toUpperCase().padStart(2, "0");
+	};
+	return `${channel(0)}${channel(2)}${channel(4)}`;
+}
 /** The cell a tile repeats on: `/XStep` × `/YStep` from the `/BBox`'s corner. */
 function cellOf(file, dict) {
 	const bbox = numbers(file, dict.get("BBox"));
@@ -178,4 +196,4 @@ function asNumber(v) {
 	return typeof v === "number" ? v : NaN;
 }
 //#endregion
-export { patternTint };
+export { patternTint, tintedHex };

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

@@ -0,0 +1,25 @@
+import { TextRun } from './content.js';
+/** A band of blocks side by side, each a column of its own. */
+export interface SideBySide {
+    readonly kind: 'side';
+    readonly cells: ReadonlyArray<{
+        readonly runs: ReadonlyArray<TextRun>;
+        /** Where the cell's own ink starts and ends across the page. */
+        readonly from: number;
+        readonly to: number;
+    }>;
+}
+/** A stretch of the column read line by line, straight down. */
+export interface Flowing {
+    readonly kind: 'flow';
+    readonly runs: ReadonlyArray<TextRun>;
+}
+export type Region = Flowing | SideBySide;
+/**
+ * The column's runs cut into its regions, top of the page first.
+ *
+ * @param runs The column's runs.
+ * @returns The regions, in reading order; one `flow` region where the column
+ *          has no side-by-side band.
+ */
+export declare function regionsOf(runs: ReadonlyArray<TextRun>): Array<Region>;

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

@@ -0,0 +1,167 @@
+//#region src/pdf-reader/regions.ts
+/**
+* The column's runs cut into its regions, top of the page first.
+*
+* @param runs The column's runs.
+* @returns The regions, in reading order; one `flow` region where the column
+*          has no side-by-side band.
+*/
+function regionsOf(runs) {
+	const lines = clusterLines(runs);
+	const out = [];
+	let pending = [];
+	const flush = (flow) => {
+		if (flow.length > 0) out.push({
+			kind: "flow",
+			runs: flow.flatMap((l) => l.runs)
+		});
+	};
+	let floor = 0;
+	for (let i = 0; i < lines.length;) {
+		const band = bandFrom(lines, i, floor);
+		if (band === void 0) {
+			pending.push(lines[i]);
+			i++;
+			continue;
+		}
+		flush(pending.slice(0, pending.length - (i - band.start)));
+		out.push(band.region);
+		pending = [];
+		i = band.end;
+		floor = band.end;
+	}
+	flush(pending);
+	return out;
+}
+function clusterLines(runs) {
+	const sorted = [...runs].sort((a, b) => b.y - a.y || a.x - b.x);
+	const out = [];
+	for (const run of sorted) {
+		const last = out[out.length - 1];
+		if (last && Math.abs(last.y - run.y) <= Math.max(1, (run.fontSizePt || 10) * .5)) {
+			last.runs.push(run);
+			last.size = Math.max(last.size, run.fontSizePt || 0);
+		} else out.push({
+			y: run.y,
+			size: run.fontSizePt || 10,
+			runs: [run]
+		});
+	}
+	return out;
+}
+/** What a run marks: nothing for a blank or for a glyph that names no character. */
+var inked = (r) => r.text.replaceAll("�", "").trim() !== "";
+/** A line's pieces: its runs cut where a gap only a column leaves opens. */
+function piecesOf(line) {
+	const runs = line.runs.filter(inked).sort((a, b) => a.x - b.x);
+	const out = [];
+	for (const run of runs) {
+		const last = out[out.length - 1];
+		const size = run.fontSizePt || 10;
+		if (last && run.x - last.to < Math.max(size, last.size) * PIECE_GAP_EM) {
+			last.to = Math.max(last.to, run.endX);
+			last.ys.push(run.y);
+			last.size = Math.max(last.size, size);
+		} else out.push({
+			from: run.x,
+			to: run.endX,
+			ys: [run.y],
+			size
+		});
+	}
+	return out.map((p) => ({
+		from: p.from,
+		to: p.to,
+		y: middle(p.ys),
+		size: p.size
+	}));
+}
+/**
+* Whether a line's pieces stand on different baselines — the mark of two
+* blocks set side by side with leading of their own, which the clustering has
+* run together.
+*/
+function misaligned(line) {
+	const pieces = piecesOf(line);
+	if (pieces.length < 2) return false;
+	const ys = pieces.map((p) => p.y);
+	const size = Math.min(...pieces.map((p) => p.size));
+	return Math.max(...ys) - Math.min(...ys) > Math.max(ALIGN_SLACK_PT, size * ALIGN_SLACK_EM);
+}
+/**
+* The side-by-side band starting at line `i`, where one does: lines around a
+* misaligned one that keep clear of the same gutters, cut into the blocks
+* between them.
+*/
+function bandFrom(lines, i, floor) {
+	if (!misaligned(lines[i])) return void 0;
+	let from = i;
+	let to = i + 1;
+	const count = (a, b) => guttersOf(lines.slice(a, b)).length;
+	if (count(from, to) === 0) return void 0;
+	const near = (a, b) => Math.abs(a.y - b.y) <= Math.max(a.size, b.size) * BAND_REACH_EM;
+	while (to < lines.length && near(lines[to - 1], lines[to]) && count(from, to + 1) >= count(from, to)) to++;
+	while (from > floor && near(lines[from], lines[from - 1]) && count(from - 1, to) >= count(from, to)) from--;
+	const band = lines.slice(from, to);
+	const gutters = guttersOf(band);
+	if (gutters.length === 0) return void 0;
+	const edges = [
+		-Infinity,
+		...gutters.map((g) => (g.from + g.to) / 2),
+		Infinity
+	];
+	const cells = edges.slice(0, -1).map((left, k) => {
+		const right = edges[k + 1];
+		const runs = band.flatMap((l) => l.runs.filter((r) => {
+			const mid = (r.x + r.endX) / 2;
+			return mid >= left && mid < right;
+		}));
+		const ink = runs.filter(inked);
+		return {
+			runs,
+			from: Math.min(...ink.map((r) => r.x)),
+			to: Math.max(...ink.map((r) => r.endX))
+		};
+	});
+	if (cells.filter((c) => c.runs.some(inked)).length < 2) return void 0;
+	return {
+		region: {
+			kind: "side",
+			cells: cells.filter((c) => c.runs.some(inked))
+		},
+		start: from,
+		end: to
+	};
+}
+/** The strips across a band that no line's ink crosses, and that are wide enough to be gutters. */
+function guttersOf(band) {
+	const spans = band.flatMap((l) => piecesOf(l)).map((p) => [p.from, p.to]).sort((a, b) => a[0] - b[0]);
+	const size = middle(band.map((l) => l.size));
+	const out = [];
+	let reach = spans[0]?.[1] ?? 0;
+	for (const [from, to] of spans.slice(1)) {
+		if (from - reach >= size * PIECE_GAP_EM) out.push({
+			from: reach,
+			to: from
+		});
+		reach = Math.max(reach, to);
+	}
+	return out;
+}
+function middle(values) {
+	const sorted = [...values].sort((a, b) => a - b);
+	return sorted[Math.floor(sorted.length / 2)] ?? 0;
+}
+/** A gap this wide, in ems, is one a column leaves, not a word space or a tab within a line. */
+var PIECE_GAP_EM = 1.5;
+/**
+* How far apart two pieces' baselines may stand and still be one line: past a
+* point and a half — or a sixth of the size — the two were set with leading of
+* their own, not on one line with a rounding in it.
+*/
+var ALIGN_SLACK_PT = 1.5;
+var ALIGN_SLACK_EM = 1 / 6;
+/** How far, in ems, a line may stand from the band and still belong to it. */
+var BAND_REACH_EM = 2.5;
+//#endregion
+export { regionsOf };

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

@@ -4,6 +4,7 @@ import { PdfFunction } from './function.js';
 import { ShapeGradient } from '../core/vector.js';
 import { PdfDict } from '../pdf/objects.js';
 import { PdfFile } from './document.js';
+import { Matrix } from './content.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
@@ -17,7 +18,45 @@ import { PdfFile } from './document.js';
  *                  annotation appearance's own.
  * @returns A map from pattern resource name to its {@link ShapeGradient}.
  */
-export declare function buildShadingMap(file: PdfFile, resources: PdfDict | undefined): Map<string, ShapeGradient>;
+export declare function buildShadingMap(file: PdfFile, resources: PdfDict | undefined): Map<string, PageGradient>;
+/**
+ * §8.7.4.5.3 — where an axial shading's axis runs on the page, y up: its
+ * first stop at (x0, y0) and its last at (x1, y1).
+ */
+export interface GradientAxis {
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+}
+/**
+ * A gradient as the page states it: the model's, and where its axis runs. A
+ * shape shows the part of the axis its box covers, and the model's gradient
+ * spans the box — see {@link gradientOverBox}.
+ */
+export type PageGradient = ShapeGradient & {
+    readonly axis?: GradientAxis;
+};
+/**
+ * A page's gradient as a shape filled with it shows it: its stops re-mapped
+ * from the whole axis to the part of it the shape's box covers.
+ *
+ * A DrawingML gradient spans the shape it fills, and a PDF shading spans its
+ * own axis, which may reach far past the shape: issue10572.pdf's pattern
+ * runs twenty-four stripes down 1800 points, of which its 450-point square
+ * shows six — spread over the square, all twenty-four came back as hairlines.
+ * Beyond either end of the axis the end colour carries on, as `/Extend` asks.
+ *
+ * @param g   The gradient, with its axis where the page states one.
+ * @param box The shape's box, in the same space as the axis.
+ * @returns The gradient as the shape shows it, with no axis.
+ */
+export declare function gradientOverBox(g: PageGradient, box: {
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+}): ShapeGradient;
 /**
  * §8.7.4.5.2 — an axial or radial shading as a gradient, for a bare `sh`.
  *
@@ -29,7 +68,7 @@ export declare function buildShadingMap(file: PdfFile, resources: PdfDict | unde
  * @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;
+export declare function gradientShading(file: PdfFile, sh: PdfDict, ctm?: Matrix): PageGradient | undefined;
 /**
  * §8.7.4.5 — which kind of shading this is, as the file states it.
  *
@@ -128,7 +167,24 @@ export interface GsPaint {
      * `false` where the state names `/None`, which takes a mask off.
      */
     readonly masked?: boolean;
+    /** §8.4.5 `/LW` — the line width, in user space. */
+    readonly lineWidth?: number;
+    /** §8.4.5 `/D` — the dash pattern's lengths, in user space; empty is solid. */
+    readonly dash?: ReadonlyArray<number>;
+    /** §8.4.5 `/LC` — the line cap: 0 butt, 1 round, 2 projecting square. */
+    readonly lineCap?: number;
+    /** §11.6.4.4 `/CA` — the constant STROKE alpha, where the state names one. */
+    readonly strokeAlpha?: number;
 }
+/**
+ * §8.4.3.6 — a dash array as a stroke can use it: lengths that are numbers and
+ * not negative, and none at all where every one is zero, which draws nothing
+ * and is solid by the spec's own reading.
+ *
+ * @param value The array, as the file states it.
+ * @returns The lengths, or an empty array for a solid line.
+ */
+export declare function dashLengths(value: unknown): ReadonlyArray<number>;
 /**
  * §8.6 — how many components a colour space takes, and what they mean.
  *

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

@@ -1,4 +1,4 @@
-import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { PDF_NULL, PdfHexString, PdfName, PdfStream } from "../pdf/objects.js";
 import { cieToSrgb } from "./cie-color.js";
 import { iccTransform } from "./icc.js";
 import { readFunction } from "./function.js";
@@ -26,12 +26,102 @@ function buildShadingMap(file, resources) {
 		if (!(pat instanceof Map)) continue;
 		const shading = dictOf(file.resolve(pat.get("Shading") ?? PDF_NULL));
 		if (!shading) continue;
-		const gradient = parseShading(file, shading);
+		const m = numArray(file, pat.get("Matrix"));
+		const gradient = parseShading(file, shading, m && m.length >= 6 ? [
+			m[0],
+			m[1],
+			m[2],
+			m[3],
+			m[4],
+			m[5]
+		] : void 0);
 		if (gradient) out.set(nm, gradient);
 	}
 	return out;
 }
 /**
+* A page's gradient as a shape filled with it shows it: its stops re-mapped
+* from the whole axis to the part of it the shape's box covers.
+*
+* A DrawingML gradient spans the shape it fills, and a PDF shading spans its
+* own axis, which may reach far past the shape: issue10572.pdf's pattern
+* runs twenty-four stripes down 1800 points, of which its 450-point square
+* shows six — spread over the square, all twenty-four came back as hairlines.
+* Beyond either end of the axis the end colour carries on, as `/Extend` asks.
+*
+* @param g   The gradient, with its axis where the page states one.
+* @param box The shape's box, in the same space as the axis.
+* @returns The gradient as the shape shows it, with no axis.
+*/
+function gradientOverBox(g, box) {
+	const { axis, ...plain } = g;
+	if (!axis || g.kind !== "linear" || g.stops.length === 0) return plain;
+	const dx = axis.x1 - axis.x0;
+	const dy = axis.y1 - axis.y0;
+	const len2 = dx * dx + dy * dy;
+	if (!(len2 > 0)) return plain;
+	const along = (x, y) => ((x - axis.x0) * dx + (y - axis.y0) * dy) / len2;
+	const ts = [
+		along(box.minX, box.minY),
+		along(box.minX, box.maxY),
+		along(box.maxX, box.minY),
+		along(box.maxX, box.maxY)
+	];
+	const t0 = Math.min(...ts);
+	const t1 = Math.max(...ts);
+	if (!(t1 - t0 > 1e-9)) return plain;
+	if (Math.abs(t0) < SPAN_NOISE && Math.abs(t1 - 1) < SPAN_NOISE) return plain;
+	const inner = g.stops.filter((st) => st.offset > t0 && st.offset < t1);
+	const stops = [
+		{
+			offset: 0,
+			colorHex: colorAlong(g.stops, t0, "after")
+		},
+		...inner.map((st) => ({
+			offset: (st.offset - t0) / (t1 - t0),
+			colorHex: st.colorHex
+		})),
+		{
+			offset: 1,
+			colorHex: colorAlong(g.stops, t1, "before")
+		}
+	];
+	return {
+		...plain,
+		stops
+	};
+}
+/** How near the box's span may come to the whole axis and be taken for it. */
+var SPAN_NOISE = .001;
+/**
+* A gradient's colour at `t` along it, its end colours carried on past either
+* end. Where two stops share `t` the gradient changes colour AT it, and `side`
+* says which of the two is wanted: the one the span after `t` starts with, or
+* the one the span before it ends with. issue10572.pdf's square starts on such
+* an edge, and taken from the wrong side its first stripe faded in from blue.
+*/
+function colorAlong(stops, t, side) {
+	const first = stops[0];
+	const last = stops[stops.length - 1];
+	if (t <= first.offset) return first.colorHex;
+	if (t >= last.offset) return last.colorHex;
+	const at = stops.filter((st) => Math.abs(st.offset - t) < 1e-9);
+	if (at.length > 0) return (side === "after" ? at[at.length - 1] : at[0]).colorHex;
+	for (let i = 1; i < stops.length; i++) {
+		const b = stops[i];
+		if (t > b.offset) continue;
+		const a = stops[i - 1];
+		const span = b.offset - a.offset;
+		const f = span > 0 ? (t - a.offset) / span : 1;
+		const mix = (shift) => {
+			const ca = parseInt(a.colorHex, 16) >> shift & 255;
+			return ca + ((parseInt(b.colorHex, 16) >> shift & 255) - ca) * f;
+		};
+		return hex255(mix(16), mix(8), mix(0));
+	}
+	return last.colorHex;
+}
+/**
 * §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
@@ -42,8 +132,8 @@ function buildShadingMap(file, resources) {
 * @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);
+function gradientShading(file, sh, ctm) {
+	return parseShading(file, sh, ctm);
 }
 /**
 * §8.7.4.5 — which kind of shading this is, as the file states it.
@@ -55,7 +145,7 @@ function gradientShading(file, sh) {
 function shadingTypeOf(file, sh) {
 	return numOf(file.get(sh, "ShadingType"));
 }
-function parseShading(file, sh) {
+function parseShading(file, sh, matrix) {
 	const type = numOf(file.get(sh, "ShadingType"));
 	if (type !== 2 && type !== 3) return void 0;
 	const stops = parseFunction(file, sh.get("Function"), shadingSpace(file, sh));
@@ -65,11 +155,33 @@ function parseShading(file, sh) {
 		stops
 	};
 	const c = numArray(file, sh.get("Coords"));
-	return {
+	if (!c || c.length < 4) return {
 		kind: "linear",
-		angle: c && c.length >= 4 ? (Math.atan2(-(c[3] - c[1]), c[2] - c[0]) * 180 / Math.PI % 360 + 360) % 360 : 0,
+		angle: 0,
 		stops
 	};
+	const [a, b, cc, d, e, f] = matrix ?? [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+	const at = (x, y) => [a * x + cc * y + e, b * x + d * y + f];
+	const [x0, y0] = at(c[0], c[1]);
+	const [x1, y1] = at(c[2], c[3]);
+	return {
+		kind: "linear",
+		angle: (Math.atan2(-(y1 - y0), x1 - x0) * 180 / Math.PI % 360 + 360) % 360,
+		stops,
+		axis: {
+			x0,
+			y0,
+			x1,
+			y1
+		}
+	};
 }
 function parseFunction(file, value, space) {
 	const resolved = value !== void 0 ? file.resolve(value) : void 0;
@@ -246,6 +358,17 @@ function numArray(file, v) {
 function colorOf(c, space) {
 	return spaceColor(c, space) ?? spaceColor(c, void 0) ?? grayHex(c[0] ?? 0);
 }
+/** §8.6.6.3 — an Indexed space's table: a string, a hex string or a stream. */
+function lookupBytes(file, v) {
+	const r = file.resolve(v ?? PDF_NULL);
+	if (r instanceof PdfHexString) return r.bytes;
+	if (typeof r === "string") {
+		const out = new Uint8Array(r.length);
+		for (let i = 0; i < r.length; i++) out[i] = r.charCodeAt(i) & 255;
+		return out;
+	}
+	if (r instanceof PdfStream) return file.streamData(r);
+}
 /**
 * §8.6.8 — the colour a run of `sc` / `scn` components comes to.
 *
@@ -301,6 +424,10 @@ function grayHex(v) {
 function cmykHex(c, m, y, k) {
 	return rgbHex((1 - c) * (1 - k), (1 - m) * (1 - k), (1 - y) * (1 - k));
 }
+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 pushStop(stops, offset, colorHex) {
 	const o = Math.max(0, Math.min(1, offset));
 	const last = stops[stops.length - 1];
@@ -350,7 +477,15 @@ function buildAlphaMap(file, resources) {
 		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;
+		const lw = file.resolve(state.get("LW") ?? PDF_NULL);
+		const lineWidth = typeof lw === "number" && lw >= 0 ? lw : void 0;
+		const d = file.resolve(state.get("D") ?? PDF_NULL);
+		const dash = Array.isArray(d) ? dashLengths(file.resolve(d[0] ?? PDF_NULL)) : void 0;
+		const lc = file.resolve(state.get("LC") ?? PDF_NULL);
+		const lineCap = lc === 0 || lc === 1 || lc === 2 ? lc : void 0;
+		const caStroke = file.resolve(state.get("CA") ?? PDF_NULL);
+		const strokeAlpha = typeof caStroke === "number" && caStroke >= 0 && caStroke <= 1 ? caStroke : void 0;
+		if (alpha === void 0 && mode === void 0 && !statesMask && !(lineWidth !== void 0 || dash !== void 0 || lineCap !== void 0 || strokeAlpha !== void 0)) continue;
 		out.set(name, {
 			...alpha !== void 0 ? { alpha } : {},
 			...mode !== void 0 ? {
@@ -358,12 +493,30 @@ function buildAlphaMap(file, resources) {
 				darkens
 			} : {},
 			...blend !== void 0 ? { blend } : {},
-			...masked !== void 0 ? { masked } : {}
+			...masked !== void 0 ? { masked } : {},
+			...lineWidth !== void 0 ? { lineWidth } : {},
+			...dash !== void 0 ? { dash } : {},
+			...lineCap !== void 0 ? { lineCap } : {},
+			...strokeAlpha !== void 0 ? { strokeAlpha } : {}
 		});
 	}
 	return out;
 }
 /**
+* §8.4.3.6 — a dash array as a stroke can use it: lengths that are numbers and
+* not negative, and none at all where every one is zero, which draws nothing
+* and is solid by the spec's own reading.
+*
+* @param value The array, as the file states it.
+* @returns The lengths, or an empty array for a solid line.
+*/
+function dashLengths(value) {
+	if (!Array.isArray(value)) return [];
+	const lengths = value.filter((n) => typeof n === "number" && n >= 0);
+	if (lengths.length !== value.length || lengths.every((n) => n === 0)) return [];
+	return lengths;
+}
+/**
 * The spaces a `/ColorSpace` resource dictionary names, by name.
 *
 * @param file      The owning file.
@@ -405,7 +558,24 @@ function colorSpaceAt(file, cs, depth) {
 			icc
 		} : base;
 	}
-	if (head.value === "Indexed") return;
+	if (head.value === "Indexed" || head.value === "I") {
+		const base = depth < MAX_ALTERNATE ? colorSpaceAt(file, file.resolve(cs[1] ?? PDF_NULL), depth + 1) : void 0;
+		const hival = file.resolve(cs[2] ?? PDF_NULL);
+		const table = lookupBytes(file, cs[3]);
+		if (!base || base.kind === "tint" || typeof hival !== "number" || !table) return void 0;
+		const transform = ([index = 0]) => {
+			const at = Math.min(Math.max(0, Math.round(index)), Math.round(hival));
+			return Array.from({ length: base.components }, (_, k) => (table[at * base.components + k] ?? 0) / 255);
+		};
+		return {
+			kind: "tint",
+			components: 1,
+			tint: {
+				transform,
+				alternate: base
+			}
+		};
+	}
 	if (head.value === "CalRGB") {
 		const params = file.resolve(cs[1] ?? PDF_NULL);
 		const cie = params instanceof Map ? cieParams(file, params, true) : void 0;
@@ -516,4 +686,4 @@ function byFamily(family, n) {
 	}
 }
 //#endregion
-export { buildAlphaMap, buildColorSpaceMap, buildShadingMap, cmykHex, gradientShading, grayHex, rgbHex, sampledShading, shadingTypeOf, spaceColor };
+export { buildAlphaMap, buildColorSpaceMap, buildShadingMap, cmykHex, dashLengths, gradientOverBox, gradientShading, grayHex, rgbHex, sampledShading, shadingTypeOf, spaceColor };