reamkit 1.30.0 → 1.31.0

package/dist/esm/pdf-reader/face-outlines.js

@@ -0,0 +1,362 @@
+import { editableEmbedding } from "../core/font/ttf-build.js";
+import { isRightToLeft } from "./content.js";
+import { ASCENDER, NATURAL_LINE_EM } from "./flow-build.js";
+//#region src/pdf-reader/face-outlines.ts
+/**
+* Fold one content stream's shown codes into the document's.
+*
+* @param into The document's codes, added to.
+* @param from One stream's (`InterpretResult.shown`).
+*/
+function addShown(into, from) {
+	for (const [font, codes] of from) {
+		let set = into.get(font);
+		if (!set) into.set(font, set = /* @__PURE__ */ new Set());
+		for (const code of codes) set.add(code);
+	}
+}
+/**
+* The outlines of every face the pages painted characters in, keyed by the name
+* a run in the face carries.
+*
+* A face is left out where its program cannot be trusted to say what the page
+* showed: where more than a fifth of its characters have no glyph the reader
+* can find, the way to its glyphs is not the one the page took, and a face
+* embedded that way would show the wrong letters in place of a substitute's
+* right ones. A character whose glyph cannot be found is left out alone — a
+* reader draws it in another face.
+*
+* So is a face that shows a script which is SHAPED: an Arabic letter takes one
+* of four forms by its neighbours, and a face rebuilt here carries one glyph
+* per character and none of the rules that choose between them. Nor can it
+* carry the part of such a face it could: ArabicCIDTrueType.pdf maps half its
+* glyphs to presentation forms, which are shaped already, and half to plain
+* letters — embedded, each line came out in two faces, a bold word with light
+* letters in it.
+*
+* @param shown   The codes the pages painted, per font.
+* @param spacing How the pages space each face's text apart where they move the
+*                pen rather than draw a glyph (see {@link pageSpacing}).
+* @returns Run font name → the face's outlines.
+*/
+function faceOutlinesOf(shown, spacing = NO_SPACING) {
+	const faces = /* @__PURE__ */ new Map();
+	for (const [font, codes] of shown) {
+		const program = font.program;
+		if (!program || font.name === void 0) continue;
+		let face = faces.get(font.name);
+		if (!face) {
+			face = {
+				font,
+				program,
+				glyphs: /* @__PURE__ */ new Map(),
+				ligatures: /* @__PURE__ */ new Map(),
+				sought: 0,
+				missed: 0,
+				shaped: false
+			};
+			faces.set(font.name, face);
+		}
+		if (program.fsType !== void 0 && (face.fsType === void 0 || editableEmbedding(face.fsType))) face.fsType = program.fsType;
+		for (const code of [...codes].sort((a, b) => a - b)) gather(face, font, program, code);
+	}
+	const out = /* @__PURE__ */ new Map();
+	for (const [name, face] of faces) {
+		const outlines = outlinesOf(face, spacing.wordGaps.get(name), spacing.kerning.get(name));
+		if (outlines) out.set(name, outlines);
+	}
+	return out;
+}
+var NO_SPACING = {
+	wordGaps: /* @__PURE__ */ new Map(),
+	kerning: /* @__PURE__ */ new Map()
+};
+/**
+* §9.4.3 — what the gaps between a face's runs say about how it is spaced.
+*
+* The interpreter emits a run for every string of a `TJ` array, so where the
+* page nudges the pen inside a word — which is how a producer KERNS it — two
+* runs meet with the nudge between them, and the letters on either side are
+* the pair. bigboundingbox.pdf kerns its Calibri by eight pairs in one short
+* line, and set without them the line came out 0.67pt longer than the page's
+* and no longer fit the cell it was measured into. Each pair is the median of
+* every nudge the page gives it.
+*
+* A wider gap is the white between two words, where the page moves the pen
+* instead of showing a space; the face's space is the lower quartile of them,
+* which a justified line's stretched gaps do not reach.
+*
+* @param pages The runs each page set, in the order they were painted.
+* @returns Per face, its word gap and its kerning pairs.
+*/
+function pageSpacing(pages) {
+	const gaps = /* @__PURE__ */ new Map();
+	const nudges = /* @__PURE__ */ new Map();
+	const beside = /* @__PURE__ */ new Map();
+	for (const runs of pages) for (let i = 1; i < runs.length; i++) {
+		const a = runs[i - 1];
+		const b = runs[i];
+		const name = a.fontName;
+		if (name === void 0 || b.fontName !== name || a.angleDeg !== void 0) continue;
+		if (b.angleDeg !== void 0 || a.fontSizePt !== b.fontSizePt || !(a.fontSizePt > 0)) continue;
+		if (Math.abs(a.y - b.y) > a.fontSizePt * SAME_LINE_EM) continue;
+		if (isRightToLeft(a.text) || isRightToLeft(b.text)) continue;
+		const left = [...a.text].at(-1);
+		const right = [...b.text][0];
+		if (left === void 0 || right === void 0) continue;
+		const gap = (b.x - a.endX) / a.fontSizePt * 1e3;
+		if (/\s/u.test(left) || /\s/u.test(right)) {
+			if (gap > MIN_KERN && gap < MAX_KERN) {
+				let list = beside.get(name);
+				if (!list) beside.set(name, list = []);
+				list.push(b.x - a.endX);
+			}
+			continue;
+		}
+		if (gap >= MIN_WORD_GAP && gap <= MAX_WORD_GAP) {
+			let list = gaps.get(name);
+			if (!list) gaps.set(name, list = []);
+			list.push(gap);
+		} else if (gap > MIN_KERN && gap < MAX_KERN) {
+			let pairs = nudges.get(name);
+			if (!pairs) nudges.set(name, pairs = /* @__PURE__ */ new Map());
+			const pair = `${left}${right}`;
+			let list = pairs.get(pair);
+			if (!list) pairs.set(pair, list = []);
+			list.push([gap, b.x - a.endX]);
+		}
+	}
+	const wordGaps = /* @__PURE__ */ new Map();
+	for (const [name, list] of gaps) {
+		if (list.length < MIN_GAP_SAMPLES) continue;
+		list.sort((p, q) => p - q);
+		wordGaps.set(name, list[Math.floor(list.length / 4)]);
+	}
+	const kerning = /* @__PURE__ */ new Map();
+	for (const [name, pairs] of nudges) {
+		if (tracked([...pairs.values()].flat().map(([, points]) => points), beside.get(name) ?? [])) continue;
+		const kept = /* @__PURE__ */ new Map();
+		for (const [pair, list] of pairs) {
+			const inEm = median(list.map(([em]) => em));
+			const inPt = median(list.map(([, points]) => points));
+			if (Math.abs(inEm) < MIN_KERN_VALUE || Math.abs(inPt) < MIN_KERN_PT) continue;
+			if (list.length >= 2 && list.every(([, points]) => Math.abs(points - inPt) <= TWIP_PT) || Math.abs(inPt) >= SURE_KERN_PT) kept.set(pair, inEm);
+		}
+		if (kept.size >= MIN_KERNED_PAIRS) kerning.set(name, kept);
+	}
+	return {
+		wordGaps,
+		kerning
+	};
+}
+/**
+* Whether a face's nudges are TRACKING rather than kerning: one amount between
+* nearly every two letters, and beside its spaces too, where no face is kerned.
+* bug1157493.pdf sets a line of Courier half a tenth of an em tight, every
+* letter and every space alike; read as kerning pairs, its letters closed up
+* and its spaces did not.
+*
+* @param nudges The face's nudges between letters, in points.
+* @param beside Its nudges beside a space, in points.
+*/
+function tracked(nudges, beside) {
+	if (beside.length < MIN_TRACKED_SPACES || nudges.length === 0) return false;
+	const typical = median([...nudges, ...beside]);
+	if (Math.abs(typical) < MIN_KERN_PT) return false;
+	const near = (points) => Math.abs(points - typical) <= TWIP_PT;
+	const all = [...nudges, ...beside];
+	return beside.filter(near).length >= MIN_TRACKED_SPACES && all.filter(near).length >= all.length * TRACKED_SHARE;
+}
+/** How many nudges beside spaces, and what share of all, make a face tracked. */
+var MIN_TRACKED_SPACES = 2;
+var TRACKED_SHARE = .8;
+/**
+* The faces a page KERNED: those with kerning pairs (see {@link pageSpacing},
+* which keeps a face's pairs only where there are enough of them to say it was
+* kerning and not an accident of how its strings were cut).
+*
+* @param spacing How the pages space their faces (see {@link pageSpacing}).
+* @returns The run font names of the kerned faces.
+*/
+function kernedFaces(spacing) {
+	return new Set(spacing.kerning.keys());
+}
+/** The middle of some numbers: the mean of the middle two where they are even. */
+function median(values) {
+	const sorted = [...values].sort((p, q) => p - q);
+	const mid = sorted.length / 2;
+	return sorted.length % 2 === 1 ? sorted[Math.floor(mid)] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+/** Two runs within this much of an em of each other's baseline share a line. */
+var SAME_LINE_EM = .1;
+/** A gap between words: wider than a kern, narrower than a column's white. */
+var MIN_WORD_GAP = 100;
+var MAX_WORD_GAP = 600;
+/**
+* A nudge inside a word, in thousandths of an em: kerning tightens a pair by as
+* much as a quarter of an em and opens one by far less — a gap wider than this
+* is a space the page did not draw.
+*/
+var MIN_KERN = -250;
+var MAX_KERN = 60;
+/** A nudge smaller than this is the rounding of a producer's positions, not a kern. */
+var MIN_KERN_VALUE = 2;
+/**
+* …and so is one smaller than a twip and a half, in points: Word lays a line
+* out in twips and writes the difference from the face's own widths as a
+* nudge. annotation-highlight.pdf's Calibri is nudged three to six thousandths
+* of an em between letters no kerning table pairs, and taken for kerns they
+* moved its words a fraction of a pixel off the page's.
+*/
+var MIN_KERN_PT = .075;
+/** A twip, in points: the grid a Word page's positions are rounded to. */
+var TWIP_PT = .05;
+/**
+* A nudge this wide is a kern seen once: rounding moves a letter a twip or
+* two, and bug793632.pdf's Calibri is nudged two twips either way — "st" in
+* and "on" out — once each, by no kerning at all.
+*/
+var SURE_KERN_PT = .15;
+/** How many pairs make a face one the page kerned. */
+var MIN_KERNED_PAIRS = 2;
+/** How many gaps it takes to say how wide a face's space is. */
+var MIN_GAP_SAMPLES = 3;
+/** Read one code's glyph into its face, where it stands for one character or a ligature. */
+function gather(face, font, program, code) {
+	const chars = [...font.decode([code])];
+	if (chars.length > 1) {
+		gatherLigature(face, font, program, code, chars);
+		return;
+	}
+	if (chars.length !== 1) return;
+	const char = chars[0];
+	if (face.glyphs.has(char) || !embeddable(char)) return;
+	if (shaped(char)) {
+		face.shaped = true;
+		return;
+	}
+	const blank = WHITE.test(char);
+	if (!blank) face.sought++;
+	const outline = program.glyph(code);
+	if (outline === void 0 || outline.length === 0 && !blank) {
+		if (!blank) face.missed++;
+		return;
+	}
+	face.glyphs.set(char, {
+		outline,
+		advance: font.width(code)
+	});
+}
+/**
+* §9.10.2 — a code that stands for a run of letters is a LIGATURE: one glyph
+* the page drew for "fi", "ffl" or Calibri's "tt". The text carries the letters
+* and the rebuilt face the glyph, so a reader that joins them draws what the
+* page drew — set apart, attachment.pdf's "attachment" came out with two
+* crossbars where the page has one.
+*
+* Only letters, and no more than {@link MAX_LIGATURE} of them: a producer that
+* maps a glyph to a longer string — a logo to a company's name — has not drawn
+* a ligature.
+*/
+function gatherLigature(face, font, program, code, chars) {
+	const key = chars.join("");
+	if (chars.length > MAX_LIGATURE || face.ligatures.has(key)) return;
+	if (!chars.every((c) => /^\p{L}$/u.test(c) && !shaped(c))) return;
+	const outline = program.glyph(code);
+	if (outline === void 0 || outline.length === 0) return;
+	face.ligatures.set(key, {
+		outline,
+		advance: font.width(code)
+	});
+}
+/** The most letters one ligature joins: ffi, ffl. */
+var MAX_LIGATURE = 3;
+/** A face's gathered glyphs as {@link FaceOutlines}, where it is one to embed. */
+function outlinesOf(face, gap, kerning) {
+	if (face.shaped || face.sought === 0 || face.missed > face.sought * MAX_MISSED_SHARE) return;
+	const glyphs = new Map(face.glyphs);
+	const program = face.program;
+	if (!glyphs.has(" ")) glyphs.set(" ", {
+		outline: [],
+		advance: spaceAdvance(face, gap)
+	});
+	if (!glyphs.has("\xA0")) glyphs.set("\xA0", glyphs.get(" "));
+	const { yMin, yMax } = extent(glyphs);
+	const pairs = new Map([...kerning ?? []].filter(([pair]) => [...pair].every((c) => glyphs.has(c))));
+	const ligatures = new Map([...face.ligatures].filter(([letters]) => [...letters].every((c) => glyphs.has(c))));
+	return {
+		glyphs,
+		...pairs.size > 0 ? { kerning: pairs } : {},
+		...ligatures.size > 0 ? { ligatures } : {},
+		...face.fsType !== void 0 ? { fsType: face.fsType } : {},
+		bold: face.font.bold === true,
+		italic: face.font.italic === true,
+		postScriptName: program.postScriptName,
+		ascent: Math.max(ASCENDER * 1e3, yMax),
+		descent: Math.min((ASCENDER - NATURAL_LINE_EM) * 1e3, yMin),
+		...program.capHeight !== void 0 ? { capHeight: program.capHeight } : {},
+		...program.xHeight !== void 0 ? { xHeight: program.xHeight } : {},
+		italicAngle: program.italicAngle,
+		fixedPitch: program.fixedPitch
+	};
+}
+/** A face may miss no more than this share of the glyphs looked for. */
+var MAX_MISSED_SHARE = .2;
+/**
+* The advance of a space the page never showed: the width the file states for
+* the face's space (see `ContentFont.spaceWidth`), where it states one; the
+* width the program gives its space glyph — which a subset keeps though it
+* drops the outline;
+* the white the page itself leaves between the face's words; the one advance
+* every glyph has, in a fixed-pitch face; a quarter of an em otherwise.
+* bigboundingbox.pdf sets its Calibri in a subset that keeps no space and no
+* way to one, and spaces the words by hand: with a quarter of an em for
+* Calibri's 226 thousandths, "Enter the amount you are paying above" no longer
+* fit its cell.
+*/
+function spaceAdvance(face, gap) {
+	const width = face.font.spaceWidth;
+	if (width !== void 0 && width > 0 && width < 1e3) return width;
+	if (face.program.spaceAdvance !== void 0) return face.program.spaceAdvance;
+	if (gap !== void 0) return gap;
+	if (face.program.fixedPitch) {
+		const first = [...face.glyphs.values()].find((g) => g.advance > 0);
+		if (first) return first.advance;
+	}
+	return 250;
+}
+/** How high and how low the glyphs' contours reach, in thousandths of an em. */
+function extent(glyphs) {
+	let yMin = 0;
+	let yMax = 0;
+	for (const glyph of glyphs.values()) for (const seg of glyph.outline) {
+		if (seg.op === "close") continue;
+		yMin = Math.min(yMin, seg.y * 1e3);
+		yMax = Math.max(yMax, seg.y * 1e3);
+	}
+	return {
+		yMin,
+		yMax
+	};
+}
+/** Whitespace: a glyph that rightly draws nothing. */
+var WHITE = /^\s$/u;
+/** Whether a character is one a face carries at all: not a control or a format character. */
+function embeddable(char) {
+	return !/^[\p{Cc}\p{Cf}\p{Cs}\uFFFD]$/u.test(char);
+}
+/**
+* Whether a character is a letter of a script whose glyphs a face's shaping
+* rules choose — which a rebuilt face does not have.
+*/
+function shaped(char) {
+	const cp = char.codePointAt(0);
+	if (cp >= 64336 && cp <= 65023 || cp >= 65136 && cp <= 65279) return false;
+	if (cp >= 4352 && cp <= 4607 || cp >= 43360 && cp <= 43391) return true;
+	if (cp >= 55216 && cp <= 55295) return true;
+	return SHAPED.test(char);
+}
+/** The scripts whose glyphs a face's shaping rules choose. */
+var SHAPED = /\p{Script=Arabic}|\p{Script=Syriac}|\p{Script=Thaana}|\p{Script=Nko}|\p{Script=Mandaic}|\p{Script=Devanagari}|\p{Script=Bengali}|\p{Script=Gurmukhi}|\p{Script=Gujarati}|\p{Script=Oriya}|\p{Script=Tamil}|\p{Script=Telugu}|\p{Script=Kannada}|\p{Script=Malayalam}|\p{Script=Sinhala}|\p{Script=Thai}|\p{Script=Lao}|\p{Script=Tibetan}|\p{Script=Myanmar}|\p{Script=Khmer}|\p{Script=Mongolian}|\p{Script=Javanese}|\p{Script=Balinese}/u;
+//#endregion
+export { addShown, faceOutlinesOf, kernedFaces, pageSpacing };

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

@@ -0,0 +1,52 @@
+import { TextRun } from './content.js';
+import { PdfImage } from './images.js';
+import { PdfVector } from './vector.js';
+/** One drawing on a page, with the words set on it. Page space, y-up. */
+export interface PageFigure {
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+    /** The paths that draw it, in no particular order. */
+    readonly vectors: ReadonlyArray<PdfVector>;
+    /** The pictures it holds. */
+    readonly images: ReadonlyArray<PdfImage>;
+    /** The words set on it. */
+    readonly labels: ReadonlyArray<TextRun>;
+}
+/**
+ * The figures a page draws.
+ *
+ * A figure is paths that stand together — each within half an em of the next —
+ * and DRAW something: a curve or a slanted line among them. Straight lines
+ * and boxes alone are a ruling, which is a table's or a form's, and a page
+ * reads those as text. It has words set on it, or it is only artwork, which
+ * the page anchors as it always has; and none of its words run across it
+ * line after line, which is prose set on a ground, not a label.
+ *
+ * @param vectors The page's paths, where the page shows them.
+ * @param images  The page's pictures, likewise.
+ * @param runs    The page's text, likewise.
+ * @param sheet   The page's size.
+ * @returns The figures, top of the page first.
+ */
+export declare function pageFigures(vectors: ReadonlyArray<PdfVector>, images: ReadonlyArray<PdfImage>, runs: ReadonlyArray<TextRun>, sheet: {
+    readonly width: number;
+    readonly height: number;
+}): Array<PageFigure>;
+/**
+ * Whether a run is lettering the file states no character for: glyphs traced
+ * as paths (see `PdfVector.glyph`), and a label only by where they stand.
+ *
+ * @param run A run of the page's text.
+ */
+export declare function tracedRun(run: TextRun): boolean;
+/**
+ * A figure's paths with the traced letters painted one after another joined
+ * into one: the letters of a label are one shape, where a shape a letter made
+ * a chart of six hundred.
+ *
+ * @param paths The figure's paths, in the order the page painted them.
+ * @returns The paths to draw, in that order.
+ */
+export declare function joinLetters(paths: ReadonlyArray<PdfVector>): Array<PdfVector>;