reamkit 1.26.0 → 1.28.0

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

@@ -1,5 +1,6 @@
 import { PDF_NULL, PdfHexString, PdfName } from "../pdf/objects.js";
 import { Lexer } from "./lexer.js";
+import { cmykHex, grayHex, rgbHex, spaceColor } from "./shading.js";
 //#region src/pdf-reader/content.ts
 /**
 * A painted path emitted by the path-painting operators (§8.5.3), captured in
@@ -91,6 +92,9 @@ function initialState() {
 		fillGradient: void 0,
 		fillPattern: void 0,
 		fillAlpha: 1,
+		fillDarkens: false,
+		blendMode: void 0,
+		softMask: false,
 		clip: void 0
 	};
 }
@@ -132,30 +136,42 @@ function spaceOf(operands, spaces) {
 	}
 }
 /**
-* §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.
+* §8.7.4.5 — one colour for a whole sweep: the stop at its middle, or the mean
+* of the two it falls between. A gradient is a shape a run cannot carry, and
+* the end it starts at is no more the colour of the words than the end it
+* finishes at.
 */
-function componentColor(operands, space) {
-	const nums = operands.filter((o) => typeof o === "number");
-	if (nums.length === 0) return void 0;
-	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": return grayHex(1 - Math.max(...nums));
-		default: return;
-	}
+function midGradient(gradient) {
+	const stops = [...gradient.stops].sort((a, b) => a.offset - b.offset);
+	if (stops.length === 0) return "000000";
+	const exact = stops.find((s) => Math.abs(s.offset - .5) < 1e-6);
+	if (exact) return exact.colorHex;
+	const before = [...stops].reverse().find((s) => s.offset <= .5) ?? stops[0];
+	const after = stops.find((s) => s.offset >= .5) ?? stops[stops.length - 1];
+	const span = after.offset - before.offset;
+	const t = span > 0 ? (.5 - before.offset) / span : 0;
+	const mix = (at) => {
+		const a = parseInt(before.colorHex.slice(at, at + 2), 16);
+		const b = parseInt(after.colorHex.slice(at, at + 2), 16);
+		return Number.isFinite(a) && Number.isFinite(b) ? Math.round(a + (b - a) * t) : 0;
+	};
+	return [
+		mix(0),
+		mix(2),
+		mix(4)
+	].map((c) => Math.max(0, Math.min(255, c)).toString(16).padStart(2, "0")).join("").toUpperCase();
 }
