reamkit 1.30.0 → 1.31.0

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

@@ -0,0 +1,433 @@
+//#region src/pdf-reader/figures.ts
+/** No thicker than this, a path is a line. */
+var THIN_PT = 1.5;
+/**
+* A line longer than this many ems RULES the page: the rule over a caption,
+* the line under a heading, a table's border. A drawing's own strokes are
+* shorter, and a long one inside a drawing — a chart's axis — is taken with
+* the drawing it stands in once that is found.
+*/
+var RULE_EM = 3;
+/** How close, in ems, two paths stand to be parts of one drawing. */
+var JOIN_EM = .5;
+/** The fewest paths a figure is drawn with: a box and a frame are not one. */
+var MIN_PATHS = 6;
+/** Past this share of the sheet, a drawing is the page's ground or frame. */
+var MOST_OF_PAGE = .5;
+/** How far across a figure a line of its words may run and still be a label. */
+var LABEL_FILL = .6;
+/** Past this many lines that run across it, what a drawing holds is prose. */
+var PROSE_LINES = 2;
+/**
+* How far apart, in ems of the text, two parts of one figure may stand. The
+* parts of comments.pdf's Figure 6 stand twenty-six points apart at 9pt.
+*/
+var NEAR_EM = 3;
+/** Type smaller than this share of the text's is a drawing's, not the text's. */
+var SMALL_SHARE = .85;
+/** How much larger than the text a figure's words may be set. */
+var LARGEST_LABEL = 1.2;
+/** How far, in its own ems, small type may stand off a drawing and label it. */
+var CAPTION_EM = 2;
+/** What a glyph mapped to no character reads as (see `UNMAPPED` in ./layout). */
+var UNMAPPED = "�";
+/** Where an annotation's appearance stands in the page's painting order. */
+var ANNOTATION_ORDER = Number.MAX_SAFE_INTEGER;
+/**
+* How many ems of its own type a line of words on a drawing may run before it
+* is a line of prose, however wide the drawing: a label is a word or three.
+*/
+var LABEL_EM = 15;
+/** Past this many paths a page is artwork through and through. */
+var MOST_PATHS = 4e3;
+/**
+* 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.
+*/
+function pageFigures(vectors, images, runs, sheet) {
+	const words = runs.filter((r) => r.text.replaceAll(UNMAPPED, "").trim().length > 0);
+	const traced = runs.filter((r) => r.type3 !== true && tracedRun(r));
+	if (words.length === 0 || vectors.length === 0 || vectors.length > MOST_PATHS) return [];
+	const size = median(words.map((r) => r.fontSizePt).filter((s) => s > 0)) || 10;
+	const gap = size * JOIN_EM;
+	const pageArea = Math.max(1, sheet.width * sheet.height);
+	const huge = (b) => (b.maxX - b.minX) * (b.maxY - b.minY) > pageArea * MOST_OF_PAGE;
+	const thin = (v) => Math.min(v.maxX - v.minX, v.maxY - v.minY) <= THIN_PT;
+	const rule = (v) => thin(v) && Math.max(v.maxX - v.minX, v.maxY - v.minY) > size * RULE_EM;
+	const lettering = words.filter((r) => r.type3 === true).map(inkOf);
+	const letter = (v) => v.glyph === true || lettering.some((b) => (v.minX + v.maxX) / 2 >= b.minX - 1 && (v.minX + v.maxX) / 2 <= b.maxX + 1 && (v.minY + v.maxY) / 2 >= b.minY - 1 && (v.minY + v.maxY) / 2 <= b.maxY + 1);
+	const own = vectors.filter((v) => v.orderKey[0] !== ANNOTATION_ORDER);
+	const seeds = own.filter((v) => !rule(v) && !huge(v) && !letter(v));
+	const parent = seeds.map((_, k) => k);
+	const find = (k) => {
+		while (parent[k] !== k) {
+			parent[k] = parent[parent[k]];
+			k = parent[k];
+		}
+		return k;
+	};
+	const order = seeds.map((_, k) => k).sort((a, b) => seeds[a].minX - seeds[b].minX);
+	for (let i = 0; i < order.length; i++) {
+		const a = seeds[order[i]];
+		for (let j = i + 1; j < order.length; j++) {
+			const b = seeds[order[j]];
+			if (b.minX > a.maxX + gap) break;
+			if (b.minY <= a.maxY + gap && b.maxY >= a.minY - gap) parent[find(order[i])] = find(order[j]);
+		}
+	}
+	const clusters = /* @__PURE__ */ new Map();
+	seeds.forEach((v, k) => {
+		const root = find(k);
+		const members = clusters.get(root);
+		if (members) members.push(v);
+		else clusters.set(root, [v]);
+	});
+	const found = [];
+	const pieces = [];
+	for (const members of clusters.values()) {
+		const box = boxOf(members);
+		if (huge(box)) continue;
+		if (members.length < MIN_PATHS || !(members.some(draws) || barChart(members))) pieces.push({
+			box,
+			vectors: members
+		});
+		else found.push({
+			box,
+			vectors: members
+		});
+	}
+	if (found.length === 0) return [];
+	const near = size * NEAR_EM;
+	const text = words.filter((r) => r.type3 !== true && r.fontSizePt >= size * SMALL_SHARE);
+	const textBetween = (a, b) => {
+		const both = union(a, b);
+		return text.some((r) => {
+			const ink = inkOf(r);
+			return touches(both, ink, 0) && !touches(a, ink, 0) && !touches(b, ink, 0);
+		});
+	};
+	const rules = own.filter(rule);
+	const taken = /* @__PURE__ */ new Set();
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (let i = 0; i < found.length; i++) {
+			for (let j = found.length - 1; j > i; j--) {
+				const [a, b] = [found[i].box, found[j].box];
+				if (!touches(a, b, gap) && !(touches(a, b, near) && !textBetween(a, b))) continue;
+				found[i].vectors.push(...found[j].vectors);
+				found[i].box = union(a, b);
+				found.splice(j, 1);
+				changed = true;
+			}
+			for (let j = pieces.length - 1; j >= 0; j--) {
+				const [a, b] = [found[i].box, pieces[j].box];
+				if (!touches(a, b, gap) && !(touches(a, b, near) && !textBetween(a, b))) continue;
+				found[i].vectors.push(...pieces[j].vectors);
+				found[i].box = union(a, b);
+				pieces.splice(j, 1);
+				changed = true;
+			}
+			for (const r of rules) {
+				if (taken.has(r) || !mostlyWithin(r, found[i].box)) continue;
+				taken.add(r);
+				found[i].vectors.push(r);
+				found[i].box = union(found[i].box, r);
+				changed = true;
+			}
+		}
+	}
+	const figures = [];
+	const labelled = /* @__PURE__ */ new Set();
+	const lettered = /* @__PURE__ */ new Set();
+	for (const f of found) {
+		const free = [...words, ...traced].filter((r) => r.type3 !== true && !labelled.has(r));
+		const labels = free.filter((r) => touches(f.box, inkOf(r), 0));
+		let box = labels.reduce((b, r) => union(b, inkOf(r)), f.box);
+		for (let grown = true; grown;) {
+			grown = false;
+			for (const r of free) {
+				if (labels.includes(r) || r.fontSizePt >= size * SMALL_SHARE) continue;
+				const ink = inkOf(r);
+				if (!touches(box, ink, r.fontSizePt * CAPTION_EM) || ink.minX < box.minX - r.fontSizePt) continue;
+				if (ink.maxX > box.maxX + r.fontSizePt) continue;
+				labels.push(r);
+				box = union(box, ink);
+				grown = true;
+			}
+		}
+		if (labels.length === 0 || runsAcross(labels, box, size)) continue;
+		if (labels.some((r) => r.fontSizePt > size * LARGEST_LABEL)) continue;
+		const spaces = runs.filter((r) => r.text.trim().length === 0 && r.text.length > 0 && touches(box, inkOf(r), 0));
+		for (const r of [...labels, ...spaces]) labelled.add(r);
+		const held = images.filter((img) => mostlyInside(img, box));
+		const letters = lettersOf(labels.filter(tracedRun), vectors).filter((v) => !lettered.has(v));
+		for (const v of letters) lettered.add(v);
+		figures.push({
+			...box,
+			vectors: [...f.vectors, ...letters],
+			images: held,
+			labels: [...labels, ...spaces]
+		});
+	}
+	return figures.sort((a, b) => b.maxY - a.maxY);
+}
+/**
+* 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.
+*/
+function tracedRun(run) {
+	return run.text.includes(UNMAPPED) && run.text.replaceAll(UNMAPPED, "").trim() === "";
+}
+/**
+* The glyphs traced for some runs: the paths traced as glyphs whose middles
+* stand in the runs' ink.
+*
+* @param runs  The traced runs.
+* @param paths The page's paths.
+*/
+function lettersOf(runs, paths) {
+	const inks = runs.map(inkOf);
+	return paths.filter((v) => {
+		if (v.glyph !== true) return false;
+		const x = (v.minX + v.maxX) / 2;
+		const y = (v.minY + v.maxY) / 2;
+		return inks.some((b) => x >= b.minX - 1 && x <= b.maxX + 1 && y >= b.minY - 1 && y <= b.maxY + 1);
+	});
+}
+/**
+* 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.
+*/
+function joinLetters(paths) {
+	const out = [];
+	let letters = [];
+	const flush = () => {
+		const [first, ...rest] = letters;
+		if (first !== void 0) out.push(rest.length === 0 ? first : {
+			...first,
+			...boxOf(letters),
+			segs: letters.flatMap((v) => v.segs)
+		});
+		letters = [];
+	};
+	for (const v of paths) {
+		const last = letters[letters.length - 1];
+		if (last !== void 0 && (!v.glyph || last.fillHex !== v.fillHex || last.alpha !== v.alpha)) flush();
+		if (v.glyph === true) letters.push(v);
+		else out.push(v);
+	}
+	flush();
+	return out;
+}
+/** Whether a path draws: a curve, or a line that is neither level nor upright. */
+function draws(v) {
+	let x = 0;
+	let y = 0;
+	for (const s of v.segs) {
+		if (s.op === "cubic") return true;
+		if (s.op === "line" && Math.abs(s.x - x) > THIN_PT && Math.abs(s.y - y) > THIN_PT) return true;
+		if (s.op !== "close") {
+			x = s.x;
+			y = s.y;
+		}
+	}
+	return false;
+}
+/**
+* Whether paths draw a BAR CHART: filled rectangles, six and more, standing on
+* one line and as long as each other's figures make them — the one drawing
+* made of nothing but straight lines and boxes that a ruling is not. A
+* table's shading stands its boxes on one line too, but each as long as the
+* last.
+*
+* comments.pdf sets Figures 10 and 12 so, bars of gradient and of flat grey.
+* With no curve among them they were taken for a ruling: their labels were
+* read as lines of the text, Figure 12 and the column beside it came back as
+* one table, and Figure 10's caption, the first line left on its page, set
+* the page's top margin 352 points down.
+*
+* @param paths The paths of one cluster.
+*/
+function barChart(paths) {
+	const bars = paths.filter((v) => v.fillHex !== void 0 || v.gradient !== void 0).flatMap(rectanglesOf);
+	const standing = (base, length) => {
+		const lengths = /* @__PURE__ */ new Map();
+		for (const b of bars) {
+			const at = Math.round(base(b) / BAR_LINE_PT);
+			const long = length(b);
+			if (long > THIN_PT) lengths.set(at, [...lengths.get(at) ?? [], long]);
+		}
+		return [...lengths.values()].some((all) => all.length >= MIN_PATHS && Math.max(...all) >= Math.min(...all) * BAR_SPREAD);
+	};
+	return standing((b) => b.minY, (b) => b.maxY - b.minY) || standing((b) => b.minX, (b) => b.maxX - b.minX);
+}
+/** How near, in points, bars' feet stand to stand on one line. */
+var BAR_LINE_PT = .5;
+/** How much longer the longest bar of a chart is than the shortest, at the least. */
+var BAR_SPREAD = 2;
+/** The upright rectangles a path is drawn with, one per subpath that is one. */
+function rectanglesOf(v) {
+	const out = [];
+	let corners = [];
+	let curved = false;
+	const close = () => {
+		const xs = new Set(corners.map((c) => Math.round(c.x * 10)));
+		const ys = new Set(corners.map((c) => Math.round(c.y * 10)));
+		if (!curved && corners.length >= 4 && corners.length <= 5 && xs.size === 2 && ys.size === 2) out.push({
+			minX: Math.min(...corners.map((c) => c.x)),
+			maxX: Math.max(...corners.map((c) => c.x)),
+			minY: Math.min(...corners.map((c) => c.y)),
+			maxY: Math.max(...corners.map((c) => c.y))
+		});
+		corners = [];
+		curved = false;
+	};
+	for (const s of v.segs) if (s.op === "move") {
+		close();
+		corners.push({
+			x: s.x,
+			y: s.y
+		});
+	} else if (s.op === "line") corners.push({
+		x: s.x,
+		y: s.y
+	});
+	else if (s.op === "cubic") curved = true;
+	close();
+	return out;
+}
+/**
+* Whether the words on a drawing are prose: lines that run across most of it,
+* more than a caption's worth. A label is short, a paragraph set on a ground
+* fills it.
+*
+* A line is its words as far as the next gap wider than an em. Two boxes side
+* by side put their labels on one baseline — comments.pdf's "Record" and
+* "Enter" a hundred and twenty points apart — and taken as one line they ran
+* across the figure like a line of its text.
+*/
+function runsAcross(labels, box, size) {
+	const byLine = [];
+	for (const r of labels) {
+		const line = byLine.find((l) => Math.abs(l.y - r.y) <= size * .3);
+		if (line) {
+			line.inks.push(inkOf(r));
+			line.em = Math.max(line.em, r.fontSizePt);
+		} else byLine.push({
+			y: r.y,
+			em: r.fontSizePt,
+			inks: [inkOf(r)]
+		});
+	}
+	const width = box.maxX - box.minX;
+	let across = 0;
+	for (const { em, inks } of byLine) {
+		inks.sort((a, b) => a.minX - b.minX);
+		let from = inks[0].minX;
+		let to = inks[0].maxX;
+		for (const ink of [...inks.slice(1), void 0]) {
+			if (ink !== void 0 && ink.minX - to <= size) {
+				to = Math.max(to, ink.maxX);
+				continue;
+			}
+			if (to - from >= Math.min(width * LABEL_FILL, em * LABEL_EM)) across++;
+			if (ink !== void 0) {
+				from = ink.minX;
+				to = ink.maxX;
+			}
+		}
+	}
+	return across >= PROSE_LINES;
+}
+/** The box a run's glyphs stand in: a fifth of the size below the baseline, the rest above. */
+function inkOf(r) {
+	const s = r.fontSizePt;
+	if (Math.abs(r.angleDeg ?? 0) < .5) return {
+		minX: Math.min(r.x, r.endX),
+		minY: r.y - s * .2,
+		maxX: Math.max(r.x, r.endX),
+		maxY: r.y + s * .8
+	};
+	return {
+		minX: Math.min(r.x, r.endX) - s * .8,
+		minY: Math.min(r.y, r.endY) - s * .8,
+		maxX: Math.max(r.x, r.endX) + s * .8,
+		maxY: Math.max(r.y, r.endY) + s * .8
+	};
+}
+function boxOf(members) {
+	return members.reduce(union, { ...members[0] });
+}
+function union(a, b) {
+	return {
+		minX: Math.min(a.minX, b.minX),
+		minY: Math.min(a.minY, b.minY),
+		maxX: Math.max(a.maxX, b.maxX),
+		maxY: Math.max(a.maxY, b.maxY)
+	};
+}
+function touches(a, b, slack) {
+	return b.minX <= a.maxX + slack && b.maxX >= a.minX - slack && b.minY <= a.maxY + slack && b.maxY >= a.minY - slack;
+}
+/**
+* Whether a rule lies along a drawing rather than meeting it: across it within
+* a point, and at least half its length inside it. A table's border that ends
+* where a figure begins is not the figure's.
+*/
+function mostlyWithin(r, box) {
+	const across = r.maxX - r.minX >= r.maxY - r.minY;
+	const [from, to, lo, hi] = across ? [
+		r.minX,
+		r.maxX,
+		box.minX,
+		box.maxX
+	] : [
+		r.minY,
+		r.maxY,
+		box.minY,
+		box.maxY
+	];
+	const [side, sideEnd, sideLo, sideHi] = across ? [
+		r.minY,
+		r.maxY,
+		box.minY,
+		box.maxY
+	] : [
+		r.minX,
+		r.maxX,
+		box.minX,
+		box.maxX
+	];
+	if (sideEnd < sideLo - 1 || side > sideHi + 1) return false;
+	return Math.min(to, hi) - Math.max(from, lo) >= (to - from) / 2;
+}
+/** Whether most of a picture lies inside a box. */
+function mostlyInside(img, box) {
+	return Math.max(0, Math.min(img.x + img.widthPt, box.maxX) - Math.max(img.x, box.minX)) * Math.max(0, Math.min(img.y + img.heightPt, box.maxY) - Math.max(img.y, box.minY)) > img.widthPt * img.heightPt / 2;
+}
+function median(values) {
+	if (values.length === 0) return 0;
+	const sorted = [...values].sort((a, b) => a - b);
+	return sorted[Math.floor(sorted.length / 2)];
+}
+//#endregion
+export { joinLetters, pageFigures, tracedRun };

