reamkit 1.30.0 → 1.31.0

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

@@ -21,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`.
@@ -47,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 {
@@ -106,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;
     /**
@@ -309,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

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

@@ -191,6 +191,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 	const glyphs = [];
 	const painted = [];
 	const outlines = [];
+	const codesShown = /* @__PURE__ */ new Map();
 	const lexer = new Lexer(bytes);
 	const stack = [];
 	let state = initialState();
@@ -373,6 +374,11 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		const bytes = toBytes(operand);
 		const codes = state.font.splitCodes ? state.font.splitCodes(bytes) : splitCodes(bytes, state.font.bytesPerCode);
 		for (const code of codes) advanceGlyph(code);
+		if (state.font.program && visible() && state.renderMode !== 3 && state.renderMode !== 7) {
+			let set = codesShown.get(state.font);
+			if (!set) codesShown.set(state.font, set = /* @__PURE__ */ new Set());
+			for (const code of codes) set.add(code);
+		}
 		return state.font.decode(codes);
 	};
 	const emitAt = (origin, shown, end) => {
@@ -393,6 +399,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			fontSizePt: Math.abs(state.fontSize) * scaleY,
 			spaceWidthPt: (state.font.width(32) / 1e3 * state.fontSize + state.charSpacing + state.wordSpacing) * scaleX,
 			fontKey: state.fontKey,
+			...state.font.fixedPitch === true ? { fixedPitch: true } : {},
 			...state.font.name !== void 0 ? { fontName: state.font.name } : {},
 			...state.font.type3 ? { type3: true } : {},
 			...state.renderMode === 3 || state.renderMode === 7 ? { invisible: true } : {},
@@ -745,7 +752,8 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		vectors,
 		glyphs,
 		shadings: painted,
-		outlines
+		outlines,
+		shown: codesShown
 	};
 }
 /** One path segment through a matrix — the glyph's own space onto the page. */

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

@@ -15,6 +15,16 @@ export interface Display {
         x: number;
         y: number;
     };
+    /**
+     * §17.6.20 — present when the page is READ in a frame turned back from the
+     * sheet it is shown on: its words run DOWN the sheet, and they are read in
+     * the frame where they stand upright (see {@link textFrameOf}). `width` and
+     * `height` above are that frame's; these are the sheet's.
+     */
+    readonly sheet?: {
+        readonly width: number;
+        readonly height: number;
+    };
 }
 /**
  * The {@link Display} a page's shown box and `/Rotate` describe.
@@ -27,6 +37,32 @@ export interface Display {
  * @returns Its size, its turn, and the map onto it.
  */
 export declare function displayOf(page: PdfPage): Display;
+/**
+ * The frame a page whose words run DOWN its sheet is read in: the sheet turned
+ * back a quarter, so the words stand upright in it and every line, paragraph
+ * and margin is found the way it is on any other page.
+ *
+ * A viewer turns such a page with its words, and so does the document it is
+ * read into (§17.6.20 `tbRl`; see {@link wordsTurnOf} for when a page's words
+ * run down it): hello_world_rotated.pdf sets "Hello world"
+ * upright in a portrait box and turns the page by `/Rotate 90`, and read on
+ * the shown sheet the words were set flat across it where every viewer shows
+ * them running down.
+ *
+ * @param shown The page's shown geometry.
+ * @returns The frame, which knows the sheet it was turned back from.
+ */
+export declare function textFrameOf(shown: Display): Display;
+/**
+ * How a page's words stand on its sheet: the quarter turn, counter-clockwise,
+ * whose words outweigh every other on it together, by their letters at their
+ * size — or 0 where none does. A label set on its side beside the text does
+ * not turn a page; a page of it does.
+ *
+ * @param runs The page's runs, placed on the shown sheet.
+ * @returns 0, 90, 180 or 270; 270 is a page whose words run DOWN it.
+ */
+export declare function wordsTurnOf(runs: ReadonlyArray<TextRun>): 0 | 90 | 180 | 270;
 /**
  * The same runs, placed on the shown page.
  *

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

@@ -46,6 +46,71 @@ function displayOf(page) {
 	};
 }
 /**
+* The frame a page whose words run DOWN its sheet is read in: the sheet turned
+* back a quarter, so the words stand upright in it and every line, paragraph
+* and margin is found the way it is on any other page.
+*
+* A viewer turns such a page with its words, and so does the document it is
+* read into (§17.6.20 `tbRl`; see {@link wordsTurnOf} for when a page's words
+* run down it): hello_world_rotated.pdf sets "Hello world"
+* upright in a portrait box and turns the page by `/Rotate 90`, and read on
+* the shown sheet the words were set flat across it where every viewer shows
+* them running down.
+*
+* @param shown The page's shown geometry.
+* @returns The frame, which knows the sheet it was turned back from.
+*/
+function textFrameOf(shown) {
+	return {
+		width: shown.height,
+		height: shown.width,
+		turnDeg: shown.turnDeg === 270 || shown.turnDeg === -90 ? 0 : shown.turnDeg + 90,
+		place: (x, y) => {
+			const p = shown.place(x, y);
+			return {
+				x: shown.height - p.y,
+				y: p.x
+			};
+		},
+		sheet: {
+			width: shown.width,
+			height: shown.height
+		}
+	};
+}
+/**
+* How a page's words stand on its sheet: the quarter turn, counter-clockwise,
+* whose words outweigh every other on it together, by their letters at their
+* size — or 0 where none does. A label set on its side beside the text does
+* not turn a page; a page of it does.
+*
+* @param runs The page's runs, placed on the shown sheet.
+* @returns 0, 90, 180 or 270; 270 is a page whose words run DOWN it.
+*/
+function wordsTurnOf(runs) {
+	const by = [
+		0,
+		0,
+		0,
+		0
+	];
+	let all = 0;
+	for (const r of runs) {
+		const letters = r.text.trim().length;
+		if (letters === 0) continue;
+		const weight = letters * (r.fontSizePt || 10);
+		all += weight;
+		const angle = (Math.round(r.angleDeg ?? 0) % 360 + 360) % 360;
+		if (angle % 90 === 0) by[angle / 90] += weight;
+	}
+	const most = by.findIndex((w) => w * 2 > all);
+	return most > 0 ? [
+		90,
+		180,
+		270
+	][most - 1] : 0;
+}
+/**
 * The same runs, placed on the shown page.
 *
 * @param runs The runs as the content stream drew them.
@@ -230,4 +295,4 @@ function placeVectors(vectors, d) {
 	}).filter((v) => shows(d, v.minX, v.minY, v.maxX, v.maxY));
 }
 //#endregion
-export { displayOf, placeImages, placeRuns, placeVectors };
+export { displayOf, placeImages, placeRuns, placeVectors, textFrameOf, wordsTurnOf };

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

@@ -183,7 +183,7 @@ var PdfFile = class PdfFile {
 			}
 			return;
 		}
-		const media = mediaBox ?? DEFAULT_MEDIA_BOX;
+		const media = mediaBox !== void 0 && hasArea(mediaBox) ? mediaBox : DEFAULT_MEDIA_BOX;
 		out.push({
 			dict: node,
 			mediaBox: media,
@@ -556,6 +556,10 @@ function lastIndexOfAscii(buf, needle) {
 * bug1844576.pdf is 612×792 of paper cropped to 181×53.75, and read as its
 * media box the form on it arrived a fifth of the way down a letter page.
 */
+/** Whether a rectangle bounds anything: a point or a line is no page. */
+function hasArea([x0, y0, x1, y1]) {
+	return Math.abs(x1 - x0) > 1 && Math.abs(y1 - y0) > 1;
+}
 function shownBox(media, crop) {
 	if (!crop) return media;
 	const [mx0, my0, mx1, my1] = media;

package/dist/esm/pdf-reader/embedded-fonts.d.ts

@@ -62,7 +62,8 @@ export declare function hasLiftableProgram(file: PdfFile, fontDict: PdfDict): bo
 /**
  * The style a font's embedded program states for itself — the `head` table's
  * macStyle, bit 0 bold and bit 1 italic — where the file carries a TrueType
- * program to read it from.
+ * program to read it from, and the weight a Type 1 program names (see
+ * {@link typeOneStyle}).
  *
  * @param file     The document.
  * @param fontDict The font dictionary.

package/dist/esm/pdf-reader/embedded-fonts.js

@@ -119,7 +119,8 @@ function hasLiftableProgram(file, fontDict) {
 /**
 * The style a font's embedded program states for itself — the `head` table's
 * macStyle, bit 0 bold and bit 1 italic — where the file carries a TrueType
-* program to read it from.
+* program to read it from, and the weight a Type 1 program names (see
+* {@link typeOneStyle}).
 *
 * @param file     The document.
 * @param fontDict The font dictionary.
@@ -128,7 +129,8 @@ function hasLiftableProgram(file, fontDict) {
 */
 function programStyle(file, fontDict) {
 	const program = fontProgram(file, fontDict);
-	if (!program || program.length < 12) return void 0;
+	if (!program) return typeOneStyle(file, fontDict);
+	if (program.length < 12) return void 0;
 	const view = new DataView(program.buffer, program.byteOffset, program.byteLength);
 	const tables = view.getUint16(4);
 	for (let i = 0; i < tables; i++) {
@@ -144,6 +146,34 @@ function programStyle(file, fontDict) {
 		};
 	}
 }
+/**
+* §9.9 `/FontFile` — the weight a Type 1 program names in its `FontInfo`
+* (`/Weight (Bold)`), read off the cleartext that opens it. pdfTeX states no
+* weight in the descriptor, and names URW's bold Times "NimbusRomNo9L-Medi",
+* which no rule of names reads as bold: comments.pdf's headings and captions
+* came back in the body's weight. Its program says "Bold"; Computer Modern's
+* say "Medium", which is their book weight.
+*
+* @param file     The document.
+* @param fontDict The font dictionary.
+* @returns The style, or `undefined` where no program names a weight.
+*/
+function typeOneStyle(file, fontDict) {
+	const owner = descendant(file, fontDict) ?? fontDict;
+	const descriptor = file.resolve(owner.get("FontDescriptor") ?? PDF_NULL);
+	if (!(descriptor instanceof Map)) return void 0;
+	const program = file.resolve(descriptor.get("FontFile") ?? PDF_NULL);
+	if (!(program instanceof PdfStream)) return void 0;
+	const bytes = file.streamData(program);
+	const clear = new TextDecoder("latin1").decode(bytes.subarray(0, TYPE_ONE_HEAD));
+	const weight = /\/Weight\s*\(([^)]*)\)/u.exec(clear)?.[1];
+	return weight === void 0 ? void 0 : {
+		bold: /bold|black|heavy|semib|demi/iu.test(weight),
+		italic: false
+	};
+}
+/** How far into a Type 1 program its `FontInfo` stands, at the most. */
+var TYPE_ONE_HEAD = 8192;
 /** §9.9 `/FontFile2` — the TrueType program, off the font or its descendant. */
 function fontProgram(file, fontDict) {
 	const owner = descendant(file, fontDict) ?? fontDict;

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

@@ -1,5 +1,13 @@
 /** One of the base encodings this reader has a table for (Annex D.2). */
 export type BaseEncodingName = 'StandardEncoding' | 'WinAnsiEncoding' | 'MacRomanEncoding';
+/**
+ * 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.
+ */
+export declare function winAnsiLatinName(code: number): string | undefined;
 /**
  * The glyph names of a base encoding, or `undefined` for a name this has no
  * table for — `/MacExpertEncoding`, whose repertory no reader here can set.

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