reamkit 1.28.0 → 1.30.0

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

@@ -1,6 +1,9 @@
 import { PDF_NULL, PdfHexString, PdfName } from "../pdf/objects.js";
+import { bidiClass } from "../core/bidi/char-types.js";
+import { reorderVisual } from "../core/bidi/algorithm.js";
+import { analyzeString, hasBidiCharacters } from "../core/bidi/index.js";
 import { Lexer } from "./lexer.js";
-import { cmykHex, grayHex, rgbHex, spaceColor } from "./shading.js";
+import { cmykHex, dashLengths, grayHex, rgbHex, spaceColor } from "./shading.js";
 //#region src/pdf-reader/content.ts
 /**
 * A painted path emitted by the path-painting operators (§8.5.3), captured in
@@ -35,6 +38,18 @@ function pathBox(segs) {
 }
 /** The area of a box, for choosing the smaller of two clip regions. */
 var area = (b) => Math.max(0, b.maxX - b.minX) * Math.max(0, b.maxY - b.minY);
+/**
+* §9.10 — whether the font says what character a glyph stands for: text that is
+* neither empty nor the replacement character a reader writes where nothing is
+* stated.
+*
+* @param text What the font's decode gave for the code.
+* @returns Whether a flowing reading can write it as a letter.
+*/
+function statesACharacter(text) {
+	const trimmed = text.trim();
+	return trimmed.length > 0 && !trimmed.includes("�");
+}
 /** The identity {@link Matrix} (no transform). */
 var IDENTITY = [
 	1,
@@ -89,9 +104,13 @@ function initialState() {
 		fillColor: "000000",
 		strokeColor: "000000",
 		lineWidth: 1,
+		dash: [],
+		lineCap: 0,
 		fillGradient: void 0,
 		fillPattern: void 0,
+		fillPatternPaint: void 0,
 		fillAlpha: 1,
+		strokeAlpha: 1,
 		fillDarkens: false,
 		blendMode: void 0,
 		softMask: false,
@@ -217,6 +236,25 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			y
 		});
 	};
+	const currentPoint = () => {
+		for (let i = path.length - 1; i >= 0; i--) {
+			const seg = path[i];
+			if (seg.op === "close") {
+				for (let k = i - 1; k >= 0; k--) {
+					const start = path[k];
+					if (start.op === "move") return {
+						x: start.x,
+						y: start.y
+					};
+				}
+				return;
+			}
+			return {
+				x: seg.x,
+				y: seg.y
+			};
+		}
+	};
 	const rectTo = (x, y, w, h) => {
 		moveTo(x, y);
 		lineTo(x + w, y);
@@ -229,6 +267,11 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 		const scale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])) || 1;
 		return state.lineWidth * scale;
 	};
+	const ctmDash = () => {
+		const m = state.ctm;
+		const scale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])) || 1;
+		return state.dash.map((n) => n * scale);
+	};
 	const paintPath = (fill, stroke) => {
 		if (path.length >= 2 && (fill || stroke) && visible()) {
 			const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
@@ -237,6 +280,7 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				segs: path,
 				...state.clip ? { clip: state.clip } : {},
 				...fill && state.fillPattern !== void 0 ? { patternName: state.fillPattern } : {},
+				...fill && state.fillPattern !== void 0 && state.fillPatternPaint !== void 0 ? { patternPaint: state.fillPatternPaint } : {},
 				...fill ? { fillHex: state.fillColor } : {},
 				...fill && state.fillAlpha < 1 ? { alpha: state.fillAlpha } : {},
 				...fill && state.fillDarkens ? { darkens: true } : {},
@@ -247,6 +291,10 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 					strokeHex: state.strokeColor,
 					lineWidth: ctmLineWidth()
 				} : {},
+				...stroke && state.dash.length > 0 ? { dash: ctmDash() } : {},
+				...stroke && state.lineCap === 1 ? { cap: "round" } : {},
+				...stroke && state.lineCap === 2 ? { cap: "square" } : {},
+				...stroke && state.strokeAlpha < 1 ? { strokeAlpha: state.strokeAlpha } : {},
 				...mcid !== void 0 ? { mcid } : {}
 			});
 		}
