reamkit 1.33.1 → 1.34.0

package/dist/esm/layout/styled-layout.js

@@ -1,8 +1,9 @@
 import { resolveFamilyStyle } from "../core/fonts/remote-fonts.js";
-import { scriptForCodepoint } from "../core/fonts/scripts.js";
-import { shapeText } from "../core/font/opentype-layout.js";
+import { fontSlotOf, scriptForCodepoint } from "../core/fonts/scripts.js";
 import { hasSubstitutable, substituteLetters } from "../core/font/ligatures.js";
-import { createFontMeasure } from "../core/font/measure.js";
+import { hasIndic, syllableStarts } from "../core/font/indic-shaper.js";
+import { createFontMeasure, shapeGlyphs } from "../core/font/measure.js";
+import "../core/font/index.js";
 import { pageItemBounds } from "./page-doc.js";
 import { halfPtToPt, pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
@@ -31,6 +32,7 @@ import { rectPath } from "../core/drawingml/preset-geometry.js";
 import { buildShapePaths, buildShapeTransform, buildStroke, gradientToSolid, lineEndPaths } from "../core/drawingml/shape-render.js";
 import { StructTreeBuilder } from "../pdf/struct-tree.js";
 import { floatIntoFrame, turnOntoSheet } from "./turned-section.js";
+import { undrawnLoss } from "./undrawn.js";
 //#region src/layout/styled-layout.ts
 function parsePdfAProfile(pdfA) {
 	const part = Number(pdfA.charAt(6));
@@ -584,7 +586,7 @@ function layoutStyledDocument(body, options) {
 		const group = bodyFrames.starts.get(idx);
 		if (group) return layoutFrameBlock(group, ctx.options ?? options, fontResources, imageResources, width);
 		if (bodyFrames.continued.has(idx)) return emptyBlock(options);
-		return layoutBodyElement(own, ctx.options ?? options, fontResources, imageResources, width, ctx.pageContentHeight, box);
+		return layoutBodyElement(own, ctx.options ?? options, fontResources, imageResources, width, ctx.pageContentHeight, box, true);
 	});
 	for (let i = 0; i < blocks.length; i++) {
 		const here = blocks[i];
@@ -696,9 +698,14 @@ function layoutStyledDocument(body, options) {
 	}
 	const bookmarks = /* @__PURE__ */ new Map();
 	const commentNotes = options.commentAnnotations && options.comments ? buildCommentNotes(noteAssigned.comments, options.comments) : void 0;
-	const reflowParagraph = (paragraph, width, widths) => layoutParagraphBlock(paragraph, options, fontResources, imageResources, width, widths);
+	const reflowParagraph = (paragraph, width, widths) => layoutParagraphBlock(paragraph, options, fontResources, imageResources, width, widths, true);
+	const pages = paginateSections(blocks, sectionCtxs, structBuilder, options.language ?? "en-US", notePlan, bookmarks, reflowParagraph, backgroundImageOf(options, imageResources), collapsesSpacing(options), options.compatibilityMode);
+	if (options.losses) {
+		const undrawn = undrawnLoss(pages);
+		if (undrawn) options.losses.push(undrawn);
+	}
 	return {
-		pages: paginateSections(blocks, sectionCtxs, structBuilder, options.language ?? "en-US", notePlan, bookmarks, reflowParagraph, backgroundImageOf(options, imageResources), collapsesSpacing(options), options.compatibilityMode),
+		pages,
 		resources: options.resources ?? new ResourceStore(),
 		fontResources,
 		imageResources,
@@ -1328,8 +1335,8 @@ function laidOutBlocksFor(elements, options, fontResources, contentWidth, imageR
 		return layoutBodyElement(el, options, fontResources, imageResources, contentWidth, void 0, box);
 	});
 }
-function layoutBodyElement(el, options, fontResources, imageResources, contentWidth, maxHeight, box) {
-	if (el.kind === "paragraph") return layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, contentWidth);
+function layoutBodyElement(el, options, fontResources, imageResources, contentWidth, maxHeight, box, pageFlow = false) {
+	if (el.kind === "paragraph") return layoutParagraphBlock(el.paragraph, options, fontResources, imageResources, contentWidth, void 0, pageFlow);
 	if (el.kind === "table") return layoutTableBlock(el.table, options, fontResources, imageResources, contentWidth);
 	if (el.kind === "image") {
 		const res = el.image.resource ? imageResources?.get(el.image.resource) : void 0;
@@ -2891,13 +2898,13 @@ function runFontKeyAndParsed(options, ascii, bold, italic) {
 /**
 * The face a CHARACTER falls back to when the run's own has no glyph for it.
 *
-* The curated substitutes are Latin families: Han, Kana, Hangul, Arabic, Thai
-* and the geometric symbols are a notdef box in every one of them, and 2145
-* characters of the corpus are exactly those. A face for the character's
-* writing system is fetched when the document holds one (see `addScriptFonts`),
-* and this is where a run reaches it — followed by every other family already
-* loaded, because a glyph one of them happens to carry is still better than a
-* box.
+* The curated substitutes are Latin families: Han, Kana, Hangul, Arabic, Thai,
+* the scripts of India and the geometric symbols are a notdef box in every one
+* of them, and 2145 characters of the corpus are exactly those. A face for the
+* character's writing system is fetched when the document holds one (see
+* `addScriptFonts`), and this is where a run reaches it — followed by every
+* other family already loaded, because a glyph one of them happens to carry is
+* still better than a box.
 *
 * Called from BOTH walks that need it — the glyph-subset collection and the
 * tokenizer — so the face a character is measured, subset and drawn with is one
@@ -2943,19 +2950,17 @@ function fallbackFaceKey(options, cp, bold, italic) {
 * Only where nobody can draw the character itself: one a face DOES carry is
 * drawn as written.
 *
-* @param options  The render options (the loaded registries).
-* @param primary  The run's own face.
-* @param resolved Its resolved properties (weight and slant).
-* @param text     The run's text.
+* @param faces The face each character of the run is drawn with ({@link runFaces}).
+* @param text  The run's text.
 * @returns The text to set, which is `text` itself unless something was undrawable.
 */
-function drawableText(options, primary, resolved, text) {
+function drawableText(faces, text) {
 	if (!hasSubstitutable(text)) return text;
 	let out = "";
 	for (const ch of text) {
 		const cp = ch.codePointAt(0);
 		const letters = substituteLetters(cp);
-		const drawable = letters === void 0 || primary.glyphForCodepoint(cp) !== 0 || fallbackFaceKey(options, cp, resolved.bold, resolved.italic) !== void 0;
+		const drawable = letters === void 0 || faces(cp).parsed.glyphForCodepoint(cp) !== 0;
 		out += drawable ? ch : letters;
 	}
 	return out;
@@ -2994,7 +2999,7 @@ function syntheticFace(variant, bold, italic, widthScale) {
 */
 function splitByFace(plan, text) {
 	const first = faceOf(plan, text.codePointAt(0) ?? 0);
-	if (!plan.faceFor || plan.faceFor.size === 0) return [{
+	if (text === "" || !plan.faceFor || plan.faceFor.size === 0) return [{
 		text,
 		face: first
 	}];
@@ -3029,24 +3034,120 @@ function faceOf(plan, cp) {
 		...plan.synthetic ? { synthetic: plan.synthetic } : {}
 	};
 }
+var INDIC_JOINS = /* @__PURE__ */ new Set([
+	8204,
+	8205,
+	9676,
+	160,
+	2404,
+	2405
+]);
+/**
+* Whether a family has a face of its OWN on hand — embedded, or a substitute
+* fetched for it — rather than the first registry, which is where
+* {@link runFontKeyAndParsed} sends a family nothing was fetched for.
+*
+* @param options The render options (the loaded faces).
+* @param family  The family's name.
+*/
+function hasOwnFace(options, family) {
+	if (options.embeddedFonts?.has(family.trim().toLowerCase()) === true) return true;
+	return options.registriesByFamily?.has(resolveFamilyStyle(family).key) === true;
+}
+/**
+* §17.3.2.26 — the faces a run's other slots name, where one is on hand and is
+* not the face its ascii slot names.
+*
+* @param options  The render options (the loaded faces).
+* @param resolved The run's resolved properties.
+* @param primary  The run's own face, its ascii slot's.
+* @returns The face per slot, or `undefined` when every slot draws in `primary`.
+*/
+function slotFaces(options, resolved, primary) {
+	let out;
+	for (const slot of [
+		"hAnsi",
+		"eastAsia",
+		"cs"
+	]) {
+		const family = resolved.fontFamily[slot];
+		if (family === void 0 || !hasOwnFace(options, family)) continue;
+		const face = runFontKeyAndParsed(options, family, resolved.bold, resolved.italic);
+		if (face.fontKey !== primary.fontKey) (out ??= /* @__PURE__ */ new Map()).set(slot, face);
+	}
+	return out;
+}
+/**
+* {@link fallbackFaceKey}, with what the face lacks of the run's weight and
+* slant: a script face is fetched in the regular weight only, and a bold run in
+* it is stroked, which is what F3's synthesis is for.
+*/
+function fallbackFace(options, cp, resolved) {
+	const face = fallbackFaceKey(options, cp, resolved.bold, resolved.italic);
+	if (!face) return void 0;
+	const variant = face.fontKey.split(":")[1];
+	const got = variant === "bold" || variant === "boldItalic" || variant === "italic" ? variant : "regular";
+	return {
+		...face,
+		...syntheticFace(got, resolved.bold, resolved.italic)
+	};
+}
+/**
+* §17.3.2.26 — the face each character of a run is drawn with: the one its
+* slot names ({@link fontSlotOf}), else the run's own, else whichever face on
+* hand has the glyph ({@link fallbackFaceKey}).
+*
+* A run names a face per slot, and Word sets each character in its slot's:
+* "split" in a run's ascii Verdana and "Кириллица" beside it in its hAnsi
+* Courier New. We drew both in Verdana's substitute, and the hAnsi face was
+* read for nothing but the line's height. A slot whose family has no face on
+* hand leaves its characters to the run's own, as before.
+*
+* Called from every walk that needs it — the glyph-subset collection, the
+* tokenizer, a table cell's measure — so the face a character is measured,
+* subset and drawn with is one decision made once.
+*
+* @param options  The render options (the loaded faces).
+* @param resolved The run's resolved properties (its faces, weight, slant, direction).
+* @param primary  The run's own face, the one its ascii slot names.
+* @param text     The run's text, for the scripts of India (see {@link INDIC_JOINS}).
+* @returns The face a code point of the run is drawn with.
+*/
+function runFaces(options, resolved, primary, text) {
+	const slots = slotFaces(options, resolved, primary);
+	const drawing = (cp) => {
+		const own = slots?.get(fontSlotOf(cp, resolved.rtl)) ?? primary;
+		if (own.parsed.glyphForCodepoint(cp) !== 0) return own;
+		if (own !== primary && primary.parsed.glyphForCodepoint(cp) !== 0) return primary;
+		return fallbackFace(options, cp, resolved) ?? own;
+	};
+	const indic = indicFace(drawing, text);
+	if (!indic) return drawing;
+	return (cp) => INDIC_JOINS.has(cp) && indic.parsed.glyphForCodepoint(cp) !== 0 ? indic : drawing(cp);
+}
+/** The face that draws the first letter of the scripts of India in `text`. */
+function indicFace(drawing, text) {
+	for (const ch of text) {
+		const cp = ch.codePointAt(0);
+		if (cp < 2304 || cp > 3455 || cp === 2404 || cp === 2405) continue;
+		return drawing(cp);
+	}
+}
 /**
 * `text` cut into the stretches ONE face draws, by the same decision the
-* tokenizer makes — the whole string as a single span when the run's own face
-* covers it, which is nearly always.
+* tokenizer makes — the whole string as a single span when one face draws all
+* of it, which is nearly always.
 *
-* @param options  The render options (the loaded registries).
-* @param primary  The run's own face.
-* @param resolved Its resolved properties (weight and slant).
-* @param text     The run's text.
+* @param faces The face each character of the run is drawn with ({@link runFaces}).
+* @param text  The run's text.
 */
-function faceSpans(options, primary, resolved, text) {
+function faceSpans(faces, text) {
 	const out = [];
-	let cur = primary;
+	let cur;
 	let buf = "";
 	for (const ch of text) {
-		const cp = ch.codePointAt(0);
-		const face = primary.parsed.glyphForCodepoint(cp) !== 0 ? primary : fallbackFaceKey(options, cp, resolved.bold, resolved.italic) ?? primary;
-		if (buf !== "" && face.fontKey !== cur.fontKey) {
+		const face = faces(ch.codePointAt(0));
+		if (cur && face.fontKey !== cur.fontKey) {
 			out.push({
 				...cur,
 				text: buf
@@ -3056,37 +3157,34 @@ function faceSpans(options, primary, resolved, text) {
 		cur = face;
 		buf += ch;
 	}
-	if (buf !== "") out.push({
+	if (cur) out.push({
 		...cur,
 		text: buf
 	});
 	return out;
 }
 /**
-* The face for every character of `text` the run's own cannot draw.
+* The face for every character of `text` the run's own does not draw.
 *
-* @param options       The render options (the loaded registries).
 * @param fontResources The faces the document embeds, by key.
 * @param primary       The run's own face.
-* @param resolved      Its resolved properties (weight and slant).
+* @param faces         The face each character is drawn with ({@link runFaces}).
 * @param text          The run's text.
 * @returns A map from code point to face, or `undefined` when the run's own
 *          face draws all of it.
 */
-function facesForRun(options, fontResources, primary, resolved, text) {
+function facesForRun(fontResources, primary, faces, text) {
 	let out;
 	for (const ch of text) {
 		const cp = ch.codePointAt(0);
-		if (out?.has(cp) === true || primary.glyphForCodepoint(cp) !== 0) continue;
-		const fallback = fallbackFaceKey(options, cp, resolved.bold, resolved.italic);
-		if (!fallback) continue;
-		const font = fontResources.get(fallback.fontKey);
+		if (out?.has(cp) === true) continue;
+		const face = faces(cp);
+		if (face.fontKey === primary.fontKey) continue;
+		const font = fontResources.get(face.fontKey);
 		if (!font) continue;
-		out ??= /* @__PURE__ */ new Map();
-		const { variant } = { variant: fallback.fontKey.split(":")[1] ?? "" };
-		out.set(cp, {
+		(out ??= /* @__PURE__ */ new Map()).set(cp, {
 			font,
-			...syntheticFace(variant === "bold" || variant === "boldItalic" || variant === "italic" ? variant : "regular", resolved.bold, resolved.italic)
+			...face.synthetic ? { synthetic: face.synthetic } : {}
 		});
 	}
 	return out;
@@ -3099,7 +3197,8 @@ function collectFontResources(body, headersFooters, options, imageResources) {
 	const numerals = [...new Set([options.section, ...(options.sections ?? []).map((sec) => sec.properties)].flatMap((p) => p?.pageNumberFormat !== void 0 ? [p.pageNumberFormat] : []))].map((fmt) => Array.from({ length: 200 }, (_, i) => formatCounter(fmt, i + 1)).join("")).join("");
 	const addRun = (run, para) => {
 		const resolved = resolveRunProperties(run.properties, para.properties, options.styles);
-		const { fontKey, parsed } = runFontKeyAndParsed(options, resolved.fontFamily.ascii, resolved.bold, resolved.italic);
+		const primary = runFontKeyAndParsed(options, resolved.fontFamily.ascii, resolved.bold, resolved.italic);
+		const { fontKey, parsed } = primary;
 		let bucket = used.get(fontKey);
 		if (!bucket) {
 			bucket = {
@@ -3108,11 +3207,9 @@ function collectFontResources(body, headersFooters, options, imageResources) {
 			};
 			used.set(fontKey, bucket);
 		}
-		const text = drawableText(options, parsed, resolved, run.listMarker === true ? markerText(run.text, parsed) : run.text);
-		for (const span of faceSpans(options, {
-			fontKey,
-			parsed
-		}, resolved, text)) {
+		const faces = runFaces(options, resolved, primary, run.text);
+		const text = drawableText(faces, run.text);
+		for (const span of faceSpans(faces, text)) {
 			let sink = used.get(span.fontKey);
 			if (!sink) {
 				sink = {
@@ -3121,8 +3218,13 @@ function collectFontResources(body, headersFooters, options, imageResources) {
 				};
 				used.set(span.fontKey, sink);
 			}
-			const shaped = shapeText(span.text, span.parsed.glyphForCodepoint, span.parsed.advanceWidths, span.parsed.ligatures, span.parsed.kerning, span.parsed.joiningForms);
+			const shown = run.listMarker === true ? markerText(span.text, span.parsed) : span.text;
+			const shaped = shapeGlyphs(span.parsed, shown);
 			for (const g of shaped.gids) sink.gids.add(g);
+			for (const [g, t] of shaped.glyphText ?? []) {
+				sink.glyphText ??= /* @__PURE__ */ new Map();
+				if (!sink.glyphText.has(g)) sink.glyphText.set(g, t);
+			}
 		}
 		if (run.text.includes("	")) for (const stop of resolveParagraphProperties(para.properties, options.styles).tabs) {
 			const ch = stop.leader === void 0 ? void 0 : TAB_LEADER_CHARS.get(stop.leader);
@@ -3287,7 +3389,8 @@ function collectFontResources(body, headersFooters, options, imageResources) {
 			resourceName,
 			parsed: info.parsed,
 			measure: createFontMeasure(info.parsed, options.layoutProfile !== "word"),
-			gids: info.gids
+			gids: info.gids,
+			...info.glyphText ? { glyphText: info.glyphText } : {}
 		});
 	}
 	return out;
@@ -3342,7 +3445,7 @@ function paragraphLeading(pp, options) {
 		markLinePt: m.ascentPt + m.descentPt + m.lineGapPt
 	};
 }
-function layoutParagraphBlock(paragraph, options, fontResources, imageResources, contentWidth, lineWidths) {
+function layoutParagraphBlock(paragraph, options, fontResources, imageResources, contentWidth, lineWidths, pageFlow = false) {
 	const cascaded = resolveParagraphProperties(paragraph.properties, options.styles);
 	const baseResolved = options.gridLinePitchPt !== void 0 && cascaded.snapToGrid !== false ? {
 		...cascaded,
@@ -3367,20 +3470,24 @@ function layoutParagraphBlock(paragraph, options, fontResources, imageResources,
 		...baseResolved,
 		alignment: "right"
 	} : baseResolved;
-	const tokens = tokenizeParagraph(paragraph, options, fontResources, imageResources, contentWidth, baseDir);
+	const all = tokenizeParagraph(paragraph, options, fontResources, imageResources, contentWidth, baseDir);
+	const tokens = pageFlow ? all : all.filter((t) => !(t.kind === "text" && t.pageBreak));
 	const firstLineWidth = paragraphMaxWidth(resolved, contentWidth, true);
 	const otherWidth = paragraphMaxWidth(resolved, contentWidth, false);
 	const leading = paragraphLeading(paragraph.properties, options);
 	const runWrap = (part, firstWidth, widths) => wrap(part, firstWidth, otherWidth, resolved, options.hyphenator, options.layoutProfile ?? "ream", leading, options.doNotExpandShiftReturn === true, widths);
-	const parts = splitAtColumnBreaks(tokens);
+	const flow = splitAtBreaks(tokens);
 	const columnBreakLines = /* @__PURE__ */ new Set();
+	const pageBreakLines = /* @__PURE__ */ new Set();
 	let wrapped;
-	if (parts.length === 1) wrapped = runWrap(tokens, firstLineWidth, lineWidths);
+	if (flow.parts.length === 1) wrapped = runWrap(flow.parts[0].tokens, firstLineWidth, lineWidths);
 	else {
 		wrapped = [];
-		for (const [i, part] of parts.entries()) {
-			const lines = runWrap(part, i === 0 ? firstLineWidth : otherWidth, lineWidths?.slice(wrapped.length));
-			if (i > 0 && lines.length > 0) columnBreakLines.add(wrapped.length);
+		for (const [i, part] of flow.parts.entries()) {
+			const width = i === 0 ? firstLineWidth : otherWidth;
+			const lines = runWrap(part.tokens, width, lineWidths?.slice(wrapped.length));
+			if (lines.length === 0 && (part.opens === "page" || part.endsPage)) lines.push(emptyLine(paragraph, options, resolved, Math.max(width, 0)));
+			if (i > 0 && lines.length > 0) (part.opens === "page" ? pageBreakLines : columnBreakLines).add(wrapped.length);
 			wrapped.push(...i === 0 ? lines : lines.map((l) => ({
 				...l,
 				firstLine: false
@@ -3391,10 +3498,6 @@ function layoutParagraphBlock(paragraph, options, fontResources, imageResources,
 	let heightPt = 0;
 	for (const line of lines) heightPt += computeLineHeight(line, resolved);
 	const numbering = paragraph.properties.numbering;
-	const breakIdx = paragraph.runs.findIndex((r) => r.pageBreak === true);
-	const holds = (r) => r.text !== "" || r.inlineImage !== void 0 || r.math !== void 0;
-	const leadingPageBreak = breakIdx >= 0 && paragraph.runs.slice(0, breakIdx + 1).every((r) => r.text === "" && r.inlineImage === void 0) && paragraph.runs.slice(breakIdx + 1).some(holds);
-	const trailingPageBreak = paragraph.runs.some((r, i) => r.pageBreak === true && (!leadingPageBreak || i > breakIdx));
 	return {
 		kind: "paragraph",
 		resolved,
@@ -3406,9 +3509,10 @@ function layoutParagraphBlock(paragraph, options, fontResources, imageResources,
 			numId: numbering.numId,
 			level: numbering.ilvl
 		} } : {},
-		...leadingPageBreak ? { pageBreakBefore: true } : {},
-		...trailingPageBreak ? { pageBreakAfter: true } : {},
+		...flow.pageBreakBefore ? { pageBreakBefore: true } : {},
+		...flow.pageBreakAfter ? { pageBreakAfter: true } : {},
 		...columnBreakLines.size > 0 ? { columnBreakLines } : {},
+		...pageBreakLines.size > 0 ? { pageBreakLines } : {},
 		...paragraph.bookmarks && paragraph.bookmarks.length > 0 ? { bookmarks: paragraph.bookmarks } : {},
 		source: paragraph
 	};
@@ -3500,7 +3604,132 @@ function displayCapsRuns(paragraph, options) {
 			start = i;
 		}
 	}
-	return any ? out : paragraph.runs;
+	return mendSplitSyllables(any ? out : paragraph.runs);
+}
+/** A run of plain text: no picture, equation, field, note mark or list marker. */
+function plainTextRun(run) {
+	return run.text.length > 0 && run.inlineImage === void 0 && run.math === void 0 && run.field === void 0 && run.footnoteRef === void 0 && run.endnoteRef === void 0 && run.noteNumber !== true && run.listMarker !== true;
+}
+var SYLLABLE_REACH = 32;
+/** Per code point of a run's text, the properties of the run each character was typed in. */
+function charPropertiesOf(run) {
+	return run.charProperties ?? [...run.text].map(() => run.properties);
+}
+/**
+* A syllable of the scripts of India that a run boundary cuts, given whole to
+* the run it begins in. Word sets runs apart for a colour, a weight, a tracked
+* change or a spelling mark, and nothing stops one from starting at a vowel
+* sign: font issues.docx colours each sign of कृष्ण apart, and
+* Untitled 2.docx ends a bold run on the र् of a reph. Shaped run by run,
+* each sign stood alone on a dotted circle and the reph stayed a Ra and a
+* virama. The syllable now takes the formatting of the run it begins in…
+*
+* …all but its colour. Word draws each sign of कृष्ण in the colour of its
+* own run, on the one shaped syllable, so each character brought along keeps
+* the properties of the run it came from (`charProperties`), and the glyphs
+* are painted from them.
+*/
+function mendSplitSyllables(runs) {
+	if (!runs.some((r) => hasIndic(r.text))) return runs;
+	const out = [...runs];
+	let prev = -1;
+	for (let k = 0; k < out.length; k++) {
+		const run = out[k];
+		if (!plainTextRun(run)) {
+			if (run.text.length > 0 || run.inlineImage !== void 0 || run.math !== void 0) prev = -1;
+			continue;
+		}
+		const before = prev >= 0 ? out[prev] : void 0;
+		if (before && hasIndic(before.text + run.text)) {
+			const tail = [...before.text].slice(-32);
+			const head = [...run.text].slice(0, SYLLABLE_REACH);
+			const starts = syllableStarts([...tail, ...head].join(""));
+			let moved = 0;
+			while (moved < head.length && !starts[tail.length + moved]) moved++;
+			if (moved > 0) {
+				const take = head.slice(0, moved).join("");
+				const brought = charPropertiesOf(run);
+				out[prev] = {
+					...before,
+					text: before.text + take,
+					charProperties: [...charPropertiesOf(before), ...brought.slice(0, moved)]
+				};
+				out[k] = {
+					...run,
+					text: run.text.slice(take.length),
+					...run.charProperties ? { charProperties: brought.slice(moved) } : {}
+				};
+			}
+		}
+		if (out[k].text.length > 0) prev = k;
+	}
+	return out;
+}
+/**
+* The colour each character of a run is drawn in, where a split syllable
+* brought characters of other runs into it: each takes its own run's colour,
+* resolved through the styles as that run's would be.
+*
+* @param options  The render options (for the style cascade).
+* @param paragraph The paragraph the run is in.
+* @param faces    The face each character of the run is drawn with ({@link runFaces}).
+* @param resolved The run's resolved properties.
+* @param run      The run, as {@link mendSplitSyllables} left it.
+* @param drawn    Its text as drawn ({@link drawableText}).
+* @returns Per code point of `drawn`, its colour — or nothing when every
+*          character is in the run's own.
+*/
+function charColours(options, paragraph, faces, resolved, run, drawn) {
+	const from = run.charProperties;
+	if (!from) return void 0;
+	const hexOf = /* @__PURE__ */ new Map([[run.properties, resolved.colorHex]]);
+	const out = [];
+	let i = 0;
+	for (const ch of run.text) {
+		const props = from[i++] ?? run.properties;
+		let hex = hexOf.get(props);
+		if (hex === void 0) {
+			hex = resolveRunProperties(props, paragraph.properties, options.styles).colorHex;
+			hexOf.set(props, hex);
+		}
+		const letters = drawn === run.text ? 1 : [...drawableText(faces, ch)].length;
+		for (let k = 0; k < letters; k++) out.push(hex);
+	}
+	return out.some((hex) => hex !== resolved.colorHex) ? out : void 0;
+}
+/**
+* A token's share of the per-character colours it was cut from: the code
+* points [from, to) of them, kept only when one differs from the token's own.
+*
+* @param colours  The colours of what the token was cut from, if any.
+* @param ownHex   The token's own colour.
+* @param from     The first code point the token takes.
+* @param to       The code point after its last.
+* @returns `{ charColorsHex }` when the token needs them, `{}` when not.
+*/
+function charColoursOf(colours, ownHex, from, to) {
+	if (!colours) return {};
+	const own = colours.slice(from, to);
+	return own.some((hex) => hex !== ownHex) ? { charColorsHex: own } : {};
+}
+/**
+* A piece cut out of a text token — its code points [from, from + its text's
+* length) — with the token's formatting and its own share of the per-character
+* colours.
+*/
+function tokenPiece(tok, text, from, widthPt) {
+	const { charColorsHex, ...rest } = tok;
+	if (!charColorsHex) return {
+		...tok,
+		text,
+		widthPt
+	};
+	return {
+		...rest,
+		text,
+		widthPt,
+		...charColoursOf(charColorsHex, tok.resolvedRun.colorHex, from, from + [...text].length)
+	};
 }
 function tokenizeParagraph(paragraph, options, fontResources, imageResources, contentWidth, baseDir) {
 	const plans = displayCapsRuns(paragraph, options).map((run) => {
@@ -3570,22 +3799,26 @@ function tokenizeParagraph(paragraph, options, fontResources, imageResources, co
 			};
 		}
 		const resolvedRun = resolveRunProperties(run.properties, paragraph.properties, options.styles);
-		const { fontKey, synthetic } = runFontKeyAndParsed(options, resolvedRun.fontFamily.ascii, resolvedRun.bold, resolvedRun.italic);
+		const primary = runFontKeyAndParsed(options, resolvedRun.fontFamily.ascii, resolvedRun.bold, resolvedRun.italic);
+		const { fontKey, synthetic } = primary;
 		const script = SCRIPT_OFFSET[resolvedRun.verticalAlign] ?? 0;
 		const own = lookupFont(fontResources, fontKey);
+		const faces = runFaces(options, resolvedRun, primary, run.text);
 		const drawn = (() => {
-			const text = drawableText(options, own.parsed, resolvedRun, run.text);
+			const text = drawableText(faces, run.text);
 			return text === run.text ? run : {
 				...run,
 				text
 			};
 		})();
-		const faceFor = facesForRun(options, fontResources, own.parsed, resolvedRun, drawn.text);
+		const faceFor = facesForRun(fontResources, primary, faces, drawn.text);
+		const charColorsHex = charColours(options, paragraph, faces, resolvedRun, run, drawn.text);
 		return {
 			run: drawn,
 			resolvedRun,
 			font: own,
 			...faceFor ? { faceFor } : {},
+			...charColorsHex ? { charColorsHex } : {},
 			...synthetic ? { synthetic } : {},
 			fontSizePt: script === 0 ? resolvedRun.fontSizePt : resolvedRun.fontSizePt * SCRIPT_SCALE,
 			...script === 0 ? {} : { risePt: resolvedRun.fontSizePt * script },
@@ -3605,17 +3838,62 @@ function tokenizeParagraph(paragraph, options, fontResources, imageResources, co
 	})), baseDir));
 }
 /**
-* Split a paragraph's tokens at every §17.3.3.1 column break, dropping the
-* break token itself (its line ends there anyway). One part ⇒ no break.
+* Split a paragraph's tokens at every §17.3.3.1 column or page break, dropping
+* the break token itself (its line ends there anyway). One part ⇒ no break.
+*
+* A forced page break happens WHERE IT STANDS. One that precedes every word of
+* the paragraph moves the paragraph itself to the next page, one that follows
+* every word sends what FOLLOWS the paragraph there, and neither splits it. One
+* between two of its words splits it there: Word sets "Latin", a page break and
+* "Second" on two pages, and read as a break after the paragraph, both words
+* stood on the first.
+*
+* A PICTURE is not nothing, however empty its run's text: the break after it
+* sends what follows to the next page, it does not move the paragraph. Counted
+* as empty, tdf125657.docx — a full-page image and then a break — kept the
+* break's page to itself and lost the one the mark after it stands on.
+*
+* …and a break is before the paragraph only when something FOLLOWS it. A
+* paragraph that is nothing but the break — a page break typed on a line of its
+* own — keeps its mark with the break, on the page the break ends, and what
+* follows starts the next page at its very top. Word for Mac, in every mode: a
+* document ending in one is one page, two in a row leave the second alone at
+* the top of page 2, and the paragraph after the break stands at the page's
+* first line. Moved to the next page with its mark, it stood an empty line down
+* every such page.
 *
 * @param tokens The paragraph's tokens in order.
-* @returns The parts, in order; always at least one.
+* @returns The parts, in order (always at least one), and whether the
+*          paragraph breaks the page before itself and after itself.
 */
-function splitAtColumnBreaks(tokens) {
-	const parts = [[]];
-	for (const t of tokens) if (t.kind === "text" && t.columnBreak) parts.push([]);
-	else parts[parts.length - 1].push(t);
-	return parts.filter((p, i) => i === 0 || p.length > 0);
+function splitAtBreaks(tokens) {
+	const isPage = (t) => t.kind === "text" && t.pageBreak === true;
+	const pageBreakBefore = tokens.length > 0 && isPage(tokens[0]) && tokens.some((t) => !isPage(t));
+	const pageBreakAfter = tokens.length > 0 && isPage(tokens[tokens.length - 1]);
+	const parts = [{
+		tokens: [],
+		endsPage: false
+	}];
+	const end = pageBreakAfter ? tokens.length - 1 : tokens.length;
+	for (const t of tokens.slice(pageBreakBefore ? 1 : 0, end)) if (isPage(t)) {
+		parts[parts.length - 1].endsPage = true;
+		parts.push({
+			tokens: [],
+			opens: "page",
+			endsPage: false
+		});
+	} else if (t.kind === "text" && t.columnBreak) parts.push({
+		tokens: [],
+		opens: "column",
+		endsPage: false
+	});
+	else parts[parts.length - 1].tokens.push(t);
+	if (pageBreakAfter) parts[parts.length - 1].endsPage = true;
+	return {
+		parts: parts.filter((p, i) => i === 0 || p.tokens.length > 0 || p.opens === "page" || p.endsPage),
+		pageBreakBefore,
+		pageBreakAfter
+	};
 }
 function tokenizePlansLtr(plans) {
 	const tokens = [];
@@ -3652,13 +3930,21 @@ function tokenizePlansLtr(plans) {
 			});
 			continue;
 		}
+		if (plan.run.listMarkerSpace === true) {
+			tokens.push(markerSpaceToken(plan, 0));
+			continue;
+		}
 		const highlight = (plan.run.commentRangeRefs?.length ?? 0) > 0;
+		let at = 0;
 		for (const t of tokenizeText(plan.run.text)) for (const piece of splitByFace(plan, t.text)) {
-			const text = plan.run.listMarker === true ? markerText(piece.text, plan.font.parsed) : piece.text;
+			const text = plan.run.listMarker === true ? markerText(piece.text, piece.face.font.parsed) : piece.text;
+			const from = at;
+			if (plan.charColorsHex) at += t.tab ? 1 : [...piece.text].length;
 			tokens.push({
 				kind: "text",
 				text,
 				isSpace: t.isSpace,
+				...charColoursOf(plan.charColorsHex, plan.resolvedRun.colorHex, from, at),
 				...t.tab ? { tab: true } : {},
 				...plan.run.href !== void 0 ? { href: plan.run.href } : {},
 				...plan.run.footnoteRef !== void 0 ? { footnoteRef: plan.run.footnoteRef } : {},
@@ -3675,10 +3961,58 @@ function tokenizePlansLtr(plans) {
 				bidiLevel: 0
 			});
 		}
+		if (plan.run.pageBreak) tokens.push(pageBreakToken(plan));
 	}
 	return tokens;
 }
 /**
+* §17.3.3.1 — the mark a `w:br w:type="page"` leaves among its paragraph's
+* tokens: nothing to draw, only where the break stands. A run that holds text
+* as well breaks after it, the way the writer writes one. It never reaches a
+* line: the paragraph is split at it before it is wrapped.
+*
+* @param plan The break's run.
+* @returns An empty text token flagged `pageBreak`.
+*/
+function pageBreakToken(plan) {
+	return {
+		kind: "text",
+		text: "",
+		isSpace: false,
+		pageBreak: true,
+		resolvedRun: plan.resolvedRun,
+		font: plan.font,
+		fontSizePt: plan.fontSizePt,
+		widthPt: 0,
+		bidiLevel: 0
+	};
+}
+/** Arial's space, as a fraction of the em: 569 of its 2048 units. */
+var MARKER_SPACE_EM = 569 / 2048;
+/**
+* §17.9.29 — the space a list level's `w:suff="space"` puts after its marker,
+* as Word sets it: a gap of 0.278 em of the marker's size, whatever the
+* marker's face — Arial's space, though the marker is in none of it. Measured
+* in Word for Mac at 48pt, Courier New, Verdana, Times New Roman, Georgia,
+* Calibri, Tahoma, Impact and Songti markers all leave the same 13.4pt before
+* the text; a space of each face would have ranged from 8.5 to 28.8. Nothing is
+* drawn in it, and a justified line does not stretch it.
+*/
+function markerSpaceToken(plan, bidiLevel) {
+	return {
+		kind: "text",
+		text: "",
+		isSpace: false,
+		listMarker: true,
+		listMarkerSpace: true,
+		resolvedRun: plan.resolvedRun,
+		font: plan.font,
+		fontSizePt: plan.fontSizePt,
+		widthPt: MARKER_SPACE_EM * plan.fontSizePt,
+		bidiLevel
+	};
+}
+/**
 * A LIST MARKER the font has no glyph for, swapped for the dot every text font
 * carries.
 *
@@ -3689,8 +4023,15 @@ function tokenizePlansLtr(plans) {
 * eleven slides. The marker is the one place where the shape matters more than
 * the code point, so it takes the nearest thing the font can draw.
 *
-* @param text The marker's text.
-* @param font The font it is set in.
+* Asked of the face that DRAWS the character, not of the run's own: a marker
+* may be set in two faces, and a character another face draws is no business
+* of the run's. chtoutline.docx numbers its chapters "第 1 章" in a Latin
+* heading face with the Han in a face of their own; asked of the Latin one, 第
+* and 章 became dots set in the Han face's subset, which had reserved neither,
+* and the heading printed nothing but its "1".
+*
+* @param text   The marker's text.
+* @param parsed The face that draws it.
 * @returns The text to draw.
 */
 function markerText(text, parsed) {
@@ -3718,7 +4059,7 @@ function measureRunText(plan, text, face) {
 	};
 	const base = drawn.font.measure.textWidthPt(text, plan.fontSizePt) * (drawn.synthetic?.widthScale ?? 1) * (plan.resolvedRun.widthScale ?? 1);
 	const extra = plan.resolvedRun.letterSpacingPt;
-	return extra === void 0 || extra === 0 ? base : base + extra * [...text].length;
+	return extra === void 0 || extra === 0 ? base : base + extra * drawn.font.measure.spacingSlots(text);
 }
 function tokenizePlansBidi(plans, realLevels) {
 	const tokens = [];
@@ -3759,6 +4100,11 @@ function tokenizePlansBidi(plans, realLevels) {
 			realIdx++;
 			continue;
 		}
+		if (plan.run.listMarkerSpace === true) {
+			tokens.push(markerSpaceToken(plan, realLevels[realIdx] ?? 0));
+			realIdx += [...plan.run.text].length;
+			continue;
+		}
 		const chars = [...plan.run.text];
 		let bufStart = 0;
 		let curSpace = false;
@@ -3767,11 +4113,12 @@ function tokenizePlansBidi(plans, realLevels) {
 		const flush = (endExclusive) => {
 			if (endExclusive <= bufStart) return;
 			const raw = chars.slice(bufStart, endExclusive).join("");
-			const text = plan.run.listMarker === true ? markerText(raw, plan.font.parsed) : raw;
+			const text = plan.run.listMarker === true ? markerText(raw, curFace.font.parsed) : raw;
 			tokens.push({
 				kind: "text",
 				text,
 				isSpace: curSpace,
+				...charColoursOf(plan.charColorsHex, plan.resolvedRun.colorHex, bufStart, endExclusive),
 				...plan.run.href !== void 0 ? { href: plan.run.href } : {},
 				...plan.run.footnoteRef !== void 0 ? { footnoteRef: plan.run.footnoteRef } : {},
 				...plan.run.anchor !== void 0 ? { anchor: plan.run.anchor } : {},
@@ -3806,6 +4153,7 @@ function tokenizePlansBidi(plans, realLevels) {
 			realIdx++;
 		}
 		flush(chars.length);
+		if (plan.run.pageBreak) tokens.push(pageBreakToken(plan));
 	}
 	return tokens;
 }
@@ -3976,7 +4324,8 @@ function paragraphItemStream(tokens, hyphenator, maxLineWidthPt) {
 				font: tok.font,
 				fontSizePt: tok.fontSizePt,
 				widthPt: fragWidth,
-				bidiLevel: tok.bidiLevel
+				bidiLevel: tok.bidiLevel,
+				...tok.charColorsHex ? charColoursOf(tok.charColorsHex, tok.resolvedRun.colorHex, [...tok.text.slice(0, prev)].length, [...tok.text.slice(0, end)].length) : {}
 			};
 			entries.push({
 				item: {
@@ -4128,11 +4477,12 @@ function splitAtHyphens(tok) {
 	}
 	if (parts.length === 0) return void 0;
 	parts.push(tok.text.slice(start));
-	return parts.map((text) => ({
-		...tok,
-		text,
-		widthPt: tok.font.measure.textWidthPt(text, tok.fontSizePt)
-	}));
+	let from = 0;
+	return parts.map((text) => {
+		const piece = tokenPiece(tok, text, from, tok.font.measure.textWidthPt(text, tok.fontSizePt));
+		if (tok.charColorsHex) from += [...text].length;
+		return piece;
+	});
 }
 function splitToWidth(tok, widthPt) {
 	if (tok.kind !== "text") return void 0;
@@ -4153,11 +4503,7 @@ function splitToWidth(tok, widthPt) {
 			width = nextWidth;
 			end++;
 		}
-		out.push({
-			...tok,
-			text,
-			widthPt: width
-		});
+		out.push(tokenPiece(tok, text, start, width));
 		start = end;
 	}
 	return out.length > 1 ? out : void 0;
@@ -4293,10 +4639,11 @@ function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, profile,
 /**
 * §17.3.2.26 — the family Word sets a token's characters in: East Asian text
 * in the run's `eastAsia` font, complex-script text (and a `w:rtl` run) in its
-* `cs` one, the rest in `ascii` — `hAnsi` above ASCII. The layout draws a run
-* with its ascii face and hands what that face lacks to another, so the name
-* the run gives for THESE characters is the one Word's line is looked up by:
-* a Chinese sentence in a Calibri run does not stand on Calibri's line.
+* `cs` one, the rest in `ascii` — `hAnsi` above ASCII (see {@link fontSlotOf}).
+* The layout draws each character in its slot's face where that face is
+* loaded, and in what it falls back to where not, so the name the run gives for
+* THESE characters is the one Word's line is looked up by: a Chinese sentence
+* in a Calibri run does not stand on Calibri's line.
 *
 * @param t The text token.
 * @returns The family's name, when the run gives one for that slot.
@@ -4306,12 +4653,9 @@ function wordFamilyOf(t) {
 	if (t.resolvedRun.rtl) return fonts.cs;
 	let high = false;
 	for (const ch of t.text) {
-		const cp = ch.codePointAt(0) ?? 0;
-		if (cp <= 127) continue;
-		high = true;
-		const script = scriptForCodepoint(cp);
-		if (script === "hebrew" || script === "arabic" || script === "thai") return fonts.cs;
-		if (script === "kr" || script === "jp" || script === "sc") return fonts.eastAsia;
+		const slot = fontSlotOf(ch.codePointAt(0) ?? 0);
+		if (slot === "cs" || slot === "eastAsia") return fonts[slot];
+		if (slot === "hAnsi") high = true;
 	}
 	return high ? fonts.hAnsi ?? fonts.ascii : fonts.ascii;
 }
@@ -4765,10 +5109,8 @@ function measureSingleLine(paragraph, options, fontResources) {
 	let total = 0;
 	for (const run of paragraph.runs) {
 		const resolved = resolveRunProperties(run.properties, paragraph.properties, options.styles);
-		const { fontKey, synthetic } = runFontKeyAndParsed(options, resolved.fontFamily.ascii, resolved.bold, resolved.italic);
-		const font = lookupFont(fontResources, fontKey);
-		const fontSizePt = resolved.fontSizePt;
-		total += font.measure.textWidthPt(run.text, fontSizePt) * (synthetic?.widthScale ?? 1) * (resolved.widthScale ?? 1);
+		const primary = runFontKeyAndParsed(options, resolved.fontFamily.ascii, resolved.bold, resolved.italic);
+		for (const span of faceSpans(runFaces(options, resolved, primary, run.text), run.text)) total += lookupFont(fontResources, span.fontKey).measure.textWidthPt(span.text, resolved.fontSizePt) * (span.synthetic?.widthScale ?? 1) * (resolved.widthScale ?? 1);
 	}
 	return total;
 }
@@ -5633,8 +5975,8 @@ var PageAssembler = class PageAssembler {
 	/**
 	* The first of a paragraph's lines, from `from` on, that the current column
 	* no longer holds: each line is counted with the notes it brings onto the
-	* page, the way the line loop places it, and an explicit column break ends
-	* the column where it stands.
+	* page, the way the line loop places it, and an explicit column or page break
+	* ends the column where it stands.
 	*
 	* @param pb   The paragraph being placed.
 	* @param from The first line not yet placed.
@@ -5647,7 +5989,7 @@ var PageAssembler = class PageAssembler {
 		let notesOnPage = this.pageNotes.length > 0;
 		const counted = /* @__PURE__ */ new Set();
 		for (let i = from; i < pb.lines.length; i++) {
-			if (i > from && pb.columnBreakLines?.has(i)) return i;
+			if (i > from && (pb.columnBreakLines?.has(i) || pb.pageBreakLines?.has(i))) return i;
 			const line = pb.lines[i];
 			const h = computeLineHeight(line, pb.resolved);
 			const notes = this.lineFootnotes(line).filter((x) => !counted.has(x.id));
@@ -6183,6 +6525,7 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 				if (!pb.resolved.widowControl || n < 2 || asm.exclusions.length > 0) return void 0;
 				let end = asm.firstLineOverflowing(pb, from);
 				if (end >= n) return void 0;
+				if (pb.columnBreakLines?.has(end) || pb.pageBreakLines?.has(end)) return void 0;
 				if (n - end === 1) end--;
 				if (from === 0 && end === 1) end = 0;
 				if (end <= from) return asm.colHasContent() ? from : from + 1;
@@ -6212,6 +6555,10 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 			let firstLineOfBlock = true;
 			let pairPending;
 			for (const [lineIdx, line] of pb.lines.entries()) {
+				if (pb.pageBreakLines?.has(lineIdx) && asm.pageHasContent()) {
+					asm.flushPage();
+					columnEnd = keptColumnEnd(lineIdx);
+				}
 				if (pb.columnBreakLines?.has(lineIdx) && asm.colHasContent()) {
 					advanceBefore(lineIdx);
 					columnEnd = keptColumnEnd(lineIdx);