reamkit 1.29.0 → 1.31.0

package/dist/esm/pdf-reader/cff-outline.js

@@ -1,3 +1,4 @@
+import { standardEncodingTable } from "./encodings.js";
 //#region src/pdf-reader/cff-outline.ts
 /**
 * Prepare an embedded CFF program for outline reading.
@@ -69,6 +70,90 @@ function cffCidToGid(program) {
 		return;
 	}
 }
+/**
+* How far the pen moves after a name-keyed CFF program's `space`, in
+* thousandths of an em — the width a writer gives the space a page never
+* showed, which is the one it was typeset with.
+*
+* @param program The raw CFF bytes.
+* @returns The advance, or `undefined` where the program has no `space` or its
+*          width cannot be read off the charstring.
+*/
+function cffSpaceAdvance(program) {
+	try {
+		const font = parseCff(program);
+		const gid = font?.nameToGid?.get("space");
+		if (!font || gid === void 0) return void 0;
+		const width = glyphWidth(font, gid);
+		return width === void 0 ? void 0 : width * font.scale * 1e3;
+	} catch {
+		return;
+	}
+}
+/**
+* TN 5177 §4.1 — a glyph's width: `nominalWidthX` plus the operand a
+* charstring puts before its first stack-clearing operator, or
+* `defaultWidthX` where it puts none. Whether one is there is a matter of
+* COUNT — one more than the operator takes.
+*/
+function glyphWidth(font, gid) {
+	const code = font.charStrings[gid];
+	if (!code) return void 0;
+	const { defaultWidth, nominalWidth } = font.widthsOf(gid);
+	const stack = [];
+	for (let i = 0; i < code.length;) {
+		const b = code[i++];
+		if (b === 28) {
+			stack.push((code[i] << 24 | code[i + 1] << 16) >> 16);
+			i += 2;
+		} else if (b >= 32 && b <= 246) stack.push(b - 139);
+		else if (b >= 247 && b <= 250) stack.push((b - 247) * 256 + code[i++] + 108);
+		else if (b >= 251 && b <= 254) stack.push(-(b - 251) * 256 - code[i++] - 108);
+		else if (b === 255) {
+			stack.push((code[i] << 24 | code[i + 1] << 16 | code[i + 2] << 8 | code[i + 3]) / 65536);
+			i += 4;
+		} else {
+			const takes = b === 21 ? 2 : b === 22 || b === 4 ? 1 : b === 14 ? stack.length >= 4 ? 4 : 0 : -1;
+			if (b === 1 || b === 3 || b === 18 || b === 23 || b === 19 || b === 20) return stack.length % 2 === 1 ? nominalWidth + stack[0] : defaultWidth;
+			if (takes < 0) return void 0;
+			return stack.length > takes ? nominalWidth + stack[0] : defaultWidth;
+		}
+	}
+}
+/**
+* The embedding a CFF program's licence allows: CFF has no OS/2 table, and
+* Adobe writes the OS/2 `fsType` into the Top DICT's `PostScript` string
+* instead (TN 5176 §9, key 12 21) as `/FSType 8 def`.
+*
+* @param program The raw CFF bytes.
+* @returns The value, or `undefined` where the program states none.
+*/
+function cffFsType(program) {
+	try {
+		const names = readIndex(program, program[2] ?? 4);
+		const tops = names ? readIndex(program, names.end) : void 0;
+		const strings = tops ? readIndex(program, tops.end) : void 0;
+		const top = tops?.items[0];
+		if (!top || !strings) return void 0;
+		const sid = parseDict(top).get(1221)?.[0];
+		if (sid === void 0 || sid < STANDARD_STRINGS.length) return void 0;
+		const own = strings.items[sid - STANDARD_STRINGS.length];
+		return own ? postScriptFsType(new TextDecoder("latin1").decode(own)) : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The `/FSType n def` a PostScript font program writes where an OpenType one
+* has its OS/2 field (Adobe TN 5176 §9; a Type 1 font's `FontInfo` alike).
+*
+* @param text The PostScript to search.
+* @returns The value, or `undefined` where the text states none.
+*/
+function postScriptFsType(text) {
+	const m = /\/FSType\s+(\d+)\s+def/u.exec(text);
+	return m ? Number(m[1]) : void 0;
+}
 /** The `CFF ` table of an OpenType wrapper, where the program is one. */
 function openTypeCff(program) {
 	if (program.length < 12) return void 0;
@@ -102,27 +187,52 @@ function parseCff(program) {
 	if (!charStrings) return void 0;
 	const matrix = top.get(1207);
 	const scale = matrix && matrix.length >= 4 ? matrix[0] ?? .001 : .001;
-	const privateSubrs = (dict) => {
+	const privateOf = (dict) => {
+		const none = {
+			subrs: [],
+			widths: {
+				defaultWidth: 0,
+				nominalWidth: 0
+			}
+		};
 		const priv = dict.get(18);
-		if (!priv || priv.length < 2) return [];
+		if (!priv || priv.length < 2) return none;
 		const size = priv[0];
 		const offset = priv[1];
-		if (offset < 0 || offset + size > program.length) return [];
-		const subrsAt = parseDict(program.subarray(offset, offset + size)).get(19)?.[0];
-		if (subrsAt === void 0) return [];
-		return readIndex(program, offset + subrsAt)?.items ?? [];
+		if (offset < 0 || offset + size > program.length) return none;
+		const inner = parseDict(program.subarray(offset, offset + size));
+		const widths = {
+			defaultWidth: inner.get(20)?.[0] ?? 0,
+			nominalWidth: inner.get(21)?.[0] ?? 0
+		};
+		const subrsAt = inner.get(19)?.[0];
+		if (subrsAt === void 0) return {
+			subrs: [],
+			widths
+		};
+		return {
+			subrs: readIndex(program, offset + subrsAt)?.items ?? [],
+			widths
+		};
 	};
 	const isCid = top.has(1230);
 	let localSubrs;
+	let widthsOf;
 	if (isCid) {
 		const fdArrayAt = top.get(1236)?.[0];
 		const fdSelectAt = top.get(1237)?.[0];
-		const subrsPerFd = (fdArrayAt !== void 0 ? readIndex(program, fdArrayAt)?.items ?? [] : []).map((fd) => privateSubrs(parseDict(fd)));
+		const privatePerFd = (fdArrayAt !== void 0 ? readIndex(program, fdArrayAt)?.items ?? [] : []).map((fd) => privateOf(parseDict(fd)));
 		const select = fdSelectAt !== void 0 ? readFdSelect(program, fdSelectAt, charStrings.items.length) : void 0;
-		localSubrs = (gid) => subrsPerFd[select ? select[gid] ?? 0 : 0] ?? [];
+		const privateFor = (gid) => privatePerFd[select ? select[gid] ?? 0 : 0];
+		localSubrs = (gid) => privateFor(gid)?.subrs ?? [];
+		widthsOf = (gid) => privateFor(gid)?.widths ?? {
+			defaultWidth: 0,
+			nominalWidth: 0
+		};
 	} else {
-		const only = privateSubrs(top);
-		localSubrs = () => only;
+		const only = privateOf(top);
+		localSubrs = () => only.subrs;
+		widthsOf = () => only.widths;
 	}
 	const charsetAt = top.get(15)?.[0];
 	const sids = charsetAt !== void 0 && charsetAt > 2 ? readCharset(program, charsetAt, charStrings.items.length) : void 0;
@@ -134,7 +244,8 @@ function parseCff(program) {
 		localSubrs,
 		scale,
 		...cidToGid ? { cidToGid } : {},
-		...nameToGid ? { nameToGid } : {}
+		...nameToGid ? { nameToGid } : {},
+		widthsOf
 	};
 }
 /**
@@ -689,9 +800,10 @@ function bias(subrs) {
 /** How deep a charstring may call, and how many operators it may run. */
 var MAX_CALL_DEPTH = 10;
 var MAX_STEPS = 65536;
-function runGlyph(font, gid) {
+function runGlyph(font, gid, part = false) {
 	const program = font.charStrings[gid];
 	if (!program) return void 0;
+	let seac;
 	const local = font.localSubrs(gid);
 	const localBias = bias(local);
 	const globalBias = bias(font.globalSubrs);
@@ -885,7 +997,16 @@ function runGlyph(font, gid) {
 				}
 				case 11: return true;
 				case 14:
-					takeWidth(stack.length > 4 ? 4 : 0);
+					takeWidth(stack.length >= 4 ? 4 : 0);
+					if (stack.length >= 4) {
+						const [adx = 0, ady = 0, bchar = 0, achar = 0] = stack;
+						seac = {
+							adx,
+							ady,
+							bchar,
+							achar
+						};
+					}
 					if (open) out.push({ op: "close" });
 					open = false;
 					return false;
@@ -919,8 +1040,35 @@ function runGlyph(font, gid) {
 	}
 	run(program, 0);
 	if (out.length > 0 && out[out.length - 1]?.op !== "close") out.push({ op: "close" });
-	if (out.length === 0) return void 0;
-	return out.map((seg) => scaleSeg(seg, font.scale));
+	const own = out.map((seg) => scaleSeg(seg, font.scale));
+	if (seac && !part) {
+		const at = seac;
+		const glyphOf = (code) => {
+			const name = standardEncodingTable().get(code);
+			const gid = name !== void 0 ? font.nameToGid?.get(name) : void 0;
+			return gid !== void 0 ? runGlyph(font, gid, true) ?? [] : [];
+		};
+		own.push(...glyphOf(at.bchar), ...glyphOf(at.achar).map((seg) => shiftSeg(seg, at.adx * font.scale, at.ady * font.scale)));
+	}
+	return own.length > 0 ? own : void 0;
+}
+/** A segment moved by `(dx, dy)`: where a `seac` puts its accent. */
+function shiftSeg(seg, dx, dy) {
+	if (seg.op === "close") return seg;
+	if (seg.op === "cubic") return {
+		op: "cubic",
+		x1: seg.x1 + dx,
+		y1: seg.y1 + dy,
+		x2: seg.x2 + dx,
+		y2: seg.y2 + dy,
+		x: seg.x + dx,
+		y: seg.y + dy
+	};
+	return {
+		op: seg.op,
+		x: seg.x + dx,
+		y: seg.y + dy
+	};
 }
 function runEscape(op, stack, trans) {
 	switch (op) {
@@ -1030,8 +1178,8 @@ function flexCurves(op, stack, x0, y0) {
 		]);
 		push([
 			n(4),
-			n(6),
-			0
+			n(5),
+			n(6)
 		], [
 			0,
 			startY - y,
@@ -1051,12 +1199,12 @@ function flexCurves(op, stack, x0, y0) {
 		]);
 		push([
 			n(5),
-			n(7),
+			n(6),
 			n(8)
 		], [
 			0,
-			n(6),
-			startY - (y + n(6))
+			n(7),
+			startY - (y + n(7))
 		]);
 		y = startY;
 	} else if (op === 37) {
@@ -1119,4 +1267,4 @@ function scaleSeg(seg, k) {
 	};
 }
 //#endregion
-export { cffCidToGid, cffNameToGid, cffOutlineSource, openTypeCff };
+export { cffCidToGid, cffFsType, cffNameToGid, cffOutlineSource, cffSpaceAdvance, openTypeCff, postScriptFsType };

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

@@ -45,8 +45,11 @@ function parseToUnicodeCMap(bytes) {
 			const hiN = bytesToInt(hi.bytes);
 			const dst = lexer.nextToken();
 			if (dst.kind === "hexstr") {
-				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));
+				const base = utf16be(dst.bytes);
+				for (let i = 0; loN + i <= hiN && i < MAX_RANGE; i++) {
+					const text = stated(incString(base, i));
+					if (text !== void 0) map.set(loN + i, text);
+				}
 			} else if (dst.kind === "arrayOpen") {
 				let i = 0;
 				for (;;) {

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

@@ -1,6 +1,5 @@
-import { ColorSpaceInfo, GsPaint } from './shading.js';
+import { ColorSpaceInfo, GsPaint, PageGradient } from './shading.js';
 import { TextMarkup } from './annot-draw.js';
-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
@@ -22,6 +21,15 @@ 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.1 — the advance of the face's SPACE as the file states it, in
+     * 1000-unit text space: the code its encoding names `space`. Absent where
+     * the font states none — not the fallback {@link width} gives a code with no
+     * width of its own.
+     */
+    readonly spaceWidth?: number;
+    /** §9.8.2 — every glyph of the face is as wide as the next: a typewriter's. */
+    readonly fixedPitch?: boolean;
     /**
      * §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`.
@@ -48,6 +56,43 @@ export interface ContentFont {
      * this is the last resort before a blank page.
      */
     readonly outline?: GlyphOutline;
+    /**
+     * §9.9 — the face's embedded program, for a writer that embeds the face:
+     * the outline EVERY code draws, the program's licence, the descriptor's
+     * metrics. Only a face whose program this reads has one.
+     */
+    readonly program?: FaceProgram;
+}
+/**
+ * §9.9 — what a writer that embeds a face needs from its program: the outline
+ * each code draws, what the licence allows, and the metrics the descriptor
+ * states (§9.8.1).
+ */
+export interface FaceProgram {
+    /**
+     * The contours a code draws, in a one-unit em — empty for a glyph the program
+     * holds that draws nothing, `undefined` where it holds none for the code.
+     */
+    readonly glyph: (code: number) => ReadonlyArray<PathSeg> | undefined;
+    /**
+     * OS/2 `fsType` — or the `/FSType` a CFF or Type 1 program writes in its
+     * place — where the program states one.
+     */
+    readonly fsType?: number;
+    /**
+     * How far the program's own space advances, in thousandths of an em — the
+     * width a writer gives a space the page never showed as a glyph.
+     */
+    readonly spaceAdvance?: number;
+    /** The program's PostScript name: the `/BaseFont` less its subset tag. */
+    readonly postScriptName: string;
+    /** §9.8.1 `/CapHeight` and `/XHeight`, in thousandths of an em, where stated. */
+    readonly capHeight?: number;
+    readonly xHeight?: number;
+    /** §9.8.1 `/ItalicAngle`, in degrees counterclockwise from the vertical. */
+    readonly italicAngle: number;
+    /** §9.8.2 `/Flags` bit 1 — every glyph has the same width. */
+    readonly fixedPitch: boolean;
 }
 /** §9.6.6 — the outlines of a face read by glyph index, and their glyph space. */
 export interface GlyphOutline {
@@ -107,6 +152,8 @@ export interface TextRun {
      * Absent where the face states no width for it.
      */
     readonly spaceWidthPt?: number;
+    /** §9.8.2 — the face sets every glyph as wide as the next (see `ContentFont`). */
+    readonly fixedPitch?: boolean;
     /** §9.8.1 — the face the glyphs were shown in is a bold one. */
     readonly bold?: boolean;
     /**
@@ -136,6 +183,12 @@ export interface TextRun {
      * leaves it to the picture.
      */
     readonly invisible?: boolean;
+    /**
+     * §12.5.5 — drawn by an annotation's appearance rather than by the page: a
+     * field's value, a button's caption, a tick. It stands in the annotation's
+     * box, which is placed where the page has it, not in the page's reading.
+     */
+    readonly annotation?: 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.
@@ -245,7 +298,7 @@ export interface VectorPlacement {
     /** 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;
+    readonly gradient?: PageGradient;
     /** §11.6.4.4 `/ca` — how opaque the fill is, when the page asked for less. */
     readonly alpha?: number;
     /**
@@ -271,10 +324,18 @@ export interface VectorPlacement {
      * known by walking into it; the `fillHex` beside this is not the fill.
      */
     readonly patternName?: string;
+    /** §8.7.3.3 — the colour `scn` gave an uncoloured pattern, where it gave one. */
+    readonly patternPaint?: 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. */
     readonly lineWidth?: number;
+    /** §8.4.3.6 — the stroke's dash lengths in page-space points, where it is dashed. */
+    readonly dash?: ReadonlyArray<number>;
+    /** §8.4.3.3 — the stroke's cap, where it is not the butt cap every line starts with. */
+    readonly cap?: 'round' | 'square';
+    /** §11.6.4.4 `/CA` — how opaque the stroke is, when the page asked for less than all. */
+    readonly strokeAlpha?: number;
     readonly mcid?: number;
 }
 /** Everything {@link interpretContent} extracts from one page's content stream. */
@@ -296,6 +357,11 @@ export interface InterpretResult {
      * there is something to draw.
      */
     readonly outlines: Array<VectorPlacement>;
+    /**
+     * §9.4.3 — the codes each font with a readable program showed where the
+     * page paints them: the glyphs a writer embedding the face has to carry.
+     */
+    readonly shown: ReadonlyMap<ContentFont, ReadonlySet<number>>;
 }
 /**
  * §9.6.5 — one showing of a Type 3 glyph: which procedure, and the matrix that
@@ -357,7 +423,7 @@ export type Matrix = readonly [number, number, number, number, number, number];
 export declare const IDENTITY: Matrix;
 /** Compose two {@link Matrix matrices}: `a` applied first, then `b`. */
 export declare function multiply(a: Matrix, b: Matrix): Matrix;
-export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, ShapeGradient>, alphas?: ReadonlyMap<string, GsPaint>, spaces?: ReadonlyMap<string, ColorSpaceInfo>, hiddenOc?: ReadonlySet<string>): InterpretResult;
+export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, PageGradient>, alphas?: ReadonlyMap<string, GsPaint>, spaces?: ReadonlyMap<string, ColorSpaceInfo>, hiddenOc?: ReadonlySet<string>): 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.