@@ -284,7 +332,8 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 					stream,
 					resources: type3.resources,
 					ctm: multiply(type3.matrix, multiply(scale, multiply(tm, state.ctm))),
-					order: paintOrder++
+					order: paintOrder++,
+					readable: statesACharacter(state.font.decode([code]))
 				});
 			}
 		}
@@ -506,6 +555,8 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 				if (named !== void 0) {
 					state.fillGradient = shadings.get(named);
 					state.fillPattern = state.fillGradient ? void 0 : named;
+					const components = operands.filter((o) => typeof o === "number");
+					state.fillPatternPaint = components.length > 0 ? spaceColor(components, void 0) : void 0;
 					break;
 				}
 				const hex = colorOfOperands(operands, state.fillSpace);
@@ -518,7 +569,12 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			}
 			case "SCN":
 			case "SC": {
-				if (operands[operands.length - 1] instanceof PdfName) break;
+				const last = operands[operands.length - 1];
+				if (last instanceof PdfName) {
+					const sweep = shadings.get(last.value);
+					if (sweep) state.strokeColor = midGradient(sweep);
+					break;
+				}
 				const hex = colorOfOperands(operands, state.strokeSpace);
 				if (hex !== void 0) state.strokeColor = hex;
 				break;
@@ -535,6 +591,14 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			case "w":
 				state.lineWidth = num(0);
 				break;
+			case "d":
+				state.dash = dashLengths(operands[0]);
+				break;
+			case "J": {
+				const cap = num(0);
+				if (cap === 0 || cap === 1 || cap === 2) state.lineCap = cap;
+				break;
+			}
 			case "m":
 				moveTo(num(0), num(1));
 				break;
@@ -544,6 +608,26 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 			case "c":
 				curveTo(num(0), num(1), num(2), num(3), num(4), num(5));
 				break;
+			case "v": {
+				const at = currentPoint();
+				if (at) {
+					const [x2, y2] = toPage(num(0), num(1));
+					const [x, y] = toPage(num(2), num(3));
+					path.push({
+						op: "cubic",
+						x1: at.x,
+						y1: at.y,
+						x2,
+						y2,
+						x,
+						y
+					});
+				}
+				break;
+			}
+			case "y":
+				curveTo(num(0), num(1), num(2), num(3), num(2), num(3));
+				break;
 			case "re":
 				rectTo(num(0), num(1), num(2), num(3));
 				break;
@@ -597,6 +681,10 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__
 						state.blendMode = paint.blend;
 					}
 					if (paint.masked !== void 0) state.softMask = paint.masked;
+					if (paint.lineWidth !== void 0) state.lineWidth = paint.lineWidth;
+					if (paint.dash !== void 0) state.dash = paint.dash;
+					if (paint.lineCap !== void 0) state.lineCap = paint.lineCap;
+					if (paint.strokeAlpha !== void 0) state.strokeAlpha = paint.strokeAlpha;
 				}
 				break;
 			}
@@ -700,12 +788,27 @@ function strokesText(mode) {
 * ArabicCIDTrueType.pdf came out mirrored for exactly that reason: the reader
 * passed visual order through and the layout reversed it a second time.
 *
-* A run is reversed only when it is wholly right-to-left. Anything mixed — a
-* number inside an Arabic sentence runs left to right — needs the full bidi
-* algorithm, and guessing at it would be worse than leaving it alone.
+* A run wholly right-to-left is simply reversed. A MIXED one — a full stop or
+* a number inside an Arabic sentence — is put through the bidi algorithm's
+* reordering (UAX #9 L2), which for the runs a line holds undoes itself: the
+* painted order reordered is the reading order. Left alone, a note of
+* freetext_no_appearance.pdf came back with every line that held a full stop
+* reading back to front. The direction it is reordered in is the one most of
+* its letters run in — the painted order says nothing about which comes first.
 */
 function logicalOrder(text) {
-	return isRightToLeft(text) ? [...text].reverse().join("") : text;
+	if (isRightToLeft(text)) return [...text].reverse().join("");
+	if (!hasBidiCharacters(text)) return text;
+	const chars = [...text];
+	let rtl = 0;
+	let strong = 0;
+	for (const ch of chars) {
+		const type = bidiClass(ch.codePointAt(0) ?? 0);
+		if (type === "R" || type === "AL") rtl++;
+		if (type === "R" || type === "AL" || type === "L") strong++;
+	}
+	const { levels } = analyzeString(text, rtl * 2 >= strong ? "rtl" : "ltr");
+	return reorderVisual(levels).map((i) => chars[i] ?? "").join("");
 }
 /**
 * Whether a string is wholly right-to-left: at least one letter of an RTL
@@ -824,8 +927,8 @@ function readValue(lexer) {
 * The bytes are binary and may hold `EI` themselves, so the end is found by
 * MEASURING where the dictionary says how much there is — an unfiltered image
 * is exactly `ceil(W · BPC · components / 8) · H` bytes — and only searched for
-* where a filter makes the length unknowable. images_1bit_grayscale.pdf draws
-* two of them and both were skipped over.
+* where a filter makes the length unknowable (see {@link filteredEnd}).
+* images_1bit_grayscale.pdf draws two of them and both were skipped over.
 */
 function readInlineImage(lexer) {
 	const dict = /* @__PURE__ */ new Map();
@@ -835,24 +938,86 @@ function readInlineImage(lexer) {
 		if (tok.kind === "keyword" && tok.value === "ID") break;
 		if (tok.kind === "name") dict.set(tok.value, readValue(lexer));
 	}
-	const start = lexer.pos + 1;
 	const measured = inlineLength(dict);
+	const crlf = lexer.byteAt(lexer.pos) === 13 && lexer.byteAt(lexer.pos + 1) === 10;
+	const start = lexer.pos + (crlf && measured === void 0 ? 2 : 1);
 	let end = measured !== void 0 ? start + measured : -1;
 	if (end < 0 || end > lexer.length) {
-		end = lexer.indexOfAscii("EI", start);
+		end = filteredEnd(lexer, start, dict);
 		if (end < 0) {
 			lexer.pos = lexer.length;
 			return;
 		}
 	}
 	const data = lexer.slice(start, Math.min(end, lexer.length));
-	const ei = lexer.indexOfAscii("EI", end);
+	const ei = lexer.indexOfKeyword("EI", end);
 	lexer.pos = ei < 0 ? lexer.length : ei + 2;
 	return {
 		dict,
 		data
 	};
 }
+/**
+* §8.9.7 — where a FILTERED inline image's bytes end, which the dictionary
+* cannot say.
+*
+* Searched for as the first two bytes `EI`, the end fell inside the picture
+* wherever its own bytes spelled them: a JPEG is dense with them, and
+* bug1065245.pdf's three banners were each cut off a few hundred bytes in,
+* would not decode, and were dropped — a blank sheet. So the data is read to
+* where its OWN encoding ends: a JPEG at its end-of-image marker, hex text at
+* `>`, base-85 at `~>`. Anything else ends at the first `EI` standing as a
+* word of its own.
+*/
+function filteredEnd(lexer, start, dict) {
+	const f = dict.get("F") ?? dict.get("Filter");
+	const first = Array.isArray(f) ? f[0] : f;
+	const filter = first instanceof PdfName ? first.value : "";
+	if (filter === "DCT" || filter === "DCTDecode") {
+		const eoi = jpegEnd(lexer, start);
+		if (eoi !== void 0) return eoi;
+	} else if (filter === "AHx" || filter === "ASCIIHexDecode") {
+		const gt = lexer.indexOfAscii(">", start);
+		if (gt >= 0) return gt + 1;
+	} else if (filter === "A85" || filter === "ASCII85Decode") {
+		const tilde = lexer.indexOfAscii("~>", start);
+		if (tilde >= 0) return tilde + 2;
+	}
+	return lexer.indexOfKeyword("EI", start);
+}
+/**
+* Where a JPEG that starts at `start` ends: past its end-of-image marker,
+* found by walking its segments — a length-prefixed marker segment is stepped
+* over whole, and the coded data after a start-of-scan is read to the next
+* marker, where `FF` stands before anything but a stuffed `00` or a restart.
+*/
+function jpegEnd(lexer, start) {
+	if (lexer.byteAt(start) !== 255 || lexer.byteAt(start + 1) !== 216) return void 0;
+	let i = start + 2;
+	for (;;) {
+		if (lexer.byteAt(i) !== 255) return void 0;
+		let marker = lexer.byteAt(i + 1);
+		while (marker === 255) marker = lexer.byteAt(++i + 1);
+		if (marker < 0) return void 0;
+		if (marker === 217) return i + 2;
+		if (marker >= 208 && marker <= 215 || marker === 1) {
+			i += 2;
+			continue;
+		}
+		const hi = lexer.byteAt(i + 2);
+		const lo = lexer.byteAt(i + 3);
+		if (hi < 0 || lo < 0 || (hi << 8) + lo < 2) return void 0;
+		i += 2 + (hi << 8) + lo;
+		if (marker !== 218) continue;
+		for (;;) {
+			const b = lexer.byteAt(i);
+			if (b < 0) return void 0;
+			const next = lexer.byteAt(i + 1);
+			if (b === 255 && next !== 0 && !(next >= 208 && next <= 215)) break;
+			i++;
+		}
+	}
+}
 /** How many bytes an UNFILTERED inline image's samples take, if that is known. */
 function inlineLength(dict) {
 	if (dict.has("F") || dict.has("Filter")) return void 0;

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

@@ -199,12 +199,28 @@ function placeVectors(vectors, d) {
 			ys.push(s.y);
 			if (s.op === "cubic") xs.push(s.x1, s.x2), ys.push(s.y1, s.y2);
 		}
+		const g = v.gradient;
+		const moved = g?.axis !== void 0 ? { gradient: {
+			...g,
+			axis: ((a) => {
+				const p0 = d.place(a.x0, a.y0);
+				const p1 = d.place(a.x1, a.y1);
+				return {
+					x0: p0.x,
+					y0: p0.y,
+					x1: p1.x,
+					y1: p1.y
+				};
+			})(g.axis)
+		} } : {};
 		if (xs.length === 0) return {
 			...v,
+			...moved,
 			segs
 		};
 		return {
 			...v,
+			...moved,
 			segs,
 			minX: Math.min(...xs),
 			minY: Math.min(...ys),

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

@@ -110,6 +110,14 @@ export declare class PdfFile {
  * reader takes one from whoever needs it:
  *
  * ```ts
+ * // browser: any wasm/JS decoder you ship — brotli-dec-wasm is ~200 KB
+ * import brotliPromise from 'brotli-dec-wasm';
+ * const brotli = await brotliPromise;
+ * Ream.parse(pdf, { filters: { BrotliDecode: (b) => brotli.decompress(b) } });
+ * ```
+ *
+ * ```ts
+ * // node, where the runtime already carries one
  * import { brotliDecompressSync } from 'node:zlib';
  * Ream.parse(pdf, { filters: { BrotliDecode: (b) => brotliDecompressSync(b) } });
  * ```

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

@@ -29,6 +29,16 @@ import { FontRegistry } from '../core/font/index.js';
  * @returns Name → a one-face registry holding that program.
  */
 export declare function collectEmbeddedFonts(file: PdfFile, pages: ReadonlyArray<PdfPage>, losses?: Array<Loss>): Map<string, FontRegistry>;
+/**
+ * Every `/Font` dictionary the pages draw with, each once: the page's own
+ * resources and those of every form it paints (§8.8 — a drawing keeps most of
+ * its lettering inside them).
+ *
+ * @param file  The owning file.
+ * @param pages The pages whose fonts are wanted.
+ * @param visit Called once per font dictionary.
+ */
+export declare function eachPageFont(file: PdfFile, pages: ReadonlyArray<PdfPage>, visit: (fontDict: PdfDict) => void): void;
 /**
  * The name a run set in `fontDict` will ask for: its `/BaseFont` without the
  * six-capital subset prefix (§9.6.4), lowercased.
@@ -49,3 +59,17 @@ export declare function embeddedFontName(file: PdfFile, fontDict: PdfDict): stri
  * @param fontDict The font dictionary.
  */
 export declare function hasLiftableProgram(file: PdfFile, fontDict: PdfDict): boolean;
+/**
+ * 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.
+ *
+ * @param file     The document.
+ * @param fontDict The font dictionary.
+ * @returns The program's own style, or `undefined` where there is no program
+ *          or it has no header.
+ */
+export declare function programStyle(file: PdfFile, fontDict: PdfDict): {
+    bold: boolean;
+    italic: boolean;
+} | undefined;

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

@@ -32,11 +32,7 @@ var MAX_FORM_DEPTH = 8;
 */
 function collectEmbeddedFonts(file, pages, losses) {
 	const out = /* @__PURE__ */ new Map();
-	const seen = /* @__PURE__ */ new Set();
-	const visiting = /* @__PURE__ */ new Set();
-	const addFont = (fontDict) => {
-		if (seen.has(fontDict)) return;
-		seen.add(fontDict);
+	eachPageFont(file, pages, (fontDict) => {
 		const name = embeddedFontName(file, fontDict);
 		if (name === void 0 || out.has(name)) return;
 		const program = fontProgram(file, fontDict);
@@ -53,13 +49,29 @@ function collectEmbeddedFonts(file, pages, losses) {
 			}
 			out.set(name, FontRegistry.fromBytes({ regular: program }));
 		} catch {}
-	};
+	});
+	return out;
+}
+/**
+* Every `/Font` dictionary the pages draw with, each once: the page's own
+* resources and those of every form it paints (§8.8 — a drawing keeps most of
+* its lettering inside them).
+*
+* @param file  The owning file.
+* @param pages The pages whose fonts are wanted.
+* @param visit Called once per font dictionary.
+*/
+function eachPageFont(file, pages, visit) {
+	const seen = /* @__PURE__ */ new Set();
+	const visiting = /* @__PURE__ */ new Set();
 	const walk = (resources, depth) => {
 		if (!resources) return;
 		const fonts = file.get(resources, "Font");
 		if (fonts instanceof Map) for (const value of fonts.values()) {
 			const dict = file.resolve(value);
-			if (dict instanceof Map) addFont(dict);
+			if (!(dict instanceof Map) || seen.has(dict)) continue;
+			seen.add(dict);
+			visit(dict);
 		}
 		if (depth >= MAX_FORM_DEPTH) return;
 		const xobjects = file.get(resources, "XObject");
@@ -76,7 +88,6 @@ function collectEmbeddedFonts(file, pages, losses) {
 		}
 	};
 	for (const page of pages) walk(page.resources, 0);
-	return out;
 }
 /**
 * The name a run set in `fontDict` will ask for: its `/BaseFont` without the
@@ -105,6 +116,34 @@ function embeddedFontName(file, fontDict) {
 function hasLiftableProgram(file, fontDict) {
 	return fontProgram(file, fontDict) !== void 0;
 }
+/**
+* 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.
+*
+* @param file     The document.
+* @param fontDict The font dictionary.
+* @returns The program's own style, or `undefined` where there is no program
+*          or it has no header.
+*/
+function programStyle(file, fontDict) {
+	const program = fontProgram(file, fontDict);
+	if (!program || 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++) {
+		const at = 12 + i * 16;
+		if (at + 16 > program.length) return void 0;
+		if (String.fromCharCode(...program.subarray(at, at + 4)) !== "head") continue;
+		const offset = view.getUint32(at + 8);
+		if (offset + 46 > program.length) return void 0;
+		const macStyle = view.getUint16(offset + 44);
+		return {
+			bold: (macStyle & 1) !== 0,
+			italic: (macStyle & 2) !== 0
+		};
+	}
+}
 /** §9.9 `/FontFile2` — the TrueType program, off the font or its descendant. */
 function fontProgram(file, fontDict) {
 	const owner = descendant(file, fontDict) ?? fontDict;
@@ -123,4 +162,4 @@ function descendant(file, fontDict) {
 	return first instanceof Map ? first : void 0;
 }
 //#endregion
-export { collectEmbeddedFonts, embeddedFontName, hasLiftableProgram };
+export { collectEmbeddedFonts, eachPageFont, embeddedFontName, hasLiftableProgram, programStyle };

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

@@ -1,7 +1,7 @@
 import { BodyElement, ParagraphProperties, Section, SectionProperties, TextOutline } from '../core/document-model/index.js';
-import { FlowDoc } from '../core/ir/flow.js';
+import { FaceFamily, FlowDoc } from '../core/ir/flow.js';
 import { FontRegistry } from '../core/font/index.js';
-import { Loss, ResourceStore } from '../core/ir/index.js';
+import { Loss, Pt, ResourceStore } from '../core/ir/index.js';
 import { PdfImage } from './images.js';
 import { PdfPage } from './document.js';
 import { PdfVector } from './vector.js';
@@ -36,6 +36,20 @@ export interface PageFrame {
  */
 export declare function paragraphBlock(text: string, outlineLevel?: number): BodyElement;
 /** One piece of reconstructed text, carrying any hyperlink (E-PDF EP8). */
+/**
+ * The space set between a span and what follows it, in the span's own size and
+ * face: a word space is as wide as the type it stands in.
+ *
+ * Written bare, the space took the document's default size, whatever the words
+ * around it were set at: issue10665_reduced.pdf sets "78" and "110" twenty
+ * points apart in 60-point type, and the eleven-point space between them closed
+ * 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.
+ *
+ * @param before The span the space follows, where there is one.
+ * @returns The space.
+ */
+export declare function spaceAfter(before: TextSpan | undefined): TextSpan;
 export interface TextSpan {
     readonly text: string;
     readonly href?: string;
@@ -66,7 +80,21 @@ export interface TextSpan {
  * survives as its own run) and squashing whitespace. With no hrefs this
  * collapses to a single run — the same shape {@link paragraphBlock} produces.
  */
-export declare function paragraphFromRuns(spans: ReadonlyArray<TextSpan>, outlineLevel?: number, placement?: Pick<ParagraphProperties, 'alignment' | 'spacingBefore' | 'indentLeft' | 'indentFirstLine'>): BodyElement;
+export declare function paragraphFromRuns(spans: ReadonlyArray<TextSpan>, outlineLevel?: number, placement?: Pick<ParagraphProperties, 'alignment' | 'spacingBefore' | 'spacingLine' | 'spacingLineRule' | 'indentLeft' | 'indentRight' | 'indentFirstLine' | 'tabs'>): BodyElement;
+/**
+ * The height of a line that carries nothing to read: one twip, the least
+ * §17.3.1.33 can state. Zero is not a height a writer states at all — it is
+ * read as "no line spacing given", and the reader's single spacing comes back.
+ */
+export declare const CARRIER_LINE_PT: Pt;
+/**
+ * §17.3.1.33 — the paragraph a floating mark is anchored in, which takes no
+ * room: the mark stands where the page drew it and the line carrying it is on
+ * no page. Left at a reader's single spacing, every rule and fill an invoice
+ * draws was a blank line in the flow, and the text under it moved down a line
+ * for each.
+ */
+export declare const FLOAT_CARRIER: ParagraphProperties;
 /**
  * Store a {@link PdfImage}'s bytes (content-addressed dedup) and build the image
  * {@link BodyElement} that references them, sized in points from the placement
@@ -123,10 +151,78 @@ export declare function shapeBlock(v: PdfVector, frame?: PageFrame, zOrder?: num
  * `A4`. Returns `undefined` when there is no usable first-page box.
  */
 export declare function sectionFromPdfPages(pages: ReadonlyArray<PdfPage>): SectionProperties | undefined;
+/** How many lines a sheet must hold before where they end says where its measure does. */
+export declare const MEASURE_LINES = 3;
+/**
+ * How far in, as a share of the sheet, a right margin the lines do not show
+ * may come: what a sheet of a line or two is re-set across is at least the
+ * rest of it.
+ */
+export declare const GUESSED_MARGIN: number;
+/**
+ * §17.3.1.33 — where the baseline of an EXACT line stands in its box, from the
+ * top. LibreOffice puts it at four fifths of the height; Word at the height
+ * less the face's descent, which for the faces documents use is within a tenth
+ * of a line of the same place.
+ */
+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;
+/**
+ * The size a document's text is set in: the middle of every size its runs
+ * carry.
+ *
+ * @param pageRuns Each page's runs.
+ * @returns The size, in points; 0 where no run states one.
+ */
+export declare function textSizeOf(pageRuns: ReadonlyArray<ReadonlyArray<TextRun>>): number;
+/**
+ * Whether a run is set too small to be read, beside the text of its document —
+ * a mark the producer leaves on the sheet, not a line of the page.
+ *
+ * TCPDF signs the last page of everything it makes "Powered by TCPDF
+ * (www.tcpdf.org)" in type one point high, three points from the corner of the
+ * paper. Taken for text it was the leftmost and the lowest thing on the page:
+ * the margins came in at the edge of the sheet and every line of basicapi.pdf
+ * and alphatrans.pdf was set against it.
+ *
+ * @param run      The run.
+ * @param textSize The size the document's text is set in (see {@link textSizeOf}).
+ * @returns `true` where the run is a mark rather than text.
+ */
+export declare function tooSmallToRead(run: TextRun, textSize: number): boolean;
+/**
+ * The margins the SOURCE used, measured off where its words actually sit.
+ *
+ * A PDF states none — text is placed anywhere on the MediaBox — so the reader
+ * used to leave them at zero rather than invent an inch. But the words
+ * themselves say where the margin was: the leftmost glyph on the page is the
+ * left margin, and reflowing inside it keeps the measure the author set instead
+ * of running the text from edge to edge.
+ *
+ * Measured on the MEDIAN page rather than the extreme one, so a single full-
+ * bleed rule or a page number in the corner does not collapse the margin for
+ * the whole document, and clamped so a strange page cannot leave no text area
+ * at all.
+ *
+ * @param section  The section the page box gave, or `undefined`.
+ * @param shown    Each page as it is shown, for its own width and height.
+ * @param pageRuns Each page's runs, already placed on the shown page.
+ * @param pageMarks Each page's pictures, which the measure has to hold.
+ * @param foot     The running foot lifted off the pages, as the first page
+ *                 showed it — the band the text block stands above.
+ * @returns The section with measured margins, or `section` when nothing is
+ *          measurable.
+ */
 export declare function withMeasuredMargins(section: SectionProperties | undefined, shown: ReadonlyArray<{
     width: number;
     height: number;
-}>, pageRuns: ReadonlyArray<ReadonlyArray<TextRun>>): SectionProperties | undefined;
+}>, pageRuns: ReadonlyArray<ReadonlyArray<TextRun>>, pageMarks?: ReadonlyArray<ReadonlyArray<{
+    x: number;
+    y: number;
+    widthPt: number;
+    heightPt: number;
+}>>, foot?: ReadonlyArray<TextRun>): SectionProperties | undefined;
 /**
  * Assemble the final {@link FlowDoc} for a reconstruction: the body elements
  * with their styles resolved against the empty style sheet, the lifted-image
@@ -134,4 +230,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>>): 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>): FlowDoc;