package/dist/esm/pdf-reader/flow-build.d.ts

@@ -1,7 +1,8 @@
-import { BodyElement, ParagraphProperties, Section, SectionProperties, TextOutline } from '../core/document-model/index.js';
-import { FaceFamily, FlowDoc } from '../core/ir/flow.js';
+import { BodyElement, Ligatures, ParagraphProperties, Section, SectionProperties, ShapeBlock, TextOutline } from '../core/document-model/index.js';
+import { FaceFamily, FaceOutlines, FlowDoc } from '../core/ir/flow.js';
 import { FontRegistry } from '../core/font/index.js';
 import { Loss, Pt, ResourceStore } from '../core/ir/index.js';
+import { Display } from './display.js';
 import { PdfImage } from './images.js';
 import { PdfPage } from './document.js';
 import { PdfVector } from './vector.js';
@@ -46,10 +47,18 @@ export declare function paragraphBlock(text: string, outlineLevel?: number): Bod
  * them up to "78110"; in 7-point footnotes the same space is half as wide
  * again as the page's, and pushes their lines over.
  *
+ * A space between two words one text markup marks is marked with them: the
+ * band a highlighter lays runs across the gap. comments.pdf highlights two
+ * lines on its sixth page, and with its spaces left bare the band came back
+ * broken at every word.
+ *
  * @param before The span the space follows, where there is one.
