reamkit 1.30.0 → 1.31.0

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

@@ -33,14 +33,22 @@ function paragraphBlock(text, outlineLevel) {
 * 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.
 */
-function spaceAfter(before) {
+function spaceAfter(before, after) {
+	const markup = before?.markup;
 	return {
 		text: " ",
 		...before?.sizePt !== void 0 ? { sizePt: before.sizePt } : {},
-		...before?.fontName !== void 0 ? { fontName: before.fontName } : {}
+		...before?.fontName !== void 0 ? { fontName: before.fontName } : {},
+		...markup !== void 0 && after?.markup !== void 0 && sameMarkup(markup, after.markup) ? { markup } : {}
 	};
 }
 /**
@@ -53,7 +61,7 @@ function paragraphFromRuns(spans, outlineLevel, placement) {
 	const merged = [];
 	for (const s of spans) {
 		const last = merged[merged.length - 1];
-		if (last && last.href === s.href && last.sizePt === s.sizePt && last.colorHex === s.colorHex && last.fontName === s.fontName && last.outline?.colorHex === s.outline?.colorHex && last.outline?.widthPt === s.outline?.widthPt && last.bold === s.bold && last.italic === s.italic && last.script === s.script && sameMarkup(last.markup, s.markup)) last.text += s.text;
+		if (last && last.href === s.href && last.sizePt === s.sizePt && last.colorHex === s.colorHex && last.fontName === s.fontName && last.outline?.colorHex === s.outline?.colorHex && last.outline?.widthPt === s.outline?.widthPt && last.bold === s.bold && last.italic === s.italic && last.script === s.script && last.widthScale === s.widthScale && sameMarkup(last.markup, s.markup)) last.text += s.text;
 		else merged.push({
 			text: s.text,
 			...s.href !== void 0 ? { href: s.href } : {},
@@ -64,7 +72,8 @@ function paragraphFromRuns(spans, outlineLevel, placement) {
 			...s.bold !== void 0 ? { bold: s.bold } : {},
 			...s.italic !== void 0 ? { italic: s.italic } : {},
 			...s.script !== void 0 ? { script: s.script } : {},
-			...s.markup !== void 0 ? { markup: s.markup } : {}
+			...s.markup !== void 0 ? { markup: s.markup } : {},
+			...s.widthScale !== void 0 ? { widthScale: s.widthScale } : {}
 		});
 	}
 	const runs = merged.map((m) => ({
@@ -98,7 +107,8 @@ function paragraphFromRuns(spans, outlineLevel, placement) {
 					...r.markup?.highlightHex !== void 0 ? { shadingColorHex: r.markup.highlightHex } : {},
 					...r.markup?.underline !== void 0 ? { underline: r.markup.underline } : {},
 					...r.markup?.underlineHex !== void 0 ? { underlineColorHex: r.markup.underlineHex } : {},
-					...r.markup?.strike === true ? { strike: true } : {}
+					...r.markup?.strike === true ? { strike: true } : {},
+					...r.widthScale !== void 0 ? { widthScale: r.widthScale } : {}
 				},
 				...r.href ? { href: r.href } : {}
 			}))
@@ -181,10 +191,6 @@ 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, void 0, {
-		spacingLine: pt(Math.max(1, box.height)),
-		spacingLineRule: "exact"
-	});
 	return {
 		kind: "shape",
 		shape: {
@@ -200,22 +206,134 @@ function positionedText(spans, box, frame, zOrder, rotation60k) {
 					offsetPt: pt(Math.max(0, frame.top - box.y - box.height))
 				}
 			},
-			width: pt(Math.max(1, box.width)),
-			height: pt(Math.max(1, box.height)),
-			...rotation60k !== void 0 ? { transform: { rotation60k } } : {},
+			...lineBox(spans, box, rotation60k),
+			paragraphProperties: FLOAT_CARRIER
+		}
+	};
+}
+/** A line of text in a box of its own, sized to the box, which nobody sees. */
+function lineBox(spans, box, rotation60k, noWrap = false) {
+	const paragraph = paragraphFromRuns(spans, void 0, {
+		spacingLine: pt(Math.max(1, box.height)),
+		spacingLineRule: "exact"
+	});
+	return {
+		width: pt(Math.max(1, box.width)),
+		height: pt(Math.max(1, box.height)),
+		...rotation60k !== void 0 ? { transform: { rotation60k } } : {},
+		geometry: {
+			kind: "preset",
+			preset: "rect"
+		},
+		fill: { kind: "none" },
+		text: {
+			content: [paragraph],
+			insetLeft: pt(0),
+			insetTop: pt(0),
+			insetRight: pt(0),
+			insetBottom: pt(0),
+			...noWrap ? { noWrap: true } : {}
+		}
+	};
+}
+/** A path of a figure, drawn where the page drew it. */
+function vectorMember(v) {
+	const el = shapeBlock(v);
+	if (el.kind !== "shape") throw new Error("a path is drawn as a shape");
+	return {
+		shape: el.shape,
+		left: v.minX,
+		top: v.maxY
+	};
+}
+/**
+* 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.
+*/
+function imageMember(image, resources) {
+	const turned = image.rotationDeg !== void 0 || image.flipV === true;
+	return {
+		shape: {
+			width: pt(image.widthPt),
+			height: pt(image.heightPt),
+			...turned ? { transform: {
+				...image.rotationDeg !== void 0 ? { rotation60k: Math.round(-image.rotationDeg * 6e4) } : {},
+				...image.flipV === true ? { flipV: true } : {}
+			} } : {},
 			geometry: {
 				kind: "preset",
 				preset: "rect"
 			},
-			fill: { kind: "none" },
-			text: {
-				content: [paragraph],
-				insetLeft: pt(0),
-				insetTop: pt(0),
-				insetRight: pt(0),
-				insetBottom: pt(0)
+			fill: {
+				kind: "picture",
+				imageResource: resources.put(image.bytes),
+				...image.crop ? { imageCrop: image.crop } : {},
+				...image.alpha !== void 0 ? { alpha: image.alpha } : {}
 			},
-			paragraphProperties: FLOAT_CARRIER
+			paragraphProperties: {}
+		},
+		left: image.x,
+		top: image.y + image.heightPt
+	};
+}
+/**
+* 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.
+*/
+function labelMember(spans, box, rotation60k) {
+	return {
+		shape: {
+			...lineBox(spans, box, rotation60k, true),
+			paragraphProperties: {}
+		},
+		left: box.x,
+		top: box.y + box.height
+	};
+}
+/** The box a figure's parts stand in, on the page (y-up). */
+function membersBox(members) {
+	return {
+		left: Math.min(...members.map((m) => m.left)),
+		top: Math.max(...members.map((m) => m.top)),
+		right: Math.max(...members.map((m) => m.left + m.shape.width)),
+		bottom: Math.min(...members.map((m) => m.top - m.shape.height))
+	};
+}
+/**
+* §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.
+*/
+function figureBlock(members, properties) {
+	const box = membersBox(members);
+	return {
+		kind: "shape",
+		shape: {
+			width: pt(box.right - box.left),
+			height: pt(box.top - box.bottom),
+			children: members.map((m) => ({
+				shape: m.shape,
+				xPt: pt(m.left - box.left),
+				yPt: pt(box.top - m.top)
+			})),
+			geometry: {
+				kind: "custom",
+				custom: {
+					pathWidth: 0,
+					pathHeight: 0,
+					commands: []
+				}
+			},
+			fill: { kind: "none" },
+			paragraphProperties: properties
 		}
 	};
 }
@@ -332,10 +450,10 @@ function shapeBlock(v, frame, zOrder, behind = false) {
 * this single geometry — a known approximation, still far better than a fixed
 * `A4`. Returns `undefined` when there is no usable first-page box.
 */
-function sectionFromPdfPages(pages) {
+function sectionFromPdfPages(pages, display) {
 	const first = pages[0];
 	if (!first) return void 0;
-	const shown = displayOf(first);
+	const shown = display ?? displayOf(first);
 	const width = shown.width;
 	const height = shown.height;
 	if (!(width > 0 && height > 0)) return void 0;
@@ -356,6 +474,102 @@ function sectionFromPdfPages(pages) {
 	};
 }
 /**
+* §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.
+*/
+function sectionOnSheet(section, display) {
+	const sheet = display?.sheet;
+	if (!section || !sheet) return section;
+	const m = section.margins;
+	return {
+		...section,
+		pageSize: {
+			width: pt(sheet.width),
+			height: pt(sheet.height),
+			orientation: sheet.width > sheet.height ? "landscape" : "portrait"
+		},
+		...m ? { margins: {
+			...m,
+			top: m.left,
+			right: m.top,
+			bottom: m.right,
+			left: m.bottom
+		} } : {},
+		textDirection: "tbRl"
+	};
+}
+/**
+* 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.
+*/
+function floatOntoSheet(el, sheetWidth) {
+	const onto = (float, width, height) => {
+		if (float.posH?.relativeFrom !== "page" || float.posV?.relativeFrom !== "page") return void 0;
+		const cx = (float.posH.offsetPt ?? 0) + width / 2;
+		const cy = (float.posV.offsetPt ?? 0) + height / 2;
+		return {
+			...float,
+			posH: {
+				relativeFrom: "page",
+				offsetPt: pt(sheetWidth - cy - width / 2)
+			},
+			posV: {
+				relativeFrom: "page",
+				offsetPt: pt(cx - height / 2)
+			}
+		};
+	};
+	const quarter = (rotation60k) => ((rotation60k ?? 0) + 90 * 6e4) % (360 * 6e4);
+	if (el.kind === "image" && el.image.float) {
+		const float = onto(el.image.float, el.image.width, el.image.height);
+		if (!float) return el;
+		return {
+			...el,
+			image: {
+				...el.image,
+				float,
+				rotation60k: quarter(el.image.rotation60k)
+			}
+		};
+	}
+	if (el.kind === "shape" && el.shape.float) {
+		const float = onto(el.shape.float, el.shape.width, el.shape.height);
+		if (!float) return el;
+		const rotation60k = quarter(el.shape.transform?.rotation60k);
+		return {
+			...el,
+			shape: {
+				...el.shape,
+				float,
+				transform: {
+					...el.shape.transform,
+					rotation60k
+				}
+			}
+		};
+	}
+	return el;
+}
+/**
 * §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.
 *
@@ -579,24 +793,129 @@ function withMeasuredMargins(section, shown, pageRuns, pageMarks = [], foot = []
 	};
 }
 /**
+* 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.
+*/
+function typesetRuns(blocks, typeset) {
+	if (typeset.size === 0) return [...blocks];
+	const shape = (s) => ({
+		...s,
+		...s.text ? { text: {
+			...s.text,
+			content: typesetRuns(s.text.content, typeset)
+		} } : {},
+		...s.children ? { children: s.children.map((child) => ({
+			...child,
+			shape: shape(child.shape)
+		})) } : {}
+	});
+	return blocks.map((el) => {
+		if (el.kind === "paragraph") {
+			const runs = el.paragraph.runs.map((run) => {
+				const face = run.properties.fontFamily?.ascii;
+				const asked = face !== void 0 ? typeset.get(face) : void 0;
+				return asked ? {
+					...run,
+					properties: {
+						...run.properties,
+						...asked
+					}
+				} : run;
+			});
+			return {
+				...el,
+				paragraph: {
+					...el.paragraph,
+					runs
+				}
+			};
+		}
+		if (el.kind === "table") {
+			const rows = el.table.rows.map((row) => ({
+				...row,
+				cells: row.cells.map((cell) => ({
+					...cell,
+					content: typesetRuns(cell.content, typeset)
+				}))
+			}));
+			return {
+				...el,
+				table: {
+					...el.table,
+					rows
+				}
+			};
+		}
+		if (el.kind === "shape") return {
+			...el,
+			shape: shape(el.shape)
+		};
+		return el;
+	});
+}
+/**
+* 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.
+*/
+function typesetting(kerned, faceOutlines) {
+	const out = /* @__PURE__ */ new Map();
+	for (const face of kerned) out.set(face, { kerningMinPt: KERN_FROM_PT });
+	for (const [face, outlines] of faceOutlines ?? []) if (outlines.ligatures && outlines.ligatures.size > 0) out.set(face, {
+		...out.get(face),
+		ligatures: "standard"
+	});
+	return out;
+}
+/** §17.3.2.19 — kerned from one point up: at every size a page is set in. */
+var KERN_FROM_PT = pt(1);
+/**
 * Assemble the final {@link FlowDoc} for a reconstruction: the body elements
 * with their styles resolved against the empty style sheet, the lifted-image
 * resource store, and the optional page {@link SectionProperties}. Shared by
 * both reconstruction paths (the tagged fast-path EP3 and the heuristic layout
 * path EP4).
 */
-function buildFlowDoc(body, resources = new ResourceStore(), section, embeddedFonts, sections = [], headersFooters, faceFamilies) {
+function buildFlowDoc(body, resources = new ResourceStore(), section, embeddedFonts, sections = [], headersFooters, faceFamilies, faceOutlines, kerned = /* @__PURE__ */ new Set()) {
+	const typeset = typesetting(kerned, faceOutlines);
+	const bands = headersFooters && typeset.size > 0 ? new Map([...headersFooters].map(([id, blocks]) => [id, typesetRuns(blocks, typeset)])) : headersFooters;
 	return {
 		kind: "flow",
-		body: resolveBodyStyles([...body], EMPTY_STYLE_SHEET),
+		body: resolveBodyStyles(typesetRuns(body, typeset), RECONSTRUCTION_SHEET),
 		sections,
-		...headersFooters && headersFooters.size > 0 ? { headersFooters } : {},
+		...bands && bands.size > 0 ? { headersFooters: bands } : {},
 		...section ? { section } : {},
 		...embeddedFonts && embeddedFonts.size > 0 ? { embeddedFonts } : {},
 		...faceFamilies && faceFamilies.size > 0 ? { faceFamilies } : {},
+		...faceOutlines && faceOutlines.size > 0 ? { faceOutlines } : {},
+		compatibilityMode: CURRENT_WORD_LAYOUT,
 		styles: EMPTY_STYLE_SHEET,
 		resources
 	};
 }
+/** [MS-DOCX] `compatibilityMode` 15 — Word 2013's layout, a current Word's. */
+var CURRENT_WORD_LAYOUT = 15;
+/**
+* §17.3.1.44 — the sheet a reconstruction's paragraphs resolve against: the
+* empty one, with widow control off. Every source page opens a page of its
+* own, and the page already broke its paragraphs where it did; where a
+* reconstructed column runs a line long, widow control — on wherever nothing
+* says otherwise — carries a second line over with it, and the column after
+* runs longer still.
+*/
+var RECONSTRUCTION_SHEET = {
+	...EMPTY_STYLE_SHEET,
+	defaultParagraphProperties: { widowControl: false }
+};
 //#endregion
-export { BASELINE_AT, CARRIER_LINE_PT, GUESSED_MARGIN, NATURAL_LINE_EM, buildFlowDoc, dedupeLosses, imageBlock, paragraphBlock, paragraphFromRuns, positionedText, sectionFromPdfPages, shapeBlock, spaceAfter, textSizeOf, tooSmallToRead, withMeasuredMargins };
+export { ASCENDER, BASELINE_AT, CARRIER_LINE_PT, GUESSED_MARGIN, NATURAL_LINE_EM, buildFlowDoc, dedupeLosses, figureBlock, floatOntoSheet, imageBlock, imageMember, labelMember, membersBox, paragraphBlock, paragraphFromRuns, positionedText, sectionFromPdfPages, sectionOnSheet, shapeBlock, spaceAfter, textSizeOf, tooSmallToRead, vectorMember, withMeasuredMargins };