reamkit 1.29.0 → 1.31.0

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 };

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

@@ -23,17 +23,17 @@ function readStructTree(file) {
 		return pg instanceof Map ? pageMap.get(pg) : void 0;
 	};
 	const seen = /* @__PURE__ */ new Set();
+	const typeOf = roleResolver(file, stRoot);
 	const read = (value, parentPage) => {
 		const elem = file.resolve(value);
 		if (!(elem instanceof Map) || seen.has(elem) || seen.size > MAX_NODES) return void 0;
 		seen.add(elem);
 		const ownPage = pageIndexOf(elem.get("Pg") ?? PDF_NULL) ?? parentPage;
-		const mcids = [];
-		const children = [];
+		const content = [];
 		for (const kid of kidList(file, elem.get("K"))) {
 			const rk = file.resolve(kid);
 			if (typeof rk === "number") {
-				if (ownPage >= 0) mcids.push({
+				if (ownPage >= 0) content.push({
 					page: ownPage,
 					mcid: rk
 				});
@@ -42,22 +42,24 @@ function readStructTree(file) {
 				if (kind === "MCR") {
 					const m = rk.get("MCID");
 					const page = pageIndexOf(rk.get("Pg") ?? PDF_NULL) ?? ownPage;
-					if (typeof m === "number" && page >= 0) mcids.push({
+					if (typeof m === "number" && page >= 0) content.push({
 						page,
 						mcid: m
 					});
 				} else if (kind === "OBJR") {} else {
 					const child = read(rk, ownPage);
-					if (child) children.push(child);
+					if (!child) continue;
+					if (inline(file, rk, child.type)) content.push(...allMcids(child));
+					else content.push(child);
 				}
 			}
 		}
+		const type = typeOf(nameOf(elem.get("S")));
 		const alt = elem.get("Alt");
 		const { colSpan, rowSpan } = readSpans(file, elem.get("A") ?? PDF_NULL);
 		return {
-			type: nameOf(elem.get("S")),
-			mcids,
-			children,
+			type,
+			...settle(type, content),
 			...typeof alt === "string" ? { alt } : {},
 			...colSpan > 1 ? { colSpan } : {},
 			...rowSpan > 1 ? { rowSpan } : {}
@@ -71,6 +73,108 @@ function readStructTree(file) {
 		children: roots
 	};
 }
+/**
+* An element's own marked content and its child elements, as the node keeps
+* them.
+*
+* An element holds text of its own AND block elements only where the tree
+* mixes them — a heading carrying its number as a child, a paragraph with a
+* formula set between two of its sentences. Kept as two lists, the order
+* between them was gone and the element's own text was never read at all:
+* bug1937438_mml_from_latex.pdf's heading came back as "1" without "A small
+* example", and its sentence around a formula without its words. Each
+* stretch of the element's own content becomes a paragraph of its own
+* standing where it stood — except in a figure, whose marked content is its
+* picture.
+*/
+function settle(type, content) {
+	const nodes = content.filter((c) => "type" in c);
+	const own = content.filter((c) => !("type" in c));
+	if (nodes.length === 0 || own.length === 0 || type === "Figure") return {
+		mcids: own,
+		children: nodes
+	};
+	const children = [];
+	let stretch = [];
+	const close = () => {
+		if (stretch.length > 0) children.push({
+			type: "P",
+			mcids: stretch,
+			children: []
+		});
+		stretch = [];
+	};
+	for (const c of content) if ("type" in c) {
+		close();
+		children.push(c);
+	} else stretch.push(c);
+	close();
+	return {
+		mcids: [],
+		children
+	};
+}
+/** Every marked content reference under a node, in reading order. */
+function allMcids(node) {
+	return [...node.mcids, ...node.children.flatMap(allMcids)];
+}
+/**
+* §14.8.4.4 — the inline-level structure types (PDF 2.0 adds `Em`, `Strong`,
+* `Sub`), a formula (§14.8.4.5.5, which is set in a line as often as out of
+* one), and a list label, which is the start of its item's line.
+*/
+var INLINE = new Set([
+	"Span",
+	"Quote",
+	"Reference",
+	"BibEntry",
+	"Code",
+	"Link",
+	"Annot",
+	"Ruby",
+	"RB",
+	"RT",
+	"RP",
+	"Warichu",
+	"WT",
+	"WP",
+	"Em",
+	"Strong",
+	"Sub",
+	"Formula",
+	"Lbl"
+]);
+/** The MathML namespace (ISO 32000-2 §14.8.6): an element in it is mathematics. */
+var MATHML = "http://www.w3.org/1998/Math/MathML";
+/** Whether an element is inline — by its standard type, or as MathML. */
+function inline(file, elem, type) {
+	if (INLINE.has(type)) return true;
+	const ns = file.resolve(elem.get("NS") ?? PDF_NULL);
+	const uri = ns instanceof Map ? file.resolve(ns.get("NS") ?? PDF_NULL) : void 0;
+	return typeof uri === "string" && uri === MATHML;
+}
+/**
+* §14.8.4.2 `/RoleMap` — a document's own structure types, mapped to the
+* standard ones they stand for, followed until a type maps no further. A
+* LaTeX document names its elements `section`, `text-unit` and
+* `section-number`, and maps them to `H1`, `Part` and `Span`: read by their
+* own names, none of them meant anything.
+*/
+function roleResolver(file, stRoot) {
+	const map = file.resolve(stRoot.get("RoleMap") ?? PDF_NULL);
+	if (!(map instanceof Map)) return (type) => type;
+	return (type) => {
+		let at = type;
+		for (let hop = 0; hop < MAX_ROLE_HOPS; hop++) {
+			const next = file.resolve(map.get(at) ?? PDF_NULL);
+			if (!(next instanceof PdfName) || next.value === at) break;
+			at = next.value;
+		}
+		return at;
+	};
+}
+/** How far a chain of role mappings is followed before it is taken for a cycle. */
+var MAX_ROLE_HOPS = 8;
 function kidList(file, kVal) {
 	if (kVal === void 0) return [];
 	const k = file.resolve(kVal);