reamkit 1.24.0 → 1.25.0

package/dist/esm/pdf/styled-page-emitter.js

@@ -653,6 +653,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 	let lastSize = -1;
 	let lastColor = "";
 	let lastFauxWidth = 0;
+	let lastStroke;
 	let lastTz = 100;
 	const switchFontIfNeeded = (tok) => {
 		const fontKey = tok.font.resourceName;
@@ -661,11 +662,20 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			lastFont = fontKey;
 			lastSize = tok.fontSizePt;
 		}
-		const fauxWidth = tok.synthetic?.bold === true ? tok.fontSizePt * .03 : 0;
+		const outline = tok.resolvedRun.textOutline;
+		const fauxWidth = outline !== void 0 ? outline.widthPt : tok.synthetic?.bold === true ? tok.fontSizePt * .03 : 0;
 		if (fauxWidth !== lastFauxWidth) {
 			out.push(fauxWidth > 0 ? `2 Tr ${formatNumber(fauxWidth)} w` : "0 Tr");
 			lastFauxWidth = fauxWidth;
 		}
+		const strokeHex = outline?.colorHex;
+		if (strokeHex !== lastStroke) {
+			if (strokeHex !== void 0) {
+				const [sr, sg, sb] = hexToRgb01(strokeHex);
+				out.push(`${formatNumber(sr)} ${formatNumber(sg)} ${formatNumber(sb)} RG`);
+			}
+			lastStroke = strokeHex;
+		}
 		const tz = Math.round((tok.synthetic?.widthScale ?? 1) * 100);
 		if (tz !== lastTz) {
 			out.push(`${formatNumber(tz)} Tz`);
@@ -722,6 +732,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			}
 			lastFont = "";
 			lastFauxWidth = 0;
+			lastStroke = void 0;
+			lastStroke = void 0;
 			lastTz = 100;
 			lastSize = -1;
 			lastColor = "";
@@ -770,6 +782,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		}
 		lastFont = "";
 		lastFauxWidth = 0;
+		lastStroke = void 0;
 		lastTz = 100;
 		lastSize = -1;
 		lastColor = "";
@@ -804,6 +817,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			out.push("Q");
 			lastFont = "";
 			lastFauxWidth = 0;
+			lastStroke = void 0;
+			lastStroke = void 0;
 			lastTz = 100;
 			lastSize = -1;
 			lastColor = "";
@@ -831,6 +846,8 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			for (const op of emitVectorShape(shape)) out.push(op);
 			lastFont = "";
 			lastFauxWidth = 0;
+			lastStroke = void 0;
+			lastStroke = void 0;
 			lastTz = 100;
 			lastSize = -1;
 			lastColor = "";
@@ -850,6 +867,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		out.push(`${formatNumber(clip.x)} ${formatNumber(H - clip.y - clip.height)} ${formatNumber(clip.width)} ${formatNumber(clip.height)} re W n`);
 		lastFont = "";
 		lastFauxWidth = 0;
+		lastStroke = void 0;
 		lastTz = 100;
 		lastSize = -1;
 		lastColor = "";
@@ -864,6 +882,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 		out.push("Q");
 		lastFont = "";
 		lastFauxWidth = 0;
+		lastStroke = void 0;
 		lastTz = 100;
 		lastSize = -1;
 		lastColor = "";

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

@@ -0,0 +1,24 @@
+import { Matrix } from './content.js';
+import { PdfDict, PdfStream } from '../pdf/objects.js';
+import { PdfFile, PdfPage } from './document.js';
+/** One annotation's normal appearance, ready to interpret in page space. */
+export interface Appearance {
+    readonly stream: PdfStream;
+    /** Maps the appearance's own space onto the page (§12.5.5). */
+    readonly ctm: Matrix;
+    /** The appearance's `/Resources`, when it states its own. */
+    readonly resources: PdfDict | undefined;
+}
+/**
+ * Every annotation appearance the page shows, in `/Annots` order — which is
+ * the order they paint in, over the page's own content.
+ *
+ * A `Popup` is a note's window and is never part of the page. An annotation
+ * flagged Hidden or NoView paints nothing. An `/AP` `/N` may be a stream or a
+ * dictionary of states, in which case `/AS` names the one in force.
+ *
+ * @param file The owning file, for resolving references.
+ * @param page The page whose annotations are wanted.
+ * @returns The appearances, each with the matrix that places it on the page.
+ */
+export declare function collectPageAppearances(file: PdfFile, page: PdfPage): Array<Appearance>;

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