+ * @param after  What follows the space, where anything does.
  * @returns The space.
  */
-export declare function spaceAfter(before: TextSpan | undefined): TextSpan;
+export declare function spaceAfter(before: TextSpan | undefined, after?: {
+    readonly markup?: TextMarkup;
+}): TextSpan;
 export interface TextSpan {
     readonly text: string;
     readonly href?: string;
@@ -73,6 +82,12 @@ export interface TextSpan {
     readonly script?: 'superscript' | 'subscript';
     /** §12.5.6.10 — a text-markup annotation marks these words. */
     readonly markup?: TextMarkup;
+    /**
+     * §17.3.2.43 — the share of their own width the characters are set at: a
+     * word space the page set narrower than the face's own (see `fittedSpace` in
+     * ./layout).
+     */
+    readonly widthScale?: number;
 }
 /**
  * Build a paragraph {@link BodyElement} from positioned {@link TextSpan}s,
@@ -125,6 +140,53 @@ export declare function positionedText(spans: ReadonlyArray<TextSpan>, box: {
     width: number;
     height: number;
 }, frame: PageFrame, zOrder: number, rotation60k?: number): BodyElement;
+/**
+ * One part of a figure (see `./figures`): the shape it is drawn as, and where
+ * its box stands on the page — its left edge and its top, y-up.
+ */
+export interface FigureMember {
+    readonly shape: ShapeBlock;
+    readonly left: number;
+    readonly top: number;
+}
+/** A path of a figure, drawn where the page drew it. */
+export declare function vectorMember(v: PdfVector): FigureMember;
+/**
+ * A picture of a figure: a box filled with it (§20.1.8.14), which is what a
+ * `pic:pic` inside a group is — the shadows comments.pdf lays under each of
+ * its boxes.
+ */
+export declare function imageMember(image: PdfImage, resources: ResourceStore): FigureMember;
+/**
+ * A label of a figure: a line of its words, in a box as wide as they are.
+ * The box never wraps — set in a face a little wider than the page's, one
+ * word would break in two.
+ */
+export declare function labelMember(spans: ReadonlyArray<TextSpan>, box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, rotation60k?: number): FigureMember;
+/** The box a figure's parts stand in, on the page (y-up). */
+export declare function membersBox(members: ReadonlyArray<FigureMember>): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+/**
+ * §20.5.2.17 — a figure as the one drawing it is: a group holding its paths,
+ * its pictures and its labels at their places in it, set in a paragraph of
+ * its own. An inline drawing takes the room it is tall (a line holding
+ * nothing but a picture is the picture's height in Word), so the text after
+ * it follows it, and the figure goes with its paragraph wherever the text
+ * puts that.
+ *
+ * @param members    Its parts, in the order they are painted.
+ * @param properties The paragraph it stands in.
+ */
+export declare function figureBlock(members: ReadonlyArray<FigureMember>, properties: ParagraphProperties): BodyElement;
 /** Collapse losses sharing a `detail` message (the same colour space dropped on many pages). */
 export declare function dedupeLosses(losses: ReadonlyArray<Loss>): Array<Loss>;
 /**
@@ -150,7 +212,36 @@ export declare function shapeBlock(v: PdfVector, frame?: PageFrame, zOrder?: num
  * this single geometry — a known approximation, still far better than a fixed
  * `A4`. Returns `undefined` when there is no usable first-page box.
  */
-export declare function sectionFromPdfPages(pages: ReadonlyArray<PdfPage>): SectionProperties | undefined;
+export declare function sectionFromPdfPages(pages: ReadonlyArray<PdfPage>, display?: Display): SectionProperties | undefined;
+/**
+ * §17.6.20 — a section read in a page's text frame (see `textFrameOf`), set
+ * back on the sheet the page is shown on, its lines running down it (`tbRl`).
+ *
+ * The frame is the sheet turned back a quarter, so its measurements carry
+ * over edge for edge: the frame's left margin is where each line starts, the
+ * sheet's top one; its top margin is where the first line stands, the
+ * sheet's right one.
+ *
+ * @param section The section as the frame measured it.
+ * @param display The geometry its pages were read in.
+ * @returns The section on the sheet, or the section unchanged for a page read
+ *          on its sheet.
+ */
+export declare function sectionOnSheet(section: SectionProperties | undefined, display: Display | undefined): SectionProperties | undefined;
+/**
+ * A mark anchored to a page read in its text frame, set on the SHEET the page
+ * is shown on: where the page drew it, turned with the page.
+ *
+ * Word lays a `tbRl` section's text down the sheet but stands a drawing
+ * anchored to the page at its offsets on the sheet, upright (§17.6.20) — so a
+ * picture the frame placed is carried onto the sheet, and turned a quarter
+ * clockwise as the words around it are.
+ *
+ * @param el         A body element, anchored or not.
+ * @param sheetWidth The sheet's width, which is the frame's height.
+ * @returns The element, anchored on the sheet.
+ */
+export declare function floatOntoSheet(el: BodyElement, sheetWidth: number): BodyElement;
 /** How many lines a sheet must hold before where they end says where its measure does. */
 export declare const MEASURE_LINES = 3;
 /**
@@ -168,6 +259,13 @@ export declare const GUESSED_MARGIN: number;
 export declare const BASELINE_AT = 0.8;
 /** A line's box where no pitch was measured: the ordinary single spacing, in ems. */
 export declare const NATURAL_LINE_EM = 1.2;
+/**
+ * How far above its baseline the first line's BOX reaches, as a fraction of the
+ * size — which is what the top margin has to leave room for. The lines are set
+ * in exact boxes (see `groupIntoParagraphs`), so this is where the box's top
+ * stands, not where a face's ascender happens to.
+ */
+export declare const ASCENDER: number;
 /**
  * The size a document's text is set in: the middle of every size its runs
  * carry.
@@ -223,6 +321,34 @@ export declare function withMeasuredMargins(section: SectionProperties | undefin
     widthPt: number;
     heightPt: number;
 }>>, foot?: ReadonlyArray<TextRun>): SectionProperties | undefined;
+/** What a face's runs ask of a word processor to be set as the page set them. */
+export interface Typesetting {
+    /** §17.3.2.19 — kerned from this size up. */
+    readonly kerningMinPt?: Pt;
+    /** [MS-DOCX] `w14:ligatures` — set with these ligatures. */
+    readonly ligatures?: Ligatures;
+}
+/**
+ * The runs set in a face the page KERNED or LIGATED, marked so (see
+ * `pageSpacing`, `FaceOutlines.ligatures`): a word processor kerns nothing a
+ * run does not ask it to, and set unkerned, a line kerned on the page runs
+ * longer than it did there; a ligature the embedded face carries is formed
+ * where the run asks for its face's ligatures.
+ *
+ * @param blocks   The blocks to mark, tables and text boxes within them too.
+ * @param typeset  Run font name → what its runs ask for.
+ * @returns The blocks, their runs in those faces asking for it.
+ */
+export declare function typesetRuns(blocks: ReadonlyArray<BodyElement>, typeset: ReadonlyMap<string, Typesetting>): Array<BodyElement>;
+/**
+ * What each face's runs ask for: kerning where the page kerned the face, and
+ * its standard ligatures where the page drew one of them (the ligatures the
+ * face's embedded font then forms are exactly the ones the page drew).
+ *
+ * @param kerned       The run font names of the faces the page kerned.
+ * @param faceOutlines Run font name → the face's outlines, ligatures among them.
+ */
+export declare function typesetting(kerned: ReadonlySet<string>, faceOutlines: ReadonlyMap<string, FaceOutlines> | undefined): Map<string, Typesetting>;
 /**
  * Assemble the final {@link FlowDoc} for a reconstruction: the body elements
  * with their styles resolved against the empty style sheet, the lifted-image
@@ -230,4 +356,4 @@ export declare function withMeasuredMargins(section: SectionProperties | undefin
  * both reconstruction paths (the tagged fast-path EP3 and the heuristic layout
  * path EP4).
  */
-export declare function buildFlowDoc(body: ReadonlyArray<BodyElement>, resources?: ResourceStore, section?: SectionProperties, embeddedFonts?: ReadonlyMap<string, FontRegistry>, sections?: ReadonlyArray<Section>, headersFooters?: ReadonlyMap<string, ReadonlyArray<BodyElement>>, faceFamilies?: ReadonlyMap<string, FaceFamily>): FlowDoc;
+export declare function buildFlowDoc(body: ReadonlyArray<BodyElement>, resources?: ResourceStore, section?: SectionProperties, embeddedFonts?: ReadonlyMap<string, FontRegistry>, sections?: ReadonlyArray<Section>, headersFooters?: ReadonlyMap<string, ReadonlyArray<BodyElement>>, faceFamilies?: ReadonlyMap<string, FaceFamily>, faceOutlines?: ReadonlyMap<string, FaceOutlines>, kerned?: ReadonlySet<string>): FlowDoc;