reamkit 1.34.0 → 1.35.0

package/README.md

@@ -30,7 +30,8 @@ Parse once into the format-neutral interlayer, convert to any target. The
 format is sniffed from the bytes; no fonts to wire up — an open
 metric-compatible substitute font (Arimo for sans, Tinos for serif, Cousine for
 monospace, plus Carlito/Caladea for Calibri/Cambria — the same families LibreOffice
-substitutes) is fetched automatically based on the document's referenced fonts,
+substitutes, with Cambria's Cyrillic and Greek from Noto Serif) is fetched
+automatically based on the document's referenced fonts,
 with a Noto face for the Japanese, Korean, Chinese, Arabic, Hebrew, Thai or
 Indic (Hindi, Bengali, Tamil and six more scripts) text the document holds:
 

package/dist/esm/core/converter/ream.d.ts

@@ -195,6 +195,21 @@ export declare class Ream {
      * @returns The font bytes and, for docx, optional per-family registries.
      */
     private resolveFonts;
+    /**
+     * Fetch the family each twin borrows the letters it lacks from: Caladea,
+     * Cambria's twin, has no Cyrillic and no Greek, and without its companion a
+     * Cambria run set every Russian or Kazakh letter in whichever face was loaded
+     * first — a grotesque beside the roman around it.
+     *
+     * A companion that fails to arrive is a recorded loss, not a throw: its
+     * letters still fall to another face on hand.
+     *
+     * @param into       The registry map the run resolver looks in.
+     * @param companions The companion families the document's text needs.
+     * @param fetchOpt   The injectable `fetch`, when the caller gave one.
+     * @param losses     Where a companion that could not be fetched records itself.
+     */
+    private addCompanionFonts;
     /**
      * Fetch one face per writing system the document holds text in — the curated
      * families are Latin, and Han, Kana, Hangul, Arabic, the scripts of India and

package/dist/esm/core/converter/ream.js

@@ -1,5 +1,5 @@
 import { fetchFontSet, fetchScriptFont, resolveFamilyKey } from "../fonts/remote-fonts.js";
-import { scriptsInFlow } from "../fonts/scripts.js";
+import { companionsInFlow, scriptsInFlow } from "../fonts/scripts.js";
 import { FontRegistry } from "../font/font-registry.js";
 import { createFontMeasure } from "../font/measure.js";
 import "../font/index.js";
@@ -287,7 +287,8 @@ var Ream = class Ream {
 		}
 		const fetchOpt = options.fontFetch ? { fetch: options.fontFetch } : {};
 		const keys = options.fontFamily ? /* @__PURE__ */ new Set([resolveFamilyKey(options.fontFamily)]) : familiesInFlow(flow);
-		if (keys.size <= 1 && scriptsInFlow(flow).scripts.size === 0) {
+		const companions = companionsInFlow(flow, keys);
+		if (keys.size <= 1 && companions.size === 0 && scriptsInFlow(flow).scripts.size === 0) {
 			const family = keys.values().next().value;
 			return { fonts: await fetchFontSet({
 				...family ? { family } : {},
@@ -304,6 +305,7 @@ var Ream = class Ream {
 			registriesByFamily.set(key, FontRegistry.fromBytes(bytes));
 			if (key === "arimo" || !baseBytes) baseBytes = bytes;
 		}
+		await this.addCompanionFonts(registriesByFamily, companions, fetchOpt, losses);
 		await this.addScriptFonts(registriesByFamily, flow, options, losses);
 		return {
 			fonts: baseBytes,
@@ -311,6 +313,37 @@ var Ream = class Ream {
 		};
 	}
 	/**
+	* Fetch the family each twin borrows the letters it lacks from: Caladea,
+	* Cambria's twin, has no Cyrillic and no Greek, and without its companion a
+	* Cambria run set every Russian or Kazakh letter in whichever face was loaded
+	* first — a grotesque beside the roman around it.
+	*
+	* A companion that fails to arrive is a recorded loss, not a throw: its
+	* letters still fall to another face on hand.
+	*
+	* @param into       The registry map the run resolver looks in.
+	* @param companions The companion families the document's text needs.
+	* @param fetchOpt   The injectable `fetch`, when the caller gave one.
+	* @param losses     Where a companion that could not be fetched records itself.
+	*/
+	async addCompanionFonts(into, companions, fetchOpt, losses) {
+		for (const family of companions) {
+			if (into.has(family)) continue;
+			try {
+				into.set(family, FontRegistry.fromBytes(await fetchFontSet({
+					family,
+					...fetchOpt
+				})));
+			} catch {
+				losses.push({
+					feature: "font",
+					detail: `the ${family} face could not be fetched; the letters it draws for a substitute fall to another face`,
+					severity: "substituted"
+				});
+			}
+		}
+	}
+	/**
 	* Fetch one face per writing system the document holds text in — the curated
 	* families are Latin, and Han, Kana, Hangul, Arabic, the scripts of India and
 	* the geometric symbols are a notdef box in every one of them.

package/dist/esm/core/font/index.d.ts

@@ -7,7 +7,7 @@ export { pickVariant } from './font-registry.js';
 export { parseGposKerning, parseGsubLigatures, shapeText } from './opentype-layout.js';
 export type { KerningMap, LigatureMap, ShapedRun } from './opentype-layout.js';
 export { hasSubstitutable, lettersForLigature, substituteLetters } from './ligatures.js';
-export { createFontMeasure, shapeGlyphs } from './measure.js';
+export { createFontMeasure, shapeGlyphs, sharedGlyphCodes } from './measure.js';
 export type { FontMeasure } from './measure.js';
 export { buildTrueType, editableEmbedding, MAX_BUILT_GLYPHS } from './ttf-build.js';
 export type { BuiltFace, BuiltGlyph, BuiltKernPair, BuiltLigature, GlyphSeg, } from './ttf-build.js';

package/dist/esm/core/font/index.js

@@ -3,6 +3,6 @@ import { parseTtf } from "./ttf-parser.js";
 import { glyphClosure, subsetTtf } from "./ttf-subset.js";
 import { FontRegistry, pickVariant } from "./font-registry.js";
 import { hasSubstitutable, lettersForLigature, substituteLetters } from "./ligatures.js";
-import { createFontMeasure, shapeGlyphs } from "./measure.js";
+import { createFontMeasure, shapeGlyphs, sharedGlyphCodes } from "./measure.js";
 import { MAX_BUILT_GLYPHS, buildTrueType, editableEmbedding } from "./ttf-build.js";
-export { FontRegistry, MAX_BUILT_GLYPHS, buildTrueType, createFontMeasure, editableEmbedding, glyphClosure, hasSubstitutable, lettersForLigature, parseTtf, pickVariant, shapeGlyphs, subsetTtf, substituteLetters };
+export { FontRegistry, MAX_BUILT_GLYPHS, buildTrueType, createFontMeasure, editableEmbedding, glyphClosure, hasSubstitutable, lettersForLigature, parseTtf, pickVariant, shapeGlyphs, sharedGlyphCodes, subsetTtf, substituteLetters };

package/dist/esm/core/font/mark-shaper.d.ts

@@ -0,0 +1,27 @@
+import { IndicRun } from './indic-shaper.js';
+import { ParsedTtf } from './ttf-parser.js';
+/**
+ * Whether `text` holds a combining mark of the blocks Latin, Greek and
+ * Cyrillic letters take — the text {@link shapeMarks} is for.
+ *
+ * @param text The text.
+ */
+export declare function hasCombiningMark(text: string): boolean;
+/**
+ * Whether a code point is one of those marks.
+ *
+ * @param cp The code point.
+ */
+export declare function isCombiningMark(cp: number): boolean;
+/**
+ * Shape a run whose letters carry combining marks, in one face: the face's
+ * substitutions, then its positioning, the marks set on their letters.
+ *
+ * @param parsed The face.
+ * @param text   The text.
+ * @param kern   Whether to apply the face's `kern` feature (the layout profile decides).
+ * @returns The glyphs and where each stands, or `undefined` when the text holds
+ *          no such mark or the face has no positioning to set one with — the
+ *          caller's own shaping applies then.
+ */
+export declare function shapeMarks(parsed: ParsedTtf, text: string, kern?: boolean): IndicRun | undefined;

package/dist/esm/core/font/mark-shaper.js

@@ -0,0 +1,116 @@
+import { OtlFace, planLookups, position, substitute } from "./opentype-lookups.js";
+//#region src/core/font/mark-shaper.ts
+/**
+* The combining marks a Latin, Greek or Cyrillic letter takes: the Combining
+* Diacritical Marks and their Extended and Supplement blocks, the Cyrillic
+* combining marks, the marks for symbols and the half marks.
+*/
+var MARK_RANGES = [
+	[768, 879],
+	[1155, 1161],
+	[6832, 6911],
+	[7616, 7679],
+	[8400, 8447],
+	[65056, 65071]
+];
+/** OpenType GDEF GlyphClassDef — the class a mark glyph is given. */
+var MARK_CLASS = 3;
+/**
+* Whether `text` holds a combining mark of the blocks Latin, Greek and
+* Cyrillic letters take — the text {@link shapeMarks} is for.
+*
+* @param text The text.
+*/
+function hasCombiningMark(text) {
+	for (let i = 0; i < text.length; i++) if (isCombiningMark(text.charCodeAt(i))) return true;
+	return false;
+}
+/**
+* Whether a code point is one of those marks.
+*
+* @param cp The code point.
+*/
+function isCombiningMark(cp) {
+	if (cp < 768) return false;
+	for (const [lo, hi] of MARK_RANGES) if (cp >= lo && cp <= hi) return true;
+	return false;
+}
+/** The script tags a face's layout is looked up by, for the letters of `cps`. */
+function scriptTags(cps) {
+	for (const cp of cps) {
+		if (cp >= 1024 && cp <= 1327) return ["cyrl"];
+		if (cp >= 880 && cp <= 1023 || cp >= 7936 && cp <= 8191) return ["grek"];
+		if (cp >= 65 && cp <= 591 || cp >= 7680 && cp <= 7935) return ["latn"];
+	}
+	return ["latn"];
+}
+var feature = (tag) => ({
+	tag,
+	mask: 1
+});
+/**
+* Shape a run whose letters carry combining marks, in one face: the face's
+* substitutions, then its positioning, the marks set on their letters.
+*
+* @param parsed The face.
+* @param text   The text.
+* @param kern   Whether to apply the face's `kern` feature (the layout profile decides).
+* @returns The glyphs and where each stands, or `undefined` when the text holds
+*          no such mark or the face has no positioning to set one with — the
+*          caller's own shaping applies then.
+*/
+function shapeMarks(parsed, text, kern = true) {
+	if (!hasCombiningMark(text)) return void 0;
+	const face = OtlFace.of(parsed);
+	if (!face.gpos) return void 0;
+	const cps = [...text].map((ch) => ch.codePointAt(0));
+	const tags = scriptTags(cps);
+	let base = 0;
+	const buf = cps.map((cp, i) => {
+		const mark = i > 0 && isCombiningMark(cp);
+		if (!mark) base = i;
+		const gid = parsed.glyphForCodepoint(cp);
+		const cls = face.glyphClass(gid) || (mark ? MARK_CLASS : 1);
+		return {
+			gid,
+			cluster: base,
+			mask: 1,
+			cls,
+			syllable: 0,
+			ligId: 0,
+			ligComp: 0,
+			sources: [i]
+		};
+	});
+	substitute(face, planLookups(face.gsub, tags, [
+		"ccmp",
+		"liga",
+		"clig"
+	].map(feature)), buf);
+	const gpos = planLookups(face.gpos, tags, [
+		...kern ? ["kern"] : [],
+		"mark",
+		"mkmk"
+	].map(feature));
+	const pos = position(face, gpos, buf);
+	const run = {
+		gids: [],
+		clusters: [],
+		sources: [],
+		advances: [],
+		xOffsets: [],
+		yOffsets: []
+	};
+	buf.forEach((g, i) => {
+		const p = pos[i];
+		run.gids.push(g.gid);
+		run.clusters.push(g.cluster);
+		run.sources.push(g.sources ?? [g.cluster]);
+		run.advances.push(g.cls === MARK_CLASS ? 0 : p.xAdvance);
+		run.xOffsets.push(p.xOffset);
+		run.yOffsets.push(p.yOffset);
+	});
+	return run;
+}
+//#endregion
+export { hasCombiningMark, isCombiningMark, shapeMarks };

package/dist/esm/core/font/measure.d.ts

@@ -80,6 +80,22 @@ export declare function shapeGlyphs(parsed: ParsedTtf, text: string): {
     readonly gids: ReadonlyArray<number>;
     readonly glyphText?: ReadonlyMap<number, string>;
 };
+/**
+ * The characters a face's `cmap` sends to one glyph, when it sends more than
+ * one: a /ToUnicode can name only one of them, and which one is a question of
+ * what the document drew.
+ *
+ * Arimo, Tinos and Cousine draw the Latin schwa U+0259 and the Cyrillic one
+ * U+04D9 with the same glyph (U+018F and U+04D8 likewise), and a scan that
+ * keeps the first code reaching a glyph named it Latin: every "және" of a
+ * Kazakh document set in Arial read back as "жəне".
+ *
+ * @param parsed The face.
+ * @param gid    The glyph.
+ * @returns The code points mapped to it, lowest first, or `undefined` when at
+ *          most one is.
+ */
+export declare function sharedGlyphCodes(parsed: ParsedTtf, gid: number): ReadonlyArray<number> | undefined;
 /**
  * Build a {@link FontMeasure} over a parsed font.
  *

package/dist/esm/core/font/measure.js

@@ -1,5 +1,6 @@
 import { shapeText } from "./opentype-layout.js";
 import { hasIndic, shapeIndic } from "./indic-shaper.js";
+import { hasCombiningMark, shapeMarks } from "./mark-shaper.js";
 //#region src/core/font/measure.ts
 var EMPTY_KERNING = /* @__PURE__ */ new Map();
 /** The most shaped words a face keeps; past it the cache starts over. */
@@ -15,7 +16,7 @@ var SHAPED_CACHE = 4096;
 * @returns The glyph ids, and the text of each glyph no character reaches.
 */
 function shapeGlyphs(parsed, text) {
-	const run = hasIndic(text) ? shapeIndic(parsed, text) : void 0;
+	const run = hasIndic(text) ? shapeIndic(parsed, text) : hasCombiningMark(text) ? shapeMarks(parsed, text) : void 0;
 	if (!run) return { gids: shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, parsed.kerning, parsed.joiningForms).gids };
 	return {
 		gids: run.gids,
@@ -41,6 +42,25 @@ function namesOf(parsed) {
 	}
 	return names;
 }
+/**
+* The characters a face's `cmap` sends to one glyph, when it sends more than
+* one: a /ToUnicode can name only one of them, and which one is a question of
+* what the document drew.
+*
+* Arimo, Tinos and Cousine draw the Latin schwa U+0259 and the Cyrillic one
+* U+04D9 with the same glyph (U+018F and U+04D8 likewise), and a scan that
+* keeps the first code reaching a glyph named it Latin: every "және" of a
+* Kazakh document set in Arial read back as "жəне".
+*
+* @param parsed The face.
+* @param gid    The glyph.
+* @returns The code points mapped to it, lowest first, or `undefined` when at
+*          most one is.
+*/
+function sharedGlyphCodes(parsed, gid) {
+	const codes = namesOf(parsed).get(gid);
+	return codes !== void 0 && codes.length > 1 ? codes : void 0;
+}
 /** A character's canonical parts: क़ is क and the nukta, ো is ে and া. */
 var partsOf = (cp) => [...String.fromCodePoint(cp).normalize("NFD")].map((ch) => ch.codePointAt(0));
 var IGNORABLE_RE = /\p{Default_Ignorable_Code_Point}/u;
@@ -184,6 +204,18 @@ function createFontMeasure(parsed, kern = true) {
 				advances: run.advances,
 				indic: run
 			};
+		} else if (hasCombiningMark(text)) {
+			let run = indicRuns.get(text);
+			if (run === void 0) {
+				if (indicRuns.size >= SHAPED_CACHE) indicRuns.clear();
+				run = shapeMarks(parsed, text, kern) ?? null;
+				indicRuns.set(text, run);
+			}
+			if (run) return {
+				gids: run.gids,
+				advances: run.advances,
+				indic: run
+			};
 		}
 		return shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
 	};
@@ -343,4 +375,4 @@ function createFontMeasure(parsed, kern = true) {
 	};
 }
 //#endregion
-export { createFontMeasure, shapeGlyphs };
+export { createFontMeasure, shapeGlyphs, sharedGlyphCodes };

package/dist/esm/core/fonts/index.d.ts

@@ -1,3 +1,3 @@
-export { fetchFontSet, fetchScriptFont, isScriptKey, knowsFamily, resolveFamilyKey, resolveFamilyStyle, clearFontCache, } from './remote-fonts.js';
+export { companionOf, companionScale, fetchFontSet, fetchScriptFont, isScriptKey, knowsFamily, resolveFamilyKey, resolveFamilyStyle, clearFontCache, } from './remote-fonts.js';
 export { scriptForCodepoint, scriptsInFlow } from './scripts.js';
-export type { FamilyKey, FamilyStyle, FetchFontSetOptions, FetchLike, ScriptKey, SubstituteKey, } from './remote-fonts.js';
+export type { Companion, FamilyKey, FamilyStyle, FetchFontSetOptions, FetchLike, ScriptKey, SubstituteKey, } from './remote-fonts.js';

package/dist/esm/core/fonts/remote-fonts.d.ts

@@ -1,6 +1,10 @@
-import { FontBytesByVariant } from '../font/index.js';
-/** A curated open substitute family (the Croscore + Carlito/Caladea set, like LibreOffice). */
-export type FamilyKey = 'arimo' | 'tinos' | 'cousine' | 'carlito' | 'caladea';
+import { FontBytesByVariant, FontVariant } from '../font/index.js';
+/**
+ * A curated open substitute family (the Croscore + Carlito/Caladea set, like
+ * LibreOffice), or the family a twin borrows the letters it lacks from (see
+ * {@link companionOf}).
+ */
+export type FamilyKey = 'arimo' | 'tinos' | 'cousine' | 'carlito' | 'caladea' | 'notoserif';
 /**
  * A WRITING SYSTEM the curated five cannot draw at all. They are Latin families
  * — Greek, Cyrillic and Hebrew ride along, everything else is a notdef box —
@@ -26,6 +30,36 @@ export declare function isScriptKey(key: SubstituteKey): key is ScriptKey;
  * @returns The regular face, or `undefined` when the download fails.
  */
 export declare function fetchScriptFont(script: ScriptKey, fetchImpl?: FetchLike): Promise<FontBytesByVariant | undefined>;
+/**
+ * The letters a metric twin does not draw, and the family it borrows them
+ * from — squeezed, per writing system and face, to the width of the face the
+ * twin stands in for.
+ */
+export interface Companion {
+    /** The family that draws them. */
+    readonly family: FamilyKey;
+    /**
+     * The blocks it is borrowed for (inclusive ranges), each with the factor
+     * its advances are multiplied by in each face.
+     */
+    readonly ranges: ReadonlyArray<readonly [number, number, Readonly<Record<FontVariant, number>>]>;
+}
+/**
+ * The family a substitute borrows the letters it lacks from, if it borrows any.
+ *
+ * @param key The substitute.
+ * @returns Its companion, or `undefined`.
+ */
+export declare function companionOf(key: string): Companion | undefined;
+/**
+ * How much a companion squeezes a character it draws in a face.
+ *
+ * @param companion The companion.
+ * @param cp        The code point.
+ * @param variant   The face it is drawn in.
+ * @returns The factor, or `undefined` when the companion is not borrowed for it.
+ */
+export declare function companionScale(companion: Companion, cp: number, variant: FontVariant): number | undefined;
 /** A family name, read: which substitute it maps to and what it says about the face. */
 export interface FamilyStyle {
     readonly key: FamilyKey;

package/dist/esm/core/fonts/remote-fonts.js

@@ -109,8 +109,65 @@ var FAMILIES = {
 	caladea: {
 		pkg: "caladea",
 		file: "Caladea"
+	},
+	notoserif: {
+		pkg: "noto-serif",
+		file: "NotoSerif",
+		nested: true
 	}
 };
+var CAMBRIA_CYRILLIC = {
+	regular: .894,
+	bold: .918,
+	italic: .9,
+	boldItalic: .915
+};
+var CAMBRIA_GREEK = {
+	regular: .932,
+	bold: .953,
+	italic: .909,
+	boldItalic: .938
+};
+var COMPANIONS = { caladea: {
+	family: "notoserif",
+	ranges: [
+		[
+			880,
+			1023,
+			CAMBRIA_GREEK
+		],
+		[
+			1024,
+			1327,
+			CAMBRIA_CYRILLIC
+		],
+		[
+			7936,
+			8191,
+			CAMBRIA_GREEK
+		]
+	]
+} };
+/**
+* The family a substitute borrows the letters it lacks from, if it borrows any.
+*
+* @param key The substitute.
+* @returns Its companion, or `undefined`.
+*/
+function companionOf(key) {
+	return Object.hasOwn(COMPANIONS, key) ? COMPANIONS[key] : void 0;
+}
+/**
+* How much a companion squeezes a character it draws in a face.
+*
+* @param companion The companion.
+* @param cp        The code point.
+* @param variant   The face it is drawn in.
+* @returns The factor, or `undefined` when the companion is not borrowed for it.
+*/
+function companionScale(companion, cp, variant) {
+	for (const [lo, hi, scale] of companion.ranges) if (cp >= lo && cp <= hi) return scale[variant];
+}
 var EXACT = {
 	calibri: "carlito",
 	"calibri light": "carlito",
@@ -405,4 +462,4 @@ async function fetchFontSet(options = {}) {
 	};
 }
 //#endregion
-export { fetchFontSet, fetchScriptFont, knowsFamily, resolveFamilyKey, resolveFamilyStyle };
+export { companionOf, companionScale, fetchFontSet, fetchScriptFont, knowsFamily, resolveFamilyKey, resolveFamilyStyle };

package/dist/esm/core/fonts/scripts.d.ts

@@ -1,5 +1,5 @@
 import { FlowDoc } from '../ir/flow.js';
-import { ScriptKey } from './remote-fonts.js';
+import { FamilyKey, ScriptKey } from './remote-fonts.js';
 /**
  * The writing system a character needs a face for, or `undefined` when a Latin
  * family covers it.
@@ -43,3 +43,23 @@ export declare function scriptsInFlow(flow: FlowDoc): {
     scripts: Set<ScriptKey>;
     hanFace: ScriptKey;
 };
+/**
+ * Hand every run's text in a document to `read`: the body, the bands, the
+ * notes and the comments, the cells of a table, the text of every shape and
+ * of the drawings over a spreadsheet grid.
+ *
+ * @param flow The parsed document.
+ * @param read Called with each run's text.
+ */
+export declare function forEachTextInFlow(flow: FlowDoc, read: (text: string) => void): void;
+/**
+ * The companions a document's families need: those whose blocks its text
+ * holds a character of (see `companionOf`). A Cambria document in Russian
+ * needs Noto Serif for its letters; one in English does not, and is not sent
+ * for it.
+ *
+ * @param flow     The parsed document.
+ * @param families The substitute families it names.
+ * @returns The companion families to fetch.
+ */
+export declare function companionsInFlow(flow: FlowDoc, families: Iterable<FamilyKey>): Set<FamilyKey>;

package/dist/esm/core/fonts/scripts.js

@@ -1,3 +1,4 @@
+import { companionOf } from "./remote-fonts.js";
 //#region src/core/fonts/scripts.ts
 var RANGES = [
 	[
@@ -252,6 +253,23 @@ function scriptsInFlow(flow) {
 			scripts.add(key);
 		}
 	};
+	forEachTextInFlow(flow, read);
+	const hanFace = scripts.has("jp") ? "jp" : scripts.has("kr") ? "kr" : "sc";
+	if (marks.has("han")) scripts.add(hanFace);
+	return {
+		scripts,
+		hanFace
+	};
+}
+/**
+* Hand every run's text in a document to `read`: the body, the bands, the
+* notes and the comments, the cells of a table, the text of every shape and
+* of the drawings over a spreadsheet grid.
+*
+* @param flow The parsed document.
+* @param read Called with each run's text.
+*/
+function forEachTextInFlow(flow, read) {
 	const shapeText = (shape) => {
 		if (shape.text) visit(shape.text.content);
 		for (const child of shape.children ?? []) shapeText(child.shape);
@@ -268,12 +286,33 @@ function scriptsInFlow(flow) {
 	for (const note of flow.footnotes?.values() ?? []) visit(note);
 	for (const note of flow.endnotes?.values() ?? []) visit(note);
 	for (const comment of flow.comments?.values() ?? []) visit(comment.content);
-	const hanFace = scripts.has("jp") ? "jp" : scripts.has("kr") ? "kr" : "sc";
-	if (marks.has("han")) scripts.add(hanFace);
-	return {
-		scripts,
-		hanFace
-	};
+}
+/**
+* The companions a document's families need: those whose blocks its text
+* holds a character of (see `companionOf`). A Cambria document in Russian
+* needs Noto Serif for its letters; one in English does not, and is not sent
+* for it.
+*
+* @param flow     The parsed document.
+* @param families The substitute families it names.
+* @returns The companion families to fetch.
+*/
+function companionsInFlow(flow, families) {
+	const wanted = [...families].flatMap((key) => {
+		const companion = companionOf(key);
+		return companion ? [companion] : [];
+	});
+	const out = /* @__PURE__ */ new Set();
+	if (wanted.length === 0) return out;
+	forEachTextInFlow(flow, (text) => {
+		if (out.size === wanted.length) return;
+		for (const ch of text) {
+			const cp = ch.codePointAt(0) ?? 0;
+			if (cp < 880) continue;
+			for (const c of wanted) if (c.ranges.some(([lo, hi]) => cp >= lo && cp <= hi)) out.add(c.family);
+		}
+	});
+	return out;
 }
 //#endregion
-export { fontSlotOf, scriptForCodepoint, scriptsInFlow };
+export { companionsInFlow, fontSlotOf, forEachTextInFlow, scriptForCodepoint, scriptsInFlow };

package/dist/esm/html/html-writer.js

@@ -528,10 +528,15 @@ function fontStack(family) {
 /** What follows a family in its stack, by the open substitute it maps to. */
 var FALLBACKS = {
 	carlito: ["Carlito", "sans-serif"],
-	caladea: ["Caladea", "serif"],
+	caladea: [
+		"Caladea",
+		"Noto Serif",
+		"serif"
+	],
 	arimo: ["sans-serif"],
 	tinos: ["serif"],
-	cousine: ["monospace"]
+	cousine: ["monospace"],
+	notoserif: ["Noto Serif", "serif"]
 };
 function decorationStyle(u) {
 	switch (u) {

package/dist/esm/layout/line-paint.d.ts

@@ -19,8 +19,8 @@ export declare const BORDER_DASHES: ReadonlyMap<BorderStyle, ReadonlyArray<numbe
 export declare function lineVisualOrder(line: Line): Array<number>;
 /**
  * The extra width each space of a justified line takes — 0 for a line that is
- * not justified, or the last line of a paragraph (which stays flush by
- * convention).
+ * not justified. The last line of a paragraph stays flush by convention: it is
+ * never stretched, only pulled in where the breaker packed it past the measure.
  *
  * @param line The laid-out line.
  * @returns Points added to (or, squeezed, taken from) each space token.

package/dist/esm/layout/line-paint.js

@@ -41,8 +41,8 @@ function lineVisualOrder(line) {
 }
 /**
 * The extra width each space of a justified line takes — 0 for a line that is
-* not justified, or the last line of a paragraph (which stays flush by
-* convention).
+* not justified. The last line of a paragraph stays flush by convention: it is
+* never stretched, only pulled in where the breaker packed it past the measure.
 *
 * @param line The laid-out line.
 * @returns Points added to (or, squeezed, taken from) each space token.
@@ -50,8 +50,7 @@ function lineVisualOrder(line) {
 function computeJustifyExtra(line) {
 	const alignment = line.resolved.alignment;
 	if (alignment !== "both" && alignment !== "distribute") return 0;
-	if (line.noJustify === true) return 0;
-	if (line.isLastInParagraph && alignment !== "distribute") return 0;
+	const flush = line.noJustify === true || line.isLastInParagraph && alignment !== "distribute";
 	let last = line.tokens.length - 1;
 	while (last >= 0 && line.tokens[last].kind === "text" && line.tokens[last].isSpace) last--;
 	let spaces = 0;
@@ -66,7 +65,8 @@ function computeJustifyExtra(line) {
 	}
 	if (spaces === 0) return 0;
 	const extra = (line.availableWidthPt - contentWidthPt) / spaces;
-	return extra < 0 ? Math.max(extra, -narrowest * GLUE_SHRINK_RATIO) : extra;
+	if (extra < 0) return Math.max(extra, -narrowest * GLUE_SHRINK_RATIO);
+	return flush ? 0 : extra;
 }
 /**
 * Whether a line is ONE text matrix and a run of glyphs: nothing in it placed

package/dist/esm/layout/page-doc.d.ts

@@ -21,6 +21,12 @@ export interface FontResource {
      * a reph, a vowel sign's contextual form — for the PDF's /ToUnicode.
      */
     readonly glyphText?: ReadonlyMap<number, string>;
+    /**
+     * For each collected glyph several characters share in the face's `cmap`,
+     * the one the document drew it for most often — what the PDF's /ToUnicode
+     * names it (see `sharedGlyphCodes`).
+     */
+    readonly glyphChars?: ReadonlyMap<number, number>;
 }
 /**
  * The face a run asked for and the registry could not give — what the page has