@@ -0,0 +1,126 @@
+import { PDF_NULL, PdfName, PdfStream } from "../pdf/objects.js";
+import { IDENTITY, multiply } from "./content.js";
+//#region src/pdf-reader/annots.ts
+/** §12.5.3 `/F` — the annotation is not painted at all. */
+var FLAG_HIDDEN = 2;
+var FLAG_NOVIEW = 32;
+/**
+* Every annotation appearance the page shows, in `/Annots` order — which is
+* the order they paint in, over the page's own content.
+*
+* A `Popup` is a note's window and is never part of the page. An annotation
+* flagged Hidden or NoView paints nothing. An `/AP` `/N` may be a stream or a
+* dictionary of states, in which case `/AS` names the one in force.
+*
+* @param file The owning file, for resolving references.
+* @param page The page whose annotations are wanted.
+* @returns The appearances, each with the matrix that places it on the page.
+*/
+function collectPageAppearances(file, page) {
+	const annots = file.get(page.dict, "Annots");
+	if (!Array.isArray(annots)) return [];
+	const out = [];
+	for (const entry of annots) {
+		const annot = file.resolve(entry);
+		if (!(annot instanceof Map)) continue;
+		const subtype = file.get(annot, "Subtype");
+		if (subtype instanceof PdfName && subtype.value === "Popup") continue;
+		const flags = file.get(annot, "F");
+		if (typeof flags === "number" && (flags & FLAG_HIDDEN || flags & FLAG_NOVIEW)) continue;
+		const stream = normalAppearance(file, annot);
+		if (!stream) continue;
+		const rect = rectangle(file.get(annot, "Rect"));
+		if (!rect) continue;
+		const matrix = matrixOf(file, stream.dict);
+		const bbox = rectangle(file.get(stream.dict, "BBox"));
+		const resources = file.get(stream.dict, "Resources");
+		out.push({
+			stream,
+			ctm: multiply(matrix, fitToRect(bbox, matrix, rect)),
+			resources: resources instanceof Map ? resources : void 0
+		});
+	}
+	return out;
+}
+/** §12.5.5 `/AP` `/N` — the normal appearance, through `/AS` when it is a set. */
+function normalAppearance(file, annot) {
+	const ap = file.get(annot, "AP");
+	if (!(ap instanceof Map)) return void 0;
+	const normal = file.get(ap, "N");
+	if (normal instanceof PdfStream) return normal;
+	if (!(normal instanceof Map)) return void 0;
+	const state = file.get(annot, "AS");
+	const picked = state instanceof PdfName ? file.resolve(normal.get(state.value) ?? PDF_NULL) : PDF_NULL;
+	if (picked instanceof PdfStream) return picked;
+	const only = [...normal.values()].map((v) => file.resolve(v)).filter((v) => v instanceof PdfStream);
+	return only.length === 1 ? only[0] : void 0;
+}
+/**
+* §12.5.5 — the matrix taking the form's `/Matrix`-transformed `/BBox` onto the
+* annotation's `/Rect`: the two are fitted corner to corner, so an appearance
+* authored at any size lands exactly in the rectangle that owns it.
+*/
+function fitToRect(bbox, matrix, rect) {
+	if (!bbox) return [
+		1,
+		0,
+		0,
+		1,
+		rect[0],
+		rect[1]
+	];
+	const xs = [];
+	const ys = [];
+	for (const [x, y] of [
+		[bbox[0], bbox[1]],
+		[bbox[2], bbox[1]],
+		[bbox[2], bbox[3]],
+		[bbox[0], bbox[3]]
+	]) {
+		xs.push(matrix[0] * x + matrix[2] * y + matrix[4]);
+		ys.push(matrix[1] * x + matrix[3] * y + matrix[5]);
+	}
+	const bw = Math.max(...xs) - Math.min(...xs);
+	const bh = Math.max(...ys) - Math.min(...ys);
+	const sx = bw > 0 ? (rect[2] - rect[0]) / bw : 1;
+	const sy = bh > 0 ? (rect[3] - rect[1]) / bh : 1;
+	return [
+		sx,
+		0,
+		0,
+		sy,
+		rect[0] - Math.min(...xs) * sx,
+		rect[1] - Math.min(...ys) * sy
+	];
+}
+/** §8.10.2 `/Matrix`, or the identity when the form states none. */
+function matrixOf(file, dict) {
+	const m = file.resolve(dict.get("Matrix") ?? PDF_NULL);
+	if (!Array.isArray(m) || m.length !== 6) return IDENTITY;
+	const n = m.map((v) => {
+		const r = file.resolve(v);
+		return typeof r === "number" ? r : 0;
+	});
+	return [
+		n[0],
+		n[1],
+		n[2],
+		n[3],
+		n[4],
+		n[5]
+	];
+}
+/** A four-number array as an ordered rectangle, or `undefined`. */
+function rectangle(v) {
+	if (!Array.isArray(v) || v.length < 4) return void 0;
+	const n = v.slice(0, 4).map((x) => typeof x === "number" ? x : NaN);
+	if (n.some((x) => !Number.isFinite(x))) return void 0;
+	return [
+		Math.min(n[0], n[2]),
+		Math.min(n[1], n[3]),
+		Math.max(n[0], n[2]),
+		Math.max(n[1], n[3])
+	];
+}
+//#endregion
+export { collectPageAppearances };

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

@@ -1,4 +1,5 @@
 import { ShapeGradient } from '../core/vector.js';
+import { PdfDict, PdfStream } from '../pdf/objects.js';
 /**
  * A page font as the interpreter needs it (built from the font dictionaries in
  * EP2b): how wide each code is, and how a run of codes decodes to Unicode. An
@@ -12,6 +13,27 @@ export interface ContentFont {
     decode: (codes: ReadonlyArray<number>) => string;
     /** Glyph advance for one code, in 1000-unit text space. */
     width: (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). */
+    readonly bold?: boolean;
+    /** §9.8.1 — the face is slanted (`/ItalicAngle`, the Italic flag, or its name). */
+    readonly italic?: boolean;
+    /**
+     * §9.6.5 — a Type 3 face, whose glyphs are content streams rather than
+     * outlines. What such a font draws is not type at all: it is whatever the
+     * procedure paints, in the resources the font states.
+     */
+    readonly type3?: Type3Face;
+}
+/** §9.6.5 — the parts of a Type 3 font a caller needs to run its glyphs. */
+export interface Type3Face {
+    /** `/FontMatrix` — glyph space to text space. */
+    readonly matrix: Matrix;
+    /** `/Encoding` + `/CharProcs` — the content stream one code draws. */
+    readonly proc: (code: number) => PdfStream | undefined;
+    /** `/Resources` the procedures draw with, when the font states its own. */
+    readonly resources: PdfDict | undefined;
 }
 /**
  * One positioned text run emitted by a show operator: its decoded text, the
@@ -24,8 +46,63 @@ export interface TextRun {
     readonly x: number;
     /** Glyph origin y in page space (points). */
     readonly y: number;
+    /**
+     * Where the pen stood after the last glyph, in page space (§9.4.4). The
+     * interpreter advances the text matrix by the font's own widths, so this is
+     * a measurement, not the half-em-per-character guess the reader used to make
+     * — and the difference between a word space and a table column is exactly
+     * the kind of thing a guess gets wrong.
+     */
+    readonly endX: number;
+    /** The pen's y after the last glyph — with {@link endX}, the whole advance. */
+    readonly endY: number;
+    /**
+     * The baseline's direction in page space, degrees counter-clockwise from
+     * left-to-right (§9.4.2 — the text matrix may turn as well as move). Absent
+     * for ordinary upright text, which is nearly all of it.
+     */
+    readonly angleDeg?: number;
     readonly fontSizePt: number;
     readonly fontKey: string;
+    /**
+     * §9.6.2 `/BaseFont` — the face's own name, subset prefix dropped and
+     * lowercased, or absent when the font states none. This is what a rebuilt run
+     * asks for, so a page whose faces the file EMBEDS is re-set in them rather
+     * than in a substitute (see `./embedded-fonts`).
+     */
+    readonly fontName?: string;
+    /** §9.8.1 — the face the glyphs were shown in is a bold one. */
+    readonly bold?: boolean;
+    /**
+     * §8.6.6.2 — the glyphs are filled with a tiling PATTERN, named here for the
+     * caller to resolve: a pattern is a content stream, not a colour, and the
+     * fill colour still standing from before is not what the page shows.
+     */
+    readonly fillPatternName?: string;
+    /**
+     * §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
+     * that way, under the picture of the page — so the run is kept, because it
+     * is the only text such a document has, and a reader reproducing the page
+     * leaves it to the picture.
+     */
+    readonly invisible?: boolean;
+    /**
+     * §9.3.6 — the colour the glyphs are STROKED in, when the rendering mode
+     * asks for a stroke, and how wide the pen is.
+     */
+    readonly outlineHex?: string;
+    readonly outlineWidthPt?: number;
+    /** §9.8.1 — the face the glyphs were shown in is a slanted one. */
+    readonly italic?: boolean;
+    /**
+     * §9.6.5 — the face is a Type 3 one, so what the page SHOWS here is the
+     * glyph procedures, not type. The run is kept for its words; a reader that
+     * reproduces the page draws the procedures instead of re-setting it.
+     */
+    readonly type3?: boolean;
+    /** §8.6.8 — the non-stroking colour the glyphs were painted in (6-hex). */
+    readonly colorHex: string;
     /**
      * The marked-content id of the enclosing `BDC` sequence (§14.6), if any — the
      * link from this text to the structure element that owns it (E-PDF EP3).
@@ -43,6 +120,8 @@ export interface TextRun {
  * `mcid` links the paint to its structure element (a `/Figure`, E-PDF EP6).
  */
 export interface ImagePlacement {
+    /** Where the `Do` fell in the stream's painting order — see {@link VectorPlacement.order}. */
+    readonly order: number;
     /** XObject resource name (no leading slash). */
     readonly name: string;
     readonly ctm: Matrix;
@@ -72,17 +151,38 @@ export type PathSeg = {
     readonly op: 'close';
 };
 /**
- * A painted path emitted by the path-painting operators (§8.5.3), captured in
- * page space (y-up). The optional fields record only what the paint mode set:
- * a fill colour/gradient (EP10/EP16c) and/or a stroke colour + width (EP11),
- * plus the enclosing structure id.
+ * §8.5.4 — the clipping region in force when a path was painted: the path that
+ * `W`/`W*` installed, plus its page-space bounding box.
  */
+export interface ClipRegion {
+    readonly segs: ReadonlyArray<PathSeg>;
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+}
 export interface VectorPlacement {
+    /**
+     * Where this fell in the stream's painting order (§8.5.3): later covers
+     * earlier, and a `Do` of a form is numbered here too, so a caller walking
+     * into that form knows exactly where its marks belong among these.
+     */
+    readonly order: number;
     readonly segs: ReadonlyArray<PathSeg>;
+    /** §8.5.4 — the clip in force when it was painted, when there was one. */
+    readonly clip?: ClipRegion;
     /** Fill colour (6-hex), present iff the path is filled (`f` / `F` / `f*` / `B` / `b`). */
     readonly fillHex?: string;
     /** Shading pattern, present iff filled with one (EP16c). */
     readonly gradient?: ShapeGradient;
+    /** §11.6.4.4 `/ca` — how opaque the fill is, when the page asked for less. */
+    readonly alpha?: number;
+    /**
+     * §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
+     * known by walking into it; the `fillHex` beside this is not the fill.
+     */
+    readonly patternName?: string;
     /** Stroke colour (6-hex), present iff the path is stroked (`S` / `s` / `B` / `b`) — EP11. */
     readonly strokeHex?: string;
     /** Stroke width in page-space points — EP11. */
@@ -94,6 +194,19 @@ export interface InterpretResult {
     readonly texts: Array<TextRun>;
     readonly images: Array<ImagePlacement>;
     readonly vectors: Array<VectorPlacement>;
+    /** §9.6.5 — every Type 3 glyph the stream showed, with where to run it. */
+    readonly glyphs: Array<Type3Call>;
+}
+/**
+ * §9.6.5 — one showing of a Type 3 glyph: which procedure, and the matrix that
+ * puts glyph space on the page.
+ */
+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;
 }
 /**
  * 2D affine matrix `[a b c d e f]`, row-vector convention (`[x y 1] · M`):
@@ -120,6 +233,19 @@ export declare function multiply(a: Matrix, b: Matrix): Matrix;
  *                   an unmapped key falls back to Latin-1 with a half-em advance.
  * @param initialCtm The starting CTM mapping user space to page space.
  * @param shadings   Shading patterns by name, selected by `scn`/`sc` (EP16c).
+ * @param alphas     Constant fill alphas by `/ExtGState` name, selected by `gs`.
  * @returns The extracted text runs, image placements and vector paths.
  */
-export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, ShapeGradient>): InterpretResult;
+export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, ShapeGradient>, alphas?: ReadonlyMap<string, number>): InterpretResult;
+/**
+ * Whether a string is wholly right-to-left: at least one letter of an RTL
+ * script and nothing of any other, spaces and joiners aside.
+ *
+ * Anything mixed — a number inside an Arabic sentence runs left to right —
+ * needs the full bidi algorithm, and guessing at it would be worse than
+ * leaving it alone.
+ *
+ * @param text The string to judge.
+ * @returns Whether it is one run of right-to-left script.
+ */
+export declare function isRightToLeft(text: string): boolean;