reamkit 1.29.0 → 1.31.0

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

@@ -21,10 +21,32 @@ var STANDARD = new Map([
 	...table(96, "quoteleft"),
 	...table(160, ". exclamdown cent sterling fraction yen florin section currency quotesingle quotedblleft guillemotleft guilsinglleft guilsinglright fi fl", ". endash dagger daggerdbl periodcentered . paragraph bullet quotesinglbase quotedblbase quotedblright guillemotright ellipsis perthousand . questiondown", ". grave acute circumflex tilde macron breve dotaccent dieresis . ring cedilla . hungarumlaut ogonek caron", "emdash . . . . . . . . . . . . . . .", ". AE . ordfeminine . . . . Lslash Oslash OE ordmasculine . . . .", ". ae . . . dotlessi . . lslash oslash oe germandbls . . . .")
 ]);
+/** Annex D.2 WIN — CP-1252. Only its punctuation block departs from Latin-1. */
+var WIN_ANSI = new Map([...ASCII, ...table(128, "Euro . quotesinglbase florin quotedblbase ellipsis dagger daggerdbl circumflex perthousand Scaron guilsinglleft OE . Zcaron .", ". quoteleft quoteright quotedblleft quotedblright bullet endash emdash tilde trademark scaron guilsinglright oe . zcaron Ydieresis")]);
+/** Annex D.2 MAC — Mac OS Roman, as the PDF variant states it. */
+var MAC_ROMAN = new Map([...ASCII, ...table(128, "Adieresis Aring Ccedilla Eacute Ntilde Odieresis Udieresis aacute agrave acircumflex adieresis atilde aring ccedilla eacute egrave", "ecircumflex edieresis iacute igrave icircumflex idieresis ntilde oacute ograve ocircumflex odieresis otilde uacute ugrave ucircumflex udieresis", "dagger degree cent sterling section bullet paragraph germandbls registered copyright trademark acute dieresis notequal AE Oslash", "infinity plusminus lessequal greaterequal yen mu partialdiff summation product pi integral ordfeminine ordmasculine Omega ae oslash", "questiondown exclamdown logicalnot radical florin approxequal Delta guillemotleft guillemotright ellipsis space Agrave Atilde Otilde OE oe", "endash emdash quotedblleft quotedblright quoteleft quoteright divide lozenge ydieresis Ydieresis fraction currency guilsinglleft guilsinglright fi fl", "daggerdbl periodcentered quotesinglbase quotedblbase perthousand Acircumflex Ecircumflex Aacute Edieresis Egrave Iacute Icircumflex Idieresis Igrave Oacute Ocircumflex", ". Ograve Uacute Ucircumflex Ugrave dotlessi circumflex tilde macron breve dotaccent ring cedilla hungarumlaut ogonek caron")]);
+/**
+* Annex D.2 WIN — the glyph NAMES of CP-1252's upper half, which the table
+* above leaves to Latin-1 for the TEXT. A program addressed by name still has
+* to be told which glyph 0xE9 is: `eacute`, looked up by name or through the
+* character a Unicode `cmap` keys it by. (0xA0 is `space` and 0xAD `hyphen`
+* here, as Annex D names the glyphs they draw.)
+*/
+var WIN_ANSI_LATIN = table(160, "space exclamdown cent sterling currency yen brokenbar section dieresis copyright ordfeminine guillemotleft logicalnot hyphen registered macron", "degree plusminus twosuperior threesuperior acute mu paragraph periodcentered cedilla onesuperior ordmasculine guillemotright onequarter onehalf threequarters questiondown", "Agrave Aacute Acircumflex Atilde Adieresis Aring AE Ccedilla Egrave Eacute Ecircumflex Edieresis Igrave Iacute Icircumflex Idieresis", "Eth Ntilde Ograve Oacute Ocircumflex Otilde Odieresis multiply Oslash Ugrave Uacute Ucircumflex Udieresis Yacute Thorn germandbls", "agrave aacute acircumflex atilde adieresis aring ae ccedilla egrave eacute ecircumflex edieresis igrave iacute icircumflex idieresis", "eth ntilde ograve oacute ocircumflex otilde odieresis divide oslash ugrave uacute ucircumflex udieresis yacute thorn ydieresis");
+/**
+* The glyph a code of WinAnsiEncoding's Latin-1 half selects, by name (see
+* `WIN_ANSI_LATIN`).
+*
+* @param code A one-byte code.
+* @returns The Annex D.2 glyph name, or `undefined` outside 0xA0–0xFF.
+*/
+function winAnsiLatinName(code) {
+	return WIN_ANSI_LATIN.get(code);
+}
 var TABLES = {
 	StandardEncoding: STANDARD,
-	WinAnsiEncoding: new Map([...ASCII, ...table(128, "Euro . quotesinglbase florin quotedblbase ellipsis dagger daggerdbl circumflex perthousand Scaron guilsinglleft OE . Zcaron .", ". quoteleft quoteright quotedblleft quotedblright bullet endash emdash tilde trademark scaron guilsinglright oe . zcaron Ydieresis")]),
-	MacRomanEncoding: new Map([...ASCII, ...table(128, "Adieresis Aring Ccedilla Eacute Ntilde Odieresis Udieresis aacute agrave acircumflex adieresis atilde aring ccedilla eacute egrave", "ecircumflex edieresis iacute igrave icircumflex idieresis ntilde oacute ograve ocircumflex odieresis otilde uacute ugrave ucircumflex udieresis", "dagger degree cent sterling section bullet paragraph germandbls registered copyright trademark acute dieresis notequal AE Oslash", "infinity plusminus lessequal greaterequal yen mu partialdiff summation product pi integral ordfeminine ordmasculine Omega ae oslash", "questiondown exclamdown logicalnot radical florin approxequal Delta guillemotleft guillemotright ellipsis space Agrave Atilde Otilde OE oe", "endash emdash quotedblleft quotedblright quoteleft quoteright divide lozenge ydieresis Ydieresis fraction currency guilsinglleft guilsinglright fi fl", "daggerdbl periodcentered quotesinglbase quotedblbase perthousand Acircumflex Ecircumflex Aacute Edieresis Egrave Iacute Icircumflex Idieresis Igrave Oacute Ocircumflex", ". Ograve Uacute Ucircumflex Ugrave dotlessi circumflex tilde macron breve dotaccent ring cedilla hungarumlaut ogonek caron")])
+	WinAnsiEncoding: WIN_ANSI,
+	MacRomanEncoding: MAC_ROMAN
 };
 /**
 * The glyph names of a base encoding, or `undefined` for a name this has no
@@ -107,4 +129,4 @@ function isStandardLatinFace(baseFont) {
 	return STANDARD_LATIN_FACES.has(baseFont.trim().replace(/^[A-Za-z]{6}\+/u, "").toLowerCase());
 }
 //#endregion
-export { baseEncodingTable, isStandardLatinFace, macGlyphName, standardEncodingTable };
+export { baseEncodingTable, isStandardLatinFace, macGlyphName, standardEncodingTable, winAnsiLatinName };

package/dist/esm/pdf-reader/face-outlines.d.ts

@@ -0,0 +1,78 @@
+import { ContentFont, TextRun } from './content.js';
+import { FaceOutlines } from '../core/ir/flow.js';
+/** The codes each font showed where the pages paint them, gathered across pages. */
+export type ShownCodes = Map<ContentFont, Set<number>>;
+/**
+ * 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`).
+ */
+export declare function addShown(into: ShownCodes, from: ReadonlyMap<ContentFont, ReadonlySet<number>>): void;
+/**
+ * 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.
+ */
+export declare function faceOutlinesOf(shown: ShownCodes, spacing?: PageSpacing): Map<string, FaceOutlines>;
+/**
+ * How a page spaces a face's text apart where it moves the pen rather than
+ * draws a glyph — between words, and between two letters of one word.
+ */
+export interface PageSpacing {
+    /** Face → the white it leaves between words, in thousandths of an em. */
+    readonly wordGaps: ReadonlyMap<string, number>;
+    /**
+     * Face → the pairs of letters it is KERNED by: the two characters → how far
+     * the second stands from where the first's advance leaves it, in thousandths
+     * of an em (negative tightens).
+     */
+    readonly kerning: ReadonlyMap<string, ReadonlyMap<string, number>>;
+}
+/**
+ * §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.
+ */
+export declare function pageSpacing(pages: ReadonlyArray<ReadonlyArray<TextRun>>): PageSpacing;
+/**
+ * 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.
+ */
+export declare function kernedFaces(spacing: PageSpacing): Set<string>;

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>;