-function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__PURE__ */ new Map(), alphas = /* @__PURE__ */ new Map(), spaces = /* @__PURE__ */ new Map()) {
+/** §8.6.8 — the colour a run of `sc` / `scn` operands comes to (see `spaceColor`). */
+function colorOfOperands(operands, space) {
+	return spaceColor(operands.filter((o) => typeof o === "number"), space);
+}
+function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__PURE__ */ new Map(), alphas = /* @__PURE__ */ new Map(), spaces = /* @__PURE__ */ new Map(), hiddenOc = /* @__PURE__ */ new Set()) {
 	const runs = [];
 	const images = [];
 	const vectors = [];
 	const glyphs = [];
+	const painted = [];
+	const outlines = [];
 	const lexer = new Lexer(bytes);
 	const stack = [];
 	let state = initialState();
@@ -167,6 +183,9 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 	let paintOrder = 0;
 	let operands = [];
 	const mcStack = [];
+	const ocStack = [];
+	let hiddenDepth = 0;
+	const visible = () => hiddenDepth === 0;
 	const toPage = (x, y) => [x * state.ctm[0] + y * state.ctm[2] + state.ctm[4], x * state.ctm[1] + y * state.ctm[3] + state.ctm[5]];
 	const moveTo = (x, y) => {
 		const [px, py] = toPage(x, y);
@@ -211,7 +230,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		return state.lineWidth * scale;
 	};
 	const paintPath = (fill, stroke) => {
-		if (path.length >= 2 && (fill || stroke)) {
+		if (path.length >= 2 && (fill || stroke) && visible()) {
 			const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
 			vectors.push({
 				order: paintOrder++,
@@ -220,6 +239,9 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				...fill && state.fillPattern !== void 0 ? { patternName: state.fillPattern } : {},
 				...fill ? { fillHex: state.fillColor } : {},
 				...fill && state.fillAlpha < 1 ? { alpha: state.fillAlpha } : {},
+				...fill && state.fillDarkens ? { darkens: true } : {},
+				...state.blendMode !== void 0 ? { blend: state.blendMode } : {},
+				...state.softMask ? { masked: true } : {},
 				...fill && state.fillGradient ? { gradient: state.fillGradient } : {},
 				...stroke ? {
 					strokeHex: state.strokeColor,
@@ -249,7 +271,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		const type3 = state.font.type3;
 		if (type3) {
 			const stream = type3.proc(code);
-			if (stream) {
+			if (stream && visible()) {
 				const scale = [
 					state.fontSize * state.hScale,
 					0,
@@ -266,12 +288,41 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				});
 			}
 		}
-		const w0 = state.font.width(code) / 1e3;
+		const outline = state.font.outline;
+		if (outline && visible() && state.renderMode !== 3 && state.renderMode !== 7) {
+			const segs = outline.path(code);
+			if (segs) {
+				const scale = [
+					state.fontSize * state.hScale,
+					0,
+					0,
+					state.fontSize,
+					0,
+					state.rise
+				];
+				const place = multiply(outline.matrix, multiply(scale, multiply(tm, state.ctm)));
+				outlines.push({
+					order: paintOrder++,
+					segs: segs.map((seg) => mapSeg(seg, place)),
+					...state.clip ? { clip: state.clip } : {},
+					fillHex: state.fillColor,
+					...state.fillAlpha < 1 ? { alpha: state.fillAlpha } : {},
+					glyph: true
+				});
+			}
+		}
 		const isSpace = state.font.bytesPerCode === 1 && code === 32;
-		tm = multiply(translation((w0 * state.fontSize + state.charSpacing + (isSpace ? state.wordSpacing : 0)) * state.hScale, 0), tm);
+		const spacing = state.charSpacing + (isSpace ? state.wordSpacing : 0);
+		const down = state.font.verticalAdvance;
+		if (down) {
+			tm = multiply(translation(0, down(code) / 1e3 * state.fontSize - spacing), tm);
+			return;
+		}
+		tm = multiply(translation((state.font.width(code) / 1e3 * state.fontSize + spacing) * state.hScale, 0), tm);
 	};
 	const consume = (operand) => {
-		const codes = splitCodes(toBytes(operand), state.font.bytesPerCode);
+		const bytes = toBytes(operand);
+		const codes = state.font.splitCodes ? state.font.splitCodes(bytes) : splitCodes(bytes, state.font.bytesPerCode);
 		for (const code of codes) advanceGlyph(code);
 		return state.font.decode(codes);
 	};
@@ -279,8 +330,10 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		const text = logicalOrder(shown);
 		if (text.length === 0) return;
 		const scaleY = Math.hypot(origin[2], origin[3]) || 1;
+		const scaleX = (Math.hypot(origin[0], origin[1]) || 1) * state.hScale;
 		const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
 		const angle = Math.atan2(origin[1], origin[0]) * 180 / Math.PI;
+		if (!visible()) return;
 		runs.push({
 			text,
 			x: origin[4],
@@ -288,19 +341,21 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			endX: end[4],
 			endY: end[5],
 			...Math.abs(angle) > UPRIGHT_TOLERANCE_DEG ? { angleDeg: angle } : {},
-			fontSizePt: state.fontSize * scaleY,
+			fontSizePt: Math.abs(state.fontSize) * scaleY,
+			spaceWidthPt: (state.font.width(32) / 1e3 * state.fontSize + state.charSpacing + state.wordSpacing) * scaleX,
 			fontKey: state.fontKey,
 			...state.font.name !== void 0 ? { fontName: state.font.name } : {},
 			...state.font.type3 ? { type3: true } : {},
 			...state.renderMode === 3 || state.renderMode === 7 ? { invisible: true } : {},
 			...state.fillPattern !== void 0 ? { fillPatternName: state.fillPattern } : {},
+			...state.fillGradient ? { gradientFill: true } : {},
 			...strokesText(state.renderMode) ? {
 				outlineHex: state.strokeColor,
 				outlineWidthPt: ctmLineWidth()
 			} : {},
 			...state.font.bold ? { bold: true } : {},
 			...state.font.italic ? { italic: true } : {},
-			colorHex: state.fillColor,
+			colorHex: state.fillGradient ? midGradient(state.fillGradient) : state.fillColor,
 			...mcid !== void 0 ? { mcid } : {}
 		});
 	};
@@ -392,23 +447,33 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				const props = operands[operands.length - 1];
 				const mcidVal = !(tag instanceof PdfName && tag.value === "Artifact") && props instanceof Map ? props.get("MCID") : void 0;
 				mcStack.push(typeof mcidVal === "number" ? mcidVal : void 0);
+				const isOc = tag instanceof PdfName && tag.value === "OC" && props instanceof PdfName && hiddenOc.has(props.value);
+				ocStack.push(isOc);
+				if (isOc) hiddenDepth++;
 				break;
 			}
 			case "BMC":
 				mcStack.push(void 0);
+				ocStack.push(false);
 				break;
 			case "EMC":
 				mcStack.pop();
+				if (ocStack.pop() === true) hiddenDepth--;
 				break;
 			case "Do": {
 				const nm = operands[0];
-				if (nm instanceof PdfName) {
+				if (nm instanceof PdfName && visible()) {
 					const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
 					images.push({
 						order: paintOrder++,
 						name: nm.value,
 						ctm: state.ctm,
-						...mcid !== void 0 ? { mcid } : {}
+						...state.clip ? { clip: state.clip } : {},
+						fillHex: state.fillColor,
+						...mcid !== void 0 ? { mcid } : {},
+						...state.fillAlpha < 1 ? { alpha: state.fillAlpha } : {},
+						...state.blendMode !== void 0 ? { blend: state.blendMode } : {},
+						...state.softMask ? { masked: true } : {}
 					});
 				}
 				break;
@@ -443,7 +508,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 					state.fillPattern = state.fillGradient ? void 0 : named;
 					break;
 				}
-				const hex = componentColor(operands, state.fillSpace);
+				const hex = colorOfOperands(operands, state.fillSpace);
 				if (hex !== void 0) {
 					state.fillColor = hex;
 					state.fillGradient = void 0;
@@ -454,7 +519,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			case "SCN":
 			case "SC": {
 				if (operands[operands.length - 1] instanceof PdfName) break;
-				const hex = componentColor(operands, state.strokeSpace);
+				const hex = colorOfOperands(operands, state.strokeSpace);
 				if (hex !== void 0) state.strokeColor = hex;
 				break;
 			}
@@ -506,12 +571,33 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				path.push({ op: "close" });
 				paintPath(true, true);
 				break;
+			case "sh": {
+				const nm = operands[0];
+				if (nm instanceof PdfName && visible()) painted.push({
+					name: nm.value,
+					ctm: state.ctm,
+					...state.clip ? { clip: state.clip } : {},
+					...state.softMask ? { masked: true } : {},
+					...state.fillAlpha < 1 ? { alpha: state.fillAlpha } : {},
+					...state.fillDarkens ? { darkens: true } : {},
+					order: paintOrder++
+				});
+				break;
+			}
 			case "n":
 				paintPath(false, false);
 				break;
 			case "gs": {
 				const nm = operands[operands.length - 1];
-				if (nm instanceof PdfName) state.fillAlpha = alphas.get(nm.value) ?? 1;
+				const paint = nm instanceof PdfName ? alphas.get(nm.value) : void 0;
+				if (paint) {
+					if (paint.alpha !== void 0) state.fillAlpha = paint.alpha;
+					if (paint.statesBlend === true) {
+						state.fillDarkens = paint.darkens ?? false;
+						state.blendMode = paint.blend;
+					}
+					if (paint.masked !== void 0) state.softMask = paint.masked;
+				}
 				break;
 			}
 			case "W":
@@ -545,8 +631,19 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				operands.push(readDict(lexer));
 				break;
 			case "keyword":
-				if (tok.value === "BI") skipInlineImage(lexer);
-				else exec(tok.value);
+				if (tok.value === "BI") {
+					const inline = readInlineImage(lexer);
+					if (inline && visible()) images.push({
+						order: paintOrder++,
+						name: "",
+						inline,
+						ctm: state.ctm,
+						...state.clip ? { clip: state.clip } : {},
+						fillHex: state.fillColor,
+						...mcStack.length > 0 ? { mcid: mcStack[mcStack.length - 1] } : {},
+						...state.blendMode !== void 0 ? { blend: state.blendMode } : {}
+					});
+				} else exec(tok.value);
 				operands = [];
 				break;
 			default:
@@ -558,7 +655,34 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		texts: runs,
 		images,
 		vectors,
-		glyphs
+		glyphs,
+		shadings: painted,
+		outlines
+	};
+}
+/** One path segment through a matrix — the glyph's own space onto the page. */
+function mapSeg(seg, m) {
+	const at = (x, y) => [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
+	if (seg.op === "close") return seg;
+	if (seg.op === "cubic") {
+		const [x1, y1] = at(seg.x1, seg.y1);
+		const [x2, y2] = at(seg.x2, seg.y2);
+		const [x, y] = at(seg.x, seg.y);
+		return {
+			op: "cubic",
+			x1,
+			y1,
+			x2,
+			y2,
+			x,
+			y
+		};
+	}
+	const [x, y] = at(seg.x, seg.y);
+	return {
+		op: seg.op,
+		x,
+		y
 	};
 }
 /** §9.3.6 — the rendering modes that put a line round the glyphs. */
@@ -610,21 +734,6 @@ function isRightToLeft(text) {
 function isRtl(cp) {
 	return cp >= 1424 && cp <= 1535 || cp >= 1536 && cp <= 1791 || cp >= 1792 && cp <= 1871 || cp >= 1920 && cp <= 1983 || cp >= 2208 && cp <= 2303 || cp >= 64285 && cp <= 65023 || cp >= 65136 && cp <= 65279;
 }
-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");
-}
-function rgbHex(r, g, b) {
-	return (hex2(r) + hex2(g) + hex2(b)).toUpperCase();
-}
-function grayHex(v) {
-	return rgbHex(v, v, v);
-}
-function cmykHex(c, m, y, k) {
-	return rgbHex((1 - c) * (1 - k), (1 - m) * (1 - k), (1 - y) * (1 - k));
-}
 function matrixFromOperands(operands) {
 	const n = (i) => typeof operands[i] === "number" ? operands[i] : 0;
 	return [
@@ -658,9 +767,30 @@ function readArray(lexer) {
 	for (;;) {
 		const tok = lexer.nextToken();
 		if (tok.kind === "arrayClose" || tok.kind === "eof") break;
-		if (tok.kind === "num") out.push(tok.value);
-		else if (tok.kind === "str") out.push(tok.value);
-		else if (tok.kind === "hexstr") out.push(new PdfHexString(tok.bytes));
+		switch (tok.kind) {
+			case "num":
+				out.push(tok.value);
+				break;
+			case "str":
+				out.push(tok.value);
+				break;
+			case "hexstr":
+				out.push(new PdfHexString(tok.bytes));
+				break;
+			case "name":
+				out.push(new PdfName(tok.value));
+				break;
+			case "arrayOpen":
+				out.push(readArray(lexer));
+				break;
+			case "dictOpen":
+				out.push(readDict(lexer));
+				break;
+			case "keyword":
+				if (tok.value === "true" || tok.value === "false") out.push(tok.value === "true");
+				break;
+			default: break;
+		}
 	}
 	return out;
 }
@@ -687,14 +817,62 @@ function readValue(lexer) {
 		default: return PDF_NULL;
 	}
 }
-function skipInlineImage(lexer) {
+/**
+* §8.9.7 — an inline image: its dictionary between `BI` and `ID`, then its
+* bytes up to `EI`.
+*
+* The bytes are binary and may hold `EI` themselves, so the end is found by
+* MEASURING where the dictionary says how much there is — an unfiltered image
+* is exactly `ceil(W · BPC · components / 8) · H` bytes — and only searched for
+* where a filter makes the length unknowable. images_1bit_grayscale.pdf draws
+* two of them and both were skipped over.
+*/
+function readInlineImage(lexer) {
+	const dict = /* @__PURE__ */ new Map();
 	for (;;) {
 		const tok = lexer.nextToken();
-		if (tok.kind === "eof") return;
+		if (tok.kind === "eof") return void 0;
 		if (tok.kind === "keyword" && tok.value === "ID") break;
+		if (tok.kind === "name") dict.set(tok.value, readValue(lexer));
+	}
+	const start = lexer.pos + 1;
+	const measured = inlineLength(dict);
+	let end = measured !== void 0 ? start + measured : -1;
+	if (end < 0 || end > lexer.length) {
+		end = lexer.indexOfAscii("EI", start);
+		if (end < 0) {
+			lexer.pos = lexer.length;
+			return;
+		}
 	}
-	const ei = lexer.indexOfAscii("EI", lexer.pos);
+	const data = lexer.slice(start, Math.min(end, lexer.length));
+	const ei = lexer.indexOfAscii("EI", end);
 	lexer.pos = ei < 0 ? lexer.length : ei + 2;
+	return {
+		dict,
+		data
+	};
+}
+/** How many bytes an UNFILTERED inline image's samples take, if that is known. */
+function inlineLength(dict) {
+	if (dict.has("F") || dict.has("Filter")) return void 0;
+	const num = (...keys) => {
+		for (const k of keys) {
+			const v = dict.get(k);
+			if (typeof v === "number") return v;
+		}
+		return 0;
+	};
+	const w = num("W", "Width");
+	const h = num("H", "Height");
+	if (w <= 0 || h <= 0) return void 0;
+	const mask = dict.get("IM") === true || dict.get("ImageMask") === true;
+	const bpc = mask ? 1 : num("BPC", "BitsPerComponent") || 8;
+	const cs = dict.get("CS") ?? dict.get("ColorSpace");
+	const name = cs instanceof PdfName ? cs.value : "";
+	const comps = mask ? 1 : /^(RGB|DeviceRGB|CalRGB)$/u.test(name) ? 3 : /^(CMYK|DeviceCMYK)$/u.test(name) ? 4 : /^(G|DeviceGray|CalGray|I|Indexed)$/u.test(name) || name === "" ? 1 : 0;
+	if (comps === 0) return void 0;
+	return ((w * comps * bpc + 7) / 8 | 0) * h;
 }
 //#endregion
 export { IDENTITY, interpretContent, isRightToLeft, multiply };

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

@@ -0,0 +1,11 @@
+/** The character a ZapfDingbats code stands for, or `undefined` for an unused one. */
+export declare function zapfDingbatsChar(code: number): string | undefined;
+/**
+ * The character a dingbat's glyph NAME stands for — `a38` is ✫ — for a font
+ * that names its glyphs through `/Differences` (§9.6.6.1).
+ *
+ * @param name The glyph name.
+ */
+export declare function dingbatChar(name: string): string | undefined;
+/** Whether a base font names the ZapfDingbats face (§9.6.2.2 Table 109). */
+export declare function isZapfDingbats(baseFont: string): boolean;