reamkit 1.29.0 → 1.30.0

package/dist/esm/pdf-reader/flow-build.js

@@ -2,6 +2,7 @@ import { pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
 import { EMPTY_STYLE_SHEET, resolveBodyStyles } from "../core/style-cascade/resolver.js";
 import "../core/style-cascade/index.js";
+import { gradientOverBox } from "./shading.js";
 import { displayOf } from "./display.js";
 //#region src/pdf-reader/flow-build.ts
 /**
@@ -21,6 +22,27 @@ function paragraphBlock(text, outlineLevel) {
 		}
 	};
 }
+/** 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.
+*/
+function spaceAfter(before) {
+	return {
+		text: " ",
+		...before?.sizePt !== void 0 ? { sizePt: before.sizePt } : {},
+		...before?.fontName !== void 0 ? { fontName: before.fontName } : {}
+	};
+}
 /**
 * Build a paragraph {@link BodyElement} from positioned {@link TextSpan}s,
 * coalescing consecutive spans that share an `href` into one run (so a link
@@ -65,7 +87,10 @@ function paragraphFromRuns(spans, outlineLevel, placement) {
 				properties: {
 					...r.sizePt !== void 0 ? { fontSizePt: pt(r.sizePt) } : {},
 					...r.colorHex !== void 0 ? { colorHex: r.colorHex } : {},
-					...r.fontName !== void 0 ? { fontFamily: { ascii: r.fontName } } : {},
+					...r.fontName !== void 0 ? { fontFamily: {
+						ascii: r.fontName,
+						hAnsi: r.fontName
+					} } : {},
 					...r.outline !== void 0 ? { textOutline: r.outline } : {},
 					...r.bold ? { bold: true } : {},
 					...r.italic ? { italic: true } : {},
@@ -85,6 +110,23 @@ function sameMarkup(a, b) {
 	return a?.highlightHex === b?.highlightHex && a?.underline === b?.underline && a?.underlineHex === b?.underlineHex && a?.strike === b?.strike;
 }
 /**
+* 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.
+*/
+var CARRIER_LINE_PT = pt(.05);
+/**
+* §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.
+*/
+var FLOAT_CARRIER = {
+	spacingLine: CARRIER_LINE_PT,
+	spacingLineRule: "exact"
+};
+/**
 * Store a {@link PdfImage}'s bytes (content-addressed dedup) and build the image
 * {@link BodyElement} that references them, sized in points from the placement
 * CTM. `alt` becomes the block's alt text when given.
@@ -112,9 +154,10 @@ function imageBlock(image, resources, alt, frame, zOrder, behind = false) {
 			width: pt(image.widthPt),
 			height: pt(image.heightPt),
 			...image.rotationDeg !== void 0 ? { rotation60k: Math.round(-image.rotationDeg * 6e4) } : {},
+			...image.flipV === true ? { flipV: true } : {},
 			...image.crop ? { crop: image.crop } : {},
 			...image.alpha !== void 0 ? { alpha: image.alpha } : {},
-			paragraphProperties: {},
+			paragraphProperties: float ? FLOAT_CARRIER : {},
 			...alt ? { altText: alt } : {}
 		}
 	};
@@ -138,7 +181,10 @@ function imageBlock(image, resources, alt, frame, zOrder, behind = false) {
 * @returns A shape carrying the text, anchored where the glyphs were.
 */
 function positionedText(spans, box, frame, zOrder, rotation60k) {
-	const paragraph = paragraphFromRuns(spans);
+	const paragraph = paragraphFromRuns(spans, void 0, {
+		spacingLine: pt(Math.max(1, box.height)),
+		spacingLineRule: "exact"
+	});
 	return {
 		kind: "shape",
 		shape: {
@@ -169,7 +215,7 @@ function positionedText(spans, box, frame, zOrder, rotation60k) {
 				insetRight: pt(0),
 				insetBottom: pt(0)
 			},
-			paragraphProperties: {}
+			paragraphProperties: FLOAT_CARRIER
 		}
 	};
 }
@@ -226,17 +272,21 @@ function shapeBlock(v, frame, zOrder, behind = false) {
 	const alpha = v.alpha !== void 0 ? { alpha: v.alpha } : {};
 	const fill = v.gradient !== void 0 ? {
 		kind: "gradient",
-		gradient: v.gradient,
+		gradient: gradientOverBox(v.gradient, v),
 		...alpha
 	} : v.fillHex !== void 0 ? {
 		kind: "solid",
 		colorHex: v.fillHex,
 		...alpha
 	} : { kind: "none" };
+	const dash = v.strokeHex !== void 0 && v.dash !== void 0 ? penDash(v.dash, pen) : [];
 	const line = v.strokeHex !== void 0 ? {
 		width: pt(pen),
 		colorHex: v.strokeHex,
-		fill: "solid"
+		fill: "solid",
+		...dash.length > 0 ? { customDash: dash } : {},
+		cap: v.cap ?? "flat",
+		...v.strokeAlpha !== void 0 ? { alpha: v.strokeAlpha } : {}
 	} : void 0;
 	const float = frame !== void 0 ? {
 		wrap: "none",
@@ -267,7 +317,7 @@ function shapeBlock(v, frame, zOrder, behind = false) {
 			},
 			fill,
 			...line ? { line } : {},
-			paragraphProperties: {}
+			paragraphProperties: float ? FLOAT_CARRIER : {}
 		}
 	};
 }
@@ -306,6 +356,131 @@ function sectionFromPdfPages(pages) {
 	};
 }
 /**
+* §8.4.3.6 — a page's dash pattern as DrawingML states one (§20.1.8.21
+* `a:custDash`): dash and gap in turn, as multiples of the pen's width.
+*
+* An odd count of lengths runs twice before it repeats, so the dashes and the
+* gaps trade places the second time round; written out once more, the pairs
+* come out even. A dash of no length is a DOT, drawn by the pen's cap alone —
+* which no .docx line carries — so it is set a pen's width long and the gap
+* after it gives that back, keeping the pattern's period.
+*
+* @param dash The lengths in page-space points.
+* @param pen  The pen's width in points.
+* @returns The pattern in pen widths, or an empty array for a solid line.
+*/
+function penDash(dash, pen) {
+	if (dash.length === 0 || !(pen > 0)) return [];
+	const out = (dash.length % 2 === 1 ? [...dash, ...dash] : [...dash]).map((n) => n / pen);
+	for (let i = 0; i < out.length; i += 2) {
+		if (out[i] > 0) continue;
+		out[i] = 1;
+		out[i + 1] = Math.max(out[i + 1] - 1, MIN_DASH_GAP);
+	}
+	return out;
+}
+/** The least gap a dash pattern keeps, in pen widths, so a dotted line stays dotted. */
+var MIN_DASH_GAP = .5;
+/** What the measure gives back, so the widest line still fits when re-set. */
+var SLACK = .01;
+/** How much of the sheet a margin down the page may take. */
+var DEEPEST_MARGIN = .5;
+/**
+* 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.
+*/
+var GUESSED_MARGIN = 1 / 3;
+/** The narrowest measure a sheet's own lines may leave, as a share of the sheet. */
+var NARROWEST_MEASURE = .2;
+/**
+* The lines a sheet's runs stand on — baselines further apart than half the
+* size of the type on them — and how many of them END at the sheet's right
+* edge, within an em of the farthest: the lines a measure broke, or a margin
+* justified, rather than the ones their author stopped.
+*/
+function linesOf(runs) {
+	const ink = runs.filter((r) => r.text.trim() !== "").map((r) => ({
+		y: r.y,
+		end: r.endX,
+		size: r.fontSizePt || 10
+	})).sort((a, b) => b.y - a.y);
+	const lines = [];
+	for (const at of ink) {
+		const last = lines[lines.length - 1];
+		if (last !== void 0 && last.y - at.y <= Math.max(last.size, at.size) / 2) {
+			last.end = Math.max(last.end, at.end);
+			last.size = Math.max(last.size, at.size);
+		} else lines.push({ ...at });
+	}
+	const edge = Math.max(...lines.map((l) => l.end));
+	return {
+		count: lines.length,
+		atEdge: lines.filter((l) => edge - l.end <= l.size).length
+	};
+}
+/**
+* The white, in ems of the text, a running foot keeps above it — which is
+* what the reader asked of it before it took the line for a foot at all.
+*/
+var FOOT_CLEAR_EM = 2;
+/**
+* §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.
+*/
+var BASELINE_AT = .8;
+/** A line's box where no pitch was measured: the ordinary single spacing, in ems. */
+var 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.
+*/
+var ASCENDER = BASELINE_AT * NATURAL_LINE_EM;
+/**
+* And how far below its baseline the last line's box reaches. A box set half
+* as deep again as its size reaches three tenths of it down; measured to a
+* face's descender instead, bug1337429.pdf's last line did not fit the sheet
+* it was drawn on and went to a second one.
+*/
+var DESCENDER = (1 - BASELINE_AT) * 1.5;
+/**
+* How small, against the document's own text, type may be set and still be
+* read as text rather than as a mark the producer left on the sheet.
+*/
+var LEGIBLE_SHARE = .25;
+/**
+* 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.
+*/
+function textSizeOf(pageRuns) {
+	const sizes = pageRuns.flat().map((r) => r.fontSizePt).filter((s) => s > 0).sort((a, b) => a - b);
+	return sizes[Math.floor(sizes.length / 2)] ?? 0;
+}
+/**
+* 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.
+*/
+function tooSmallToRead(run, textSize) {
+	return run.fontSizePt > 0 && run.fontSizePt < textSize * LEGIBLE_SHARE;
+}
+/**
 * 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
@@ -322,18 +497,13 @@ function sectionFromPdfPages(pages) {
 * @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.
 */
-/** What the measure gives back, so the widest line still fits when re-set. */
-var SLACK = .01;
-/** How much of the sheet a margin down the page may take. */
-var DEEPEST_MARGIN = .5;
-/** How far a face's ascender stands above its baseline, as a fraction of the size. */
-var ASCENDER = .8;
-/** And its descender below — the two together are a little over one em. */
-var DESCENDER = .22;
-function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
+function withMeasuredMargins(section, shown, pageRuns, pageMarks = [], foot = []) {
 	if (!section?.pageSize) return section;
 	const width = section.pageSize.width;
 	const height = section.pageSize.height;
@@ -341,8 +511,10 @@ function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
 	const rights = [];
 	const tops = [];
 	const bottoms = [];
-	pageRuns.forEach((runs, i) => {
+	const textSize = textSizeOf(pageRuns);
+	pageRuns.forEach((all, i) => {
 		const page = shown[i];
+		const runs = all.filter((r) => r.annotation !== true && !tooSmallToRead(r, textSize));
 		if (!page || runs.length === 0) return;
 		let minX = Infinity;
 		let maxX = -Infinity;
@@ -365,6 +537,7 @@ function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
 				topSize = r.fontSizePt;
 			}
 		}
+		const textEnd = maxX;
 		for (const mark of pageMarks[i] ?? []) {
 			if (!Number.isFinite(mark.x) || !Number.isFinite(mark.y)) continue;
 			maxX = Math.max(maxX, mark.x + mark.widthPt);
@@ -372,7 +545,12 @@ function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
 		}
 		if (!Number.isFinite(minX) || !Number.isFinite(minY)) return;
 		lefts.push(minX);
-		rights.push(page.width - maxX);
+		const lines = linesOf(runs);
+		rights.push({
+			value: page.width - maxX,
+			full: lines.count >= 3 || maxX > textEnd,
+			edged: lines.atEdge >= 2 && maxX <= textEnd
+		});
 		tops.push(page.height - maxY - topSize * ASCENDER);
 		bottoms.push(minY - bottomSize * DESCENDER);
 	});
@@ -382,13 +560,21 @@ function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
 		return s[Math.floor(s.length / 2)] ?? 0;
 	};
 	const clamp = (v, span, most = 1 / 3) => pt(Math.max(0, Math.min(v, span * most)));
+	const inked = foot.filter((r) => r.text.trim() !== "");
+	const footTop = Math.max(...inked.map((r) => r.y + r.fontSizePt * ASCENDER));
+	const footBottom = Math.min(...inked.map((r) => r.y - r.fontSizePt * DESCENDER));
+	const floor = inked.length > 0 ? footTop + textSize * FOOT_CLEAR_EM : Infinity;
+	const left = clamp(Math.min(...lefts), width);
+	const voters = rights.filter((r) => r.full);
+	const farthest = voters.length > 0 && voters.every((r) => r.edged) ? Math.max(width * GUESSED_MARGIN, width * (1 - NARROWEST_MEASURE) - left) : width * GUESSED_MARGIN;
 	return {
 		...section,
 		margins: {
-			left: clamp(Math.min(...lefts), width),
-			right: clamp(median(rights) - width * SLACK, width),
+			left,
+			right: pt(Math.max(0, Math.min(median((voters.length > 0 ? voters : rights).map((r) => r.value)) - width * SLACK, farthest))),
 			top: clamp(Math.min(...tops), height, DEEPEST_MARGIN),
-			bottom: clamp(Math.min(...bottoms) - height * SLACK, height, DEEPEST_MARGIN)
+			bottom: clamp(Math.min(...bottoms, floor) - height * SLACK, height, DEEPEST_MARGIN),
+			...inked.length > 0 ? { footer: clamp(footBottom, height, DEEPEST_MARGIN) } : {}
 		}
 	};
 }
@@ -399,7 +585,7 @@ function withMeasuredMargins(section, shown, pageRuns, pageMarks = []) {
 * both reconstruction paths (the tagged fast-path EP3 and the heuristic layout
 * path EP4).
 */
-function buildFlowDoc(body, resources = new ResourceStore(), section, embeddedFonts, sections = [], headersFooters) {
+function buildFlowDoc(body, resources = new ResourceStore(), section, embeddedFonts, sections = [], headersFooters, faceFamilies) {
 	return {
 		kind: "flow",
 		body: resolveBodyStyles([...body], EMPTY_STYLE_SHEET),
@@ -407,9 +593,10 @@ function buildFlowDoc(body, resources = new ResourceStore(), section, embeddedFo
 		...headersFooters && headersFooters.size > 0 ? { headersFooters } : {},
 		...section ? { section } : {},
 		...embeddedFonts && embeddedFonts.size > 0 ? { embeddedFonts } : {},
+		...faceFamilies && faceFamilies.size > 0 ? { faceFamilies } : {},
 		styles: EMPTY_STYLE_SHEET,
 		resources
 	};
 }
 //#endregion
-export { buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, positionedText, sectionFromPdfPages, shapeBlock, withMeasuredMargins };
+export { BASELINE_AT, CARRIER_LINE_PT, GUESSED_MARGIN, NATURAL_LINE_EM, buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, positionedText, sectionFromPdfPages, shapeBlock, spaceAfter, textSizeOf, tooSmallToRead, withMeasuredMargins };

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

@@ -1,6 +1,7 @@
 import { PdfDict } from '../pdf/objects.js';
 import { ContentFont } from './content.js';
-import { PdfFile } from './document.js';
+import { PdfFile, PdfPage } from './document.js';
+import { FaceFamily } from '../core/ir/flow.js';
 /**
  * Build a {@link ContentFont} (the interpreter's decode + advance hooks) from a
  * `/Font` dictionary (E-PDF EP2). Unicode comes from the `/ToUnicode` CMap;
@@ -14,3 +15,28 @@ import { PdfFile } from './document.js';
  * @returns The decode/advance hooks plus the code width (1 or 2 bytes per code).
  */
 export declare function buildContentFont(file: PdfFile, fontDict: PdfDict): ContentFont;
+/**
+ * For every face a run may name, the family a word processor knows it by —
+ * keyed by the name the run carries (see {@link FaceFamily}).
+ *
+ * A PDF names the FACE and a .docx names a family: written as the face,
+ * `inter-semibold` was a font no reader has, and LibreOffice set the whole of
+ * an invoice drawn in Inter in its default serif. The family is the one the
+ * descriptor states (§9.8.1 `/FontFamily`) or, where it states none, the one
+ * the PostScript name is made of.
+ *
+ * @param file  The document.
+ * @param pages The pages whose faces are wanted.
+ * @returns Run font name → its family.
+ */
+export declare function collectFaceFamilies(file: PdfFile, pages: ReadonlyArray<PdfPage>): Map<string, FaceFamily>;
+/**
+ * The family a PostScript face name is made of: `Inter-SemiBold` → `Inter`,
+ * `ArialMT` → `Arial`, `TimesNewRomanPS-BoldMT` → `Times New Roman`.
+ *
+ * §9.6.2.1 names a face `Family-Style` (Word writes `Family,Style`), with the
+ * family's words run together. What follows the separator is a style only if
+ * it is made of style words — `MS-Mincho` is a family of its own — and the
+ * words come apart where the capitals say they do.
+ */
+export declare function familyOfFace(baseFont: string): string;