reamkit 1.27.0 → 1.29.0

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

@@ -32,7 +32,8 @@ function parseToUnicodeCMap(bytes) {
 			if (src.kind !== "hexstr") continue;
 			const dst = lexer.nextToken();
 			if (dst.kind !== "hexstr") continue;
-			map.set(bytesToInt(src.bytes), utf16be(dst.bytes));
+			const text = stated(utf16be(dst.bytes));
+			if (text !== void 0) map.set(bytesToInt(src.bytes), text);
 		}
 		else if (tok.value === "beginbfrange") for (;;) {
 			const lo = lexer.nextToken();
@@ -44,14 +45,17 @@ function parseToUnicodeCMap(bytes) {
 			const hiN = bytesToInt(hi.bytes);
 			const dst = lexer.nextToken();
 			if (dst.kind === "hexstr") {
-				const base = utf16be(dst.bytes);
-				for (let i = 0; loN + i <= hiN && i < MAX_RANGE; i++) map.set(loN + i, incString(base, i));
+				const base = stated(utf16be(dst.bytes));
+				if (base !== void 0) for (let i = 0; loN + i <= hiN && i < MAX_RANGE; i++) map.set(loN + i, incString(base, i));
 			} else if (dst.kind === "arrayOpen") {
 				let i = 0;
 				for (;;) {
 					const el = lexer.nextToken();
 					if (el.kind === "arrayClose" || el.kind === "eof") break;
-					if (el.kind === "hexstr") map.set(loN + i++, utf16be(el.bytes));
+					if (el.kind !== "hexstr") continue;
+					const text = stated(utf16be(el.bytes));
+					if (text !== void 0) map.set(loN + i, text);
+					i++;
 				}
 			}
 		}
@@ -61,6 +65,9 @@ function parseToUnicodeCMap(bytes) {
 		codeBytes
 	};
 }
+function stated(text) {
+	for (const ch of text) if (ch !== "\0") return text;
+}
 function bytesToInt(bytes) {
 	let n = 0;
 	for (const b of bytes) n = n * 256 + b;
@@ -74,8 +81,11 @@ function utf16be(bytes) {
 }
 function incString(base, i) {
 	if (i === 0) return base;
-	if (base.length === 1) return String.fromCharCode(base.charCodeAt(0) + i);
-	return base;
+	const chars = [...base];
+	if (chars.length === 0) return base;
+	const last = chars[chars.length - 1].codePointAt(0) + i;
+	if (last > 1114111 || last >= 55296 && last <= 57343) return base;
+	return chars.slice(0, -1).join("") + String.fromCodePoint(last);
 }
 //#endregion
 export { parseToUnicodeCMap };

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

@@ -11,10 +11,25 @@ import { PdfDict, PdfStream } from '../pdf/objects.js';
 export interface ContentFont {
     /** Bytes per character code: simple fonts read 1 byte/code, Type0 reads 2. */
     readonly bytesPerCode: 1 | 2;
+    /**
+     * §9.7.6.2 — how a shown string breaks into codes, where the CMap is not
+     * fixed-width. A named CMap like `90ms-RKSJ-H` mixes one-byte and two-byte
+     * codes, and split down the middle a Japanese line came apart into nonsense.
+     * Absent means the fixed width above.
+     */
+    readonly splitCodes?: (bytes: Uint8Array) => Array<number>;
     /** Decode a sequence of character codes to a Unicode string. */
     decode: (codes: ReadonlyArray<number>) => string;
     /** Glyph advance for one code, in 1000-unit text space. */
     width: (code: number) => number;
+    /**
+     * §9.4.4 / §9.7.4.3 — the face sets its text DOWN the page, not across, and
+     * the pen advances by the vertical displacement `w1` rather than by `w0`.
+     * A `…-V` CMap asks for this; `/DW2`'s default `[880 -1000]` is one em down.
+     * The number here is that displacement in 1000-unit text space, and it is
+     * negative because the page's y runs up.
+     */
+    readonly verticalAdvance?: (code: number) => number;
     /** §9.6.2 — the face's own `/BaseFont` name, for a document that embeds it. */
     readonly name?: string;
     /** §9.8.1 — the face is a bold one (weight, the ForceBold flag, or its name). */
@@ -27,6 +42,19 @@ export interface ContentFont {
      * procedure paints, in the resources the font states.
      */
     readonly type3?: Type3Face;
+    /**
+     * §9.6.6 — the OUTLINE a code draws, for a code that stands for no
+     * character. A face that can say what its characters are never has one:
+     * this is the last resort before a blank page.
+     */
+    readonly outline?: GlyphOutline;
+}
+/** §9.6.6 — the outlines of a face read by glyph index, and their glyph space. */
+export interface GlyphOutline {
+    /** Glyph space to text space, as a Type 3 font's `/FontMatrix` is. */
+    readonly matrix: Matrix;
+    /** The contours one code draws, or `undefined` where it draws none. */
+    readonly path: (code: number) => Array<PathSeg> | undefined;
 }
 /** §9.6.5 — the parts of a Type 3 font a caller needs to run its glyphs. */
 export interface Type3Face {
@@ -94,6 +122,12 @@ export interface TextRun {
      * fill colour still standing from before is not what the page shows.
      */
     readonly fillPatternName?: string;
+    /**
+     * §8.7.4.5 — the glyphs are filled with a SHADING pattern: a sweep from one
+     * colour to another, of which the run carries the middle. The colour is not
+     * lost, the shape of it is.
+     */
+    readonly gradientFill?: boolean;
     /**
      * §9.3.6 — the page painted these glyphs NOWHERE: mode 3 shows nothing and
      * mode 7 only adds to the clip. A scanned page carries its recognised words
@@ -157,6 +191,8 @@ export interface ImagePlacement {
      */
     readonly fillHex: string;
     readonly mcid?: number;
+    /** §11.6.4.4 `/ca` — how opaque the picture is drawn, when the page asked for less. */
+    readonly alpha?: number;
     /** §11.3.5 `/BM` — a blend the page asked for that nothing here performs. */
     readonly blend?: string;
     /** §11.6.5 `/SMask` — the paint faded from place to place; nothing here does. */
@@ -222,6 +258,13 @@ export interface VectorPlacement {
     readonly blend?: string;
     /** §11.6.5 `/SMask` — the paint faded from place to place; nothing here does. */
     readonly masked?: boolean;
+    /**
+     * §9.6.6 — this path is a GLYPH, traced from the face because its code stands
+     * for no character. It is type, not artwork, so the de-cluttering a page's
+     * paths go through does not apply: a full stop is a mark one point across and
+     * every filter there would throw it out.
+     */
+    readonly glyph?: boolean;
     /**
      * §8.7.3 — the TILING pattern resource name the path is filled with. Its
      * content is a stream of its own, so what the fill actually shows is only
@@ -241,18 +284,66 @@ export interface InterpretResult {
     readonly vectors: Array<VectorPlacement>;
     /** §9.6.5 — every Type 3 glyph the stream showed, with where to run it. */
     readonly glyphs: Array<Type3Call>;
+    /**
+     * §8.7.4.3 — every region the stream painted with a bare `sh`, which fills
+     * the CLIP rather than a path. What a caller can do with one depends on the
+     * shading's own type, so the placement is carried rather than counted.
+     */
+    readonly shadings: Array<ShadingPaint>;
+    /**
+     * §9.6.6 — every glyph the stream showed that stands for NO character, as
+     * the path it draws in page space. There is nothing to write for one, and
+     * there is something to draw.
+     */
+    readonly outlines: Array<VectorPlacement>;
 }
 /**
  * §9.6.5 — one showing of a Type 3 glyph: which procedure, and the matrix that
  * puts glyph space on the page.
  */
+/** §8.7.4.3 — one `sh`: which shading, where the CTM put it, what bounded it. */
+export interface ShadingPaint {
+    /** The `/Shading` resource name (no leading slash). */
+    readonly name: string;
+    /** The CTM in force, which maps the shading's own space onto the page. */
+    readonly ctm: Matrix;
+    /** §8.5.4 — the clip the paint was bounded by, which is its whole extent. */
+    readonly clip?: ClipRegion;
+    /**
+     * §11.6.5 `/SMask` — the paint was faded from place to place. For a `sh` that
+     * is not a detail: the mask is the SHAPE, and the clip is only its outer
+     * bound.
+     */
+    readonly masked?: boolean;
+    /** §11.6.4.4 `/ca` — how opaque the paint is, when the page asked for less. */
+    readonly alpha?: number;
+    /** §11.3.5 `/BM` — the paint only DARKENS what it covers. */
+    readonly darkens?: boolean;
+    /** Where it fell in the painting order (§8.5.3). */
+    readonly order: number;
+}
 export interface Type3Call {
     readonly stream: PdfStream;
     readonly resources: PdfDict | undefined;
     readonly ctm: Matrix;
     /** §8.5.3 — its place in the stream's painting order, as a form call has. */
     readonly order: number;
+    /**
+     * §9.6.5/§9.10 — the font SAYS what character this glyph stands for. A
+     * flowing reading re-sets that character in a face of its own, so drawing the
+     * procedure as well puts two copies of the letter on the page.
+     */
+    readonly readable: boolean;
 }
+/**
+ * §9.10 — whether the font says what character a glyph stands for: text that is
+ * neither empty nor the replacement character a reader writes where nothing is
+ * stated.
+ *
+ * @param text What the font's decode gave for the code.
+ * @returns Whether a flowing reading can write it as a letter.
+ */
+export declare function statesACharacter(text: string): boolean;
 /**
  * 2D affine matrix `[a b c d e f]`, row-vector convention (`[x y 1] · M`):
  * ```

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

@@ -1,6 +1,6 @@
 import { PDF_NULL, PdfHexString, PdfName } from "../pdf/objects.js";
 import { Lexer } from "./lexer.js";
-import { cieToSrgb } from "./cie-color.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
@@ -35,6 +35,18 @@ function pathBox(segs) {
 }
 /** The area of a box, for choosing the smaller of two clip regions. */
 var area = (b) => Math.max(0, b.maxX - b.minX) * Math.max(0, b.maxY - b.minY);
+/**
+* §9.10 — whether the font says what character a glyph stands for: text that is
+* neither empty nor the replacement character a reader writes where nothing is
+* stated.
+*
+* @param text What the font's decode gave for the code.
+* @returns Whether a flowing reading can write it as a letter.
+*/
+function statesACharacter(text) {
+	const trimmed = text.trim();
+	return trimmed.length > 0 && !trimmed.includes("�");
+}
 /** The identity {@link Matrix} (no transform). */
 var IDENTITY = [
 	1,
@@ -136,39 +148,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;
-	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 = componentColor(space.tint.transform(nums), space.tint.alternate);
-				if (hex !== void 0) return hex;
-			}
-			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();
+}
+/** §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();
@@ -281,16 +296,46 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 					stream,
 					resources: type3.resources,
 					ctm: multiply(type3.matrix, multiply(scale, multiply(tm, state.ctm))),
-					order: paintOrder++
+					order: paintOrder++,
+					readable: statesACharacter(state.font.decode([code]))
+				});
+			}
+		}
+		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 w0 = state.font.width(code) / 1e3;
 		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);
 	};
@@ -316,13 +361,14 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			...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 } : {}
 		});
 	};
@@ -438,7 +484,9 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 						...state.clip ? { clip: state.clip } : {},
 						fillHex: state.fillColor,
 						...mcid !== void 0 ? { mcid } : {},
-						...state.blendMode !== void 0 ? { blend: state.blendMode } : {}
+						...state.fillAlpha < 1 ? { alpha: state.fillAlpha } : {},
+						...state.blendMode !== void 0 ? { blend: state.blendMode } : {},
+						...state.softMask ? { masked: true } : {}
 					});
 				}
 				break;
@@ -473,7 +521,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;
@@ -484,7 +532,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;
 			}
@@ -536,17 +584,32 @@ 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) {
-					const paint = alphas.get(nm.value);
-					state.fillAlpha = paint?.alpha ?? 1;
-					state.fillDarkens = paint?.darkens ?? false;
-					state.blendMode = paint?.blend;
-					state.softMask = paint?.masked ?? false;
+				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;
 			}
@@ -605,7 +668,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. */
@@ -657,21 +747,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 [
@@ -705,9 +780,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;
 }

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;