reamkit 1.30.0 → 1.32.0

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

@@ -5,6 +5,7 @@ import { textMarkupOf } from "./annot-draw.js";
 import { appearanceContent, collectPageAppearances } from "./annots.js";
 import { buildContentFont } from "./font.js";
 import { hiddenProperties, hiddenXObject } from "./optional-content.js";
+import { addShown } from "./face-outlines.js";
 import { patternTint, tintedHex } from "./pattern-tint.js";
 //#region src/pdf-reader/text.ts
 var MAX_FORM_DEPTH = 8;
@@ -15,22 +16,24 @@ var MAX_FORM_DEPTH = 8;
 * origin falls inside a `/Link` annotation's `/Rect` with that link's URI (EP8)
 * so hyperlinks survive.
 *
-* @param file The owning {@link PdfFile}.
-* @param page The page to extract.
+* @param file  The owning {@link PdfFile}.
+* @param page  The page to extract.
+* @param painted Where to gather the codes each font painted, for a caller
+*                that embeds the faces (see `./face-outlines`).
 * @returns The page's runs, each carrying an `href` when it sits under a link.
 */
-function extractPageText(file, page) {
+function extractPageText(file, page, painted) {
 	const runs = [];
-	collectRuns(file, page.resources, file.pageContent(page), IDENTITY, 0, /* @__PURE__ */ new Set(), runs);
+	collectRuns(file, page.resources, file.pageContent(page), IDENTITY, 0, /* @__PURE__ */ new Set(), runs, painted);
 	const own = runs.length;
-	for (const appearance of collectPageAppearances(file, page)) collectRuns(file, appearance.resources ?? page.resources, appearanceContent(file, appearance), appearance.ctm, 1, new Set([appearance.stream]), runs);
+	for (const appearance of collectPageAppearances(file, page)) collectRuns(file, appearance.resources ?? page.resources, appearanceContent(file, appearance), appearance.ctm, 1, new Set([appearance.stream]), runs, painted);
 	for (let i = own; i < runs.length; i++) runs[i] = {
 		...runs[i],
 		annotation: true
 	};
 	const links = collectLinks(file, page);
 	const marks = collectTextMarkup(file, page);
-	const shown = withoutRestrikes(runs);
+	const shown = withAccentsComposed(withoutRestrikes(runs));
 	if (links.length === 0 && marks.length === 0) return shown;
 	return shown.flatMap((run) => {
 		const link = links.find((l) => inRect(run.x, run.y, l.rect));
@@ -168,6 +171,91 @@ function withoutRestrikes(runs) {
 }
 /** How near, in ems, a re-strike of the same text lands to the one it thickens. */
 var RESTRIKE_EM = .08;
+/**
+* §9.4.3 — an accent struck over a letter, composed with it.
+*
+* TeX sets an accented letter its font has no glyph for as two: the accent,
+* and the letter drawn back under it — "ï" is a dieresis and a dotless i.
+* Read as they come, comments.pdf's "naïve" came back "na¨ıve", the accent a
+* character of the word. A run that is one spacing accent, with the pen taken
+* back under it for the run after it, is the accent of that run's first letter
+* — or, where the accent was struck after its letter, of the last letter of the
+* run before it. The two are written as the one character Unicode composes them
+* into, a dotless i or j taking back its dot's place under the accent.
+*
+* @param runs The page's runs, in painting order.
+* @returns The runs with each such accent composed into its letter.
+*/
+function withAccentsComposed(runs) {
+	const out = [];
+	for (let i = 0; i < runs.length; i++) {
+		const run = runs[i];
+		const mark = ACCENTS.get(run.text);
+		const next = runs[i + 1];
+		const prev = out[out.length - 1];
+		if (mark !== void 0 && next !== void 0 && struckOver(run, next, "first")) {
+			const [first = "", ...rest] = [...next.text];
+			out.push({
+				...next,
+				text: accented(first, mark) + rest.join("")
+			});
+			i++;
+			continue;
+		}
+		if (mark !== void 0 && prev !== void 0 && struckOver(run, prev, "last")) {
+			const chars = [...prev.text];
+			const last = chars.pop() ?? "";
+			out[out.length - 1] = {
+				...prev,
+				text: chars.join("") + accented(last, mark)
+			};
+			continue;
+		}
+		out.push(run);
+	}
+	return out;
+}
+/**
+* Whether an accent stands over the first letter of a run (the pen taken back
+* under it) or over the last (the pen taken back to strike it): on one
+* baseline, give or take the lift an accent over a capital takes, and
+* overlapping it by more than a hair.
+*/
+function struckOver(accent, base, which) {
+	if (accent.angleDeg !== void 0 || base.angleDeg !== void 0) return false;
+	const size = base.fontSizePt || accent.fontSizePt || 10;
+	if (Math.abs(accent.y - base.y) > size * ACCENT_LIFT_EM) return false;
+	if (!/^\p{L}/u.test(which === "first" ? base.text : [...base.text].at(-1) ?? "")) return false;
+	const hair = size * ACCENT_OVERLAP_EM;
+	return which === "first" ? base.x < accent.endX - hair && base.x > accent.x - size : accent.x < base.endX - hair && accent.x > base.x;
+}
+/** A letter with an accent composed onto it: a dotless i or j takes back its dot's place. */
+function accented(letter, mark) {
+	return ((letter === "ı" ? "i" : letter === "ȷ" ? "j" : letter) + mark).normalize("NFC");
+}
+/** How far over the line, in ems, TeX lifts an accent to stand over a capital. */
+var ACCENT_LIFT_EM = .6;
+/** How far, in ems, an accent must overlap its letter to stand over it. */
+var ACCENT_OVERLAP_EM = .05;
+/** The spacing accents TeX strikes over a letter, and the combining marks they are. */
+var ACCENTS = new Map([
+	["`", "̀"],
+	["´", "́"],
+	["ˆ", "̂"],
+	["^", "̂"],
+	["˜", "̃"],
+	["~", "̃"],
+	["¯", "̄"],
+	["ˉ", "̄"],
+	["˘", "̆"],
+	["˙", "̇"],
+	["¨", "̈"],
+	["˚", "̊"],
+	["˝", "̋"],
+	["ˇ", "̌"],
+	["¸", "̧"],
+	["˛", "̨"]
+]);
 var spaceCache = /* @__PURE__ */ new WeakMap();
 /** The page's shading patterns, read once per resource dictionary. */
 var shadingCache = /* @__PURE__ */ new WeakMap();
@@ -187,14 +275,15 @@ function spacesOf(file, resources) {
 	spaceCache.set(resources, made);
 	return made;
 }
-function collectRuns(file, resources, content, baseCtm, depth, visiting, out) {
+function collectRuns(file, resources, content, baseCtm, depth, visiting, out, shown) {
 	const result = interpretContent(content, buildFonts(file, resources), baseCtm, shadingsOf(file, resources), void 0, spacesOf(file, resources), hiddenProperties(file, resources));
 	out.push(...result.texts.map((r) => withPatternColour(file, resources, r, visiting)));
+	if (shown) addShown(shown, result.shown);
 	if (depth >= MAX_FORM_DEPTH) return;
 	for (const glyph of result.glyphs) {
 		if (visiting.has(glyph.stream)) continue;
 		visiting.add(glyph.stream);
-		collectRuns(file, glyph.resources ?? resources, file.streamData(glyph.stream), glyph.ctm, depth + 1, visiting, out);
+		collectRuns(file, glyph.resources ?? resources, file.streamData(glyph.stream), glyph.ctm, depth + 1, visiting, out, shown);
 		visiting.delete(glyph.stream);
 	}
 	if (!resources) return;
@@ -208,7 +297,7 @@ function collectRuns(file, resources, content, baseCtm, depth, visiting, out) {
 		if (!(sub instanceof PdfName) || sub.value !== "Form") continue;
 		visiting.add(stream);
 		const formRes = file.get(stream.dict, "Resources");
-		collectRuns(file, formRes instanceof Map ? formRes : resources, file.streamData(stream), multiply(matrixOf(file, stream.dict), placement.ctm), depth + 1, visiting, out);
+		collectRuns(file, formRes instanceof Map ? formRes : resources, file.streamData(stream), multiply(matrixOf(file, stream.dict), placement.ctm), depth + 1, visiting, out, shown);
 		visiting.delete(stream);
 	}
 }

package/dist/esm/pdf-reader/type1-outline.d.ts

@@ -10,6 +10,17 @@ export interface Type1Font {
     readonly has: (name: string) => boolean;
     /** The program's own `/Encoding`: code → glyph name, where it states one. */
     readonly encoding?: ReadonlyMap<number, string>;
+    /**
+     * The embedding the program's licence allows — the OS/2 `fsType` Adobe
+     * writes into `FontInfo` as `/FSType`, where the program states one.
+     */
+    readonly fsType?: number;
+    /**
+     * §6.4 — how far the pen moves after a glyph, in thousandths of an em: the
+     * width its `hsbw` (or `sbw`) states. `undefined` where the program holds no
+     * such glyph or its charstring states no width first.
+     */
+    readonly advance: (name: string) => number | undefined;
 }
 /**
  * Read an embedded Type 1 program.

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

@@ -1,3 +1,4 @@
+import { postScriptFsType } from "./cff-outline.js";
 //#region src/pdf-reader/type1-outline.ts
 /**
 * Read an embedded Type 1 program.
@@ -31,7 +32,13 @@ function type1Font(program) {
 			return out;
 		},
 		has: (name) => parsed.charstrings.has(name),
-		...parsed.encoding ? { encoding: parsed.encoding } : {}
+		advance: (name) => {
+			const charstring = parsed.charstrings.get(name);
+			const width = charstring ? statedWidth(charstring) : void 0;
+			return width === void 0 ? void 0 : width * parsed.scale * 1e3;
+		},
+		...parsed.encoding ? { encoding: parsed.encoding } : {},
+		...parsed.fsType !== void 0 ? { fsType: parsed.fsType } : {}
 	};
 }
 function parseType1(program) {
@@ -47,11 +54,13 @@ function parseType1(program) {
 	const charstrings = readCharstrings(plain, text, lenIV);
 	if (charstrings.size === 0) return void 0;
 	const encoding = readEncoding(clear);
+	const fsType = postScriptFsType(clear);
 	return {
 		charstrings,
 		subrs: readSubrs(plain, text, lenIV),
 		...encoding ? { encoding } : {},
-		scale: readMatrixScale(clear) ?? .001
+		scale: readMatrixScale(clear) ?? .001,
+		...fsType !== void 0 ? { fsType } : {}
 	};
 }
 /** The `eexec` key (§7), and the one every charstring is encrypted with (§6.2). */
@@ -211,6 +220,7 @@ function runGlyph(font, program, depth) {
 	let inFlex = false;
 	let x = 0;
 	let y = 0;
+	let sideBearing = 0;
 	let open = false;
 	let steps = 0;
 	const moveTo = () => {
@@ -255,6 +265,7 @@ function runGlyph(font, program, depth) {
 				case 13:
 					x = stack[0] ?? 0;
 					y = 0;
+					sideBearing = x;
 					stack.length = 0;
 					break;
 				case 9:
@@ -404,18 +415,25 @@ function runGlyph(font, program, depth) {
 						break;
 					}
 					if (op2 === 6) {
-						const base = STANDARD_ENCODING[stack[3] ?? 0];
-						const charstring = base !== void 0 ? font.charstrings.get(base) : void 0;
-						if (charstring && depth < 2) {
+						const [asb = 0, adx = 0, ady = 0, bchar = 0, achar = 0] = stack;
+						if (open) out.push({ op: "close" });
+						open = false;
+						const part = (charCode, dx, dy) => {
+							const name = STANDARD_ENCODING[charCode];
+							const charstring = name !== void 0 ? font.charstrings.get(name) : void 0;
+							if (!charstring || depth >= 2) return;
 							const drawn = runGlyph(font, charstring, depth + 1);
-							if (drawn) out.push(...drawn.map((seg) => unscale(seg, font.scale)));
-						}
+							if (drawn) out.push(...drawn.map((seg) => shift(unscale(seg, font.scale), dx, dy)));
+						};
+						part(bchar, 0, 0);
+						part(achar, adx + sideBearing - asb, ady);
 						stack.length = 0;
 						return false;
 					}
 					if (op2 === 7) {
 						x = stack[0] ?? 0;
 						y = stack[1] ?? 0;
+						sideBearing = x;
 						stack.length = 0;
 						break;
 					}
@@ -457,10 +475,47 @@ function scaleSeg(seg, k) {
 		y: seg.y * k
 	};
 }
-/** The base of a `seac` comes back already scaled; this puts it back in glyph space. */
+/**
+* §6.4 — the width a charstring states before it draws: the second operand of
+* `hsbw` (`sbx wx hsbw`), or the third of `sbw` (`sbx sby wx wy sbw`).
+*/
+function statedWidth(code) {
+	const stack = [];
+	for (let i = 0; i < code.length && stack.length <= 4;) {
+		const b = code[i++];
+		if (b >= 32 && b <= 246) stack.push(b - 139);
+		else if (b >= 247 && b <= 250) stack.push((b - 247) * 256 + (code[i++] ?? 0) + 108);
+		else if (b >= 251 && b <= 254) stack.push(-(b - 251) * 256 - (code[i++] ?? 0) - 108);
+		else if (b === 255) {
+			stack.push(code[i] << 24 | code[i + 1] << 16 | code[i + 2] << 8 | code[i + 3] | 0);
+			i += 4;
+		} else if (b === 13) return stack[1];
+		else if (b === 12 && code[i] === 7) return stack[2];
+		else return void 0;
+	}
+}
+/** The parts of a `seac` come back already scaled; this puts them back in glyph space. */
 function unscale(seg, k) {
 	return scaleSeg(seg, k === 0 ? 1 : 1 / k);
 }
+/** A segment moved by `(dx, dy)`: where a `seac` puts its accent. */
+function shift(seg, dx, dy) {
+	if (seg.op === "close" || dx === 0 && dy === 0) 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
+	};
+}
 /** §C.1 — the names `seac` selects its two parts by, at the codes it states. */
 var STANDARD_ENCODING = {
 	32: "space",

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

@@ -266,15 +266,23 @@ function overlaps(a, b) {
 * path intersection, and where the two merely overlap the answer is the smaller
 * of them — bounded, never larger than the truth.
 *
+* A path is measured by where its curves reach, not where their handles stand,
+* and one that reaches past its clip by no more than a sliver is inside it. An
+* appearance's `/BBox` is drawn round the path it holds: comments.pdf signs its
+* sixth page with a stamp of sixty-seven strokes that its box meets exactly,
+* and a handle standing 0.03pt past the box made the signature a path round
+* its clip — it came back a black bar the width of the text.
+*
 * @param v The painted path as the interpreter saw it.
 * @returns The path to draw, or `undefined` when the clip leaves nothing.
 */
 function clipped(v) {
 	const clip = v.clip;
 	if (!clip) return v;
-	const b = bbox(v.segs);
+	const b = reachOf(v.segs);
 	if (!b) return v;
 	if (clip.minX >= b.maxX || clip.maxX <= b.minX || clip.minY >= b.maxY || clip.maxY <= b.minY) return;
+	if (b.minX >= clip.minX - SLIVER_PT && b.maxX <= clip.maxX + SLIVER_PT && b.minY >= clip.minY - SLIVER_PT && b.maxY <= clip.maxY + SLIVER_PT) return v;
 	const pathArea = Math.max(0, b.maxX - b.minX) * Math.max(0, b.maxY - b.minY);
 	if (Math.max(0, clip.maxX - clip.minX) * Math.max(0, clip.maxY - clip.minY) >= pathArea) return v;
 	return {
@@ -283,6 +291,68 @@ function clipped(v) {
 		segs: clip.segs
 	};
 }
+/** How far past its clip a path may reach and still be inside it: a box's rounding. */
+var SLIVER_PT = .5;
+/**
+* The box a path's curves reach: its points, and the turns of its curves —
+* a Bézier stays inside its handles, and rarely reaches them.
+*
+* @param segs The path.
+*/
+function reachOf(segs) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	const add = (x, y) => {
+		minX = Math.min(minX, x);
+		minY = Math.min(minY, y);
+		maxX = Math.max(maxX, x);
+		maxY = Math.max(maxY, y);
+	};
+	let [x, y] = [0, 0];
+	let [startX, startY] = [0, 0];
+	for (const s of segs) {
+		if (s.op === "close") {
+			[x, y] = [startX, startY];
+			continue;
+		}
+		if (s.op === "cubic") {
+			const [x0, y0] = [x, y];
+			for (const t of [...turnsOf(x0, s.x1, s.x2, s.x), ...turnsOf(y0, s.y1, s.y2, s.y)]) add(bezierAt(x0, s.x1, s.x2, s.x, t), bezierAt(y0, s.y1, s.y2, s.y, t));
+		}
+		add(s.x, s.y);
+		[x, y] = [s.x, s.y];
+		if (s.op === "move") [startX, startY] = [s.x, s.y];
+	}
+	return Number.isFinite(minX) ? {
+		minX,
+		minY,
+		maxX,
+		maxY
+	} : void 0;
+}
+/** Where, between its ends, one coordinate of a cubic Bézier turns back. */
+function turnsOf(p0, p1, p2, p3) {
+	const a = p3 - 3 * p2 + 3 * p1 - p0;
+	const b = 2 * (p2 - 2 * p1 + p0);
+	const c = p1 - p0;
+	let roots = [];
+	if (Math.abs(a) < FLAT) {
+		if (Math.abs(b) >= FLAT) roots = [-c / b];
+	} else {
+		const d = b * b - 4 * a * c;
+		if (d >= 0) roots = [(-b + Math.sqrt(d)) / (2 * a), (-b - Math.sqrt(d)) / (2 * a)];
+	}
+	return roots.filter((t) => t > 0 && t < 1);
+}
+/** A coefficient this small is none: the curve's derivative is of lower degree. */
+var FLAT = 1e-12;
+/** One coordinate of a cubic Bézier at `t`. */
+function bezierAt(p0, p1, p2, p3, t) {
+	const u = 1 - t;
+	return u * u * u * p0 + 3 * u * u * t * p1 + 3 * u * t * t * p2 + t * t * t * p3;
+}
 function bbox(segs) {
 	let minX = Infinity;
 	let minY = Infinity;

package/dist/esm/svg/svg-text.d.ts

@@ -0,0 +1,58 @@
+import { FontResource, LaidOutDocument, TextLineItem } from '../layout/page-doc.js';
+import { ImageCrop } from '../core/document-model/index.js';
+import { VectorShape } from '../core/vector.js';
+/** The glyph outlines of a page's faces, each defined once and used by id. */
+export declare class SvgGlyphs {
+    private readonly sources;
+    private readonly ids;
+    private readonly defs;
+    private readonly faceIds;
+    /**
+     * The id of the path that draws glyph `gid` of `font`, defining it on first
+     * use: `null` for a glyph with no ink (a space), `undefined` where the face
+     * carries no outlines this reads — the caller then sets the token as text.
+     *
+     * @param font The face.
+     * @param gid  The glyph.
+     * @returns The `<path>` id, `null`, or `undefined`.
+     */
+    use(font: FontResource, gid: number): string | null | undefined;
+    /** The `<defs>` holding every glyph used, or nothing when none was. */
+    defsXml(): string;
+    private sourceOf;
+}
+/** What drawing a line needs from the writer around it. */
+export interface SvgLineCtx {
+    readonly glyphs: SvgGlyphs;
+    /** The document-wide counter generated ids are numbered from. */
+    readonly ids: {
+        n: number;
+    };
+    readonly laid: LaidOutDocument;
+    /** A picture in a box, as the writer draws one. */
+    readonly image: (out: Array<string>, placed: PlacedImage) => void;
+    /** A vector shape, as the writer draws one. */
+    readonly shape: (out: Array<string>, shape: VectorShape) => void;
+}
+/** A picture placed in a box on the page — its top-left corner and size, in points. */
+export interface PlacedImage {
+    readonly resourceName: string;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly crop?: ImageCrop;
+    readonly rotationDeg?: number;
+    readonly flipH?: boolean;
+    readonly flipV?: boolean;
+    readonly alpha?: number;
+}
+/**
+ * Draw one laid-out line: what stands behind its glyphs, then the glyphs, a
+ * picture or formula wherever one stands in it.
+ *
+ * @param out  The SVG fragment sink.
+ * @param item The line, as the layout placed it.
+ * @param ctx  The glyph definitions and the writer's own drawing.
+ */
+export declare function emitSvgLine(out: Array<string>, item: TextLineItem, ctx: SvgLineCtx): void;