reamkit 1.22.0 → 1.23.0

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

@@ -143,6 +143,22 @@ export declare class Ream {
      * @returns The font bytes and, for docx, optional per-family registries.
      */
     private resolveFonts;
+    /**
+     * Fetch one face per writing system the document holds text in — the curated
+     * families are Latin, and Han, Kana, Hangul, Arabic and the geometric symbols
+     * are a notdef box in every one of them.
+     *
+     * Only the regular weight is fetched: Noto Sans SC is ten megabytes, and a
+     * bold run in it is better stroked (see `SyntheticFace`) than downloaded four
+     * times over. A face that fails to arrive is a recorded loss, not a throw —
+     * the rest of the document still renders.
+     *
+     * @param into    The registry map the run resolver looks in.
+     * @param flow    The parsed document.
+     * @param options The convert options (for the injectable `fetch`).
+     * @param losses  Where a face that could not be fetched records itself.
+     */
+    private addScriptFonts;
     /**
      * In strict mode, throw {@link ConversionLossError} for the first recorded loss.
      *

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

@@ -1,4 +1,5 @@
-import { fetchFontSet } from "../fonts/remote-fonts.js";
+import { fetchFontSet, fetchScriptFont, resolveFamilyKey } from "../fonts/remote-fonts.js";
+import { scriptsInFlow } from "../fonts/scripts.js";
 import { FontRegistry } from "../font/font-registry.js";
 import { createFontMeasure } from "../font/measure.js";
 import { ConversionLossError } from "../ir/loss.js";
@@ -12,8 +13,8 @@ import { writeDocx } from "../../word/docx-writer.js";
 import { writeXlsx } from "../../excel/xlsx-writer.js";
 import { writeHtml } from "../../html/html-writer.js";
 import { writeSvg } from "../../svg/svg-writer.js";
-import { resolveDocxAutoFonts } from "../../word/docx-to-pdf.js";
 import { DEFAULT_READERS, resolveFontsViaChain, toFlowDoc } from "./facade.js";
+import { familiesInFlow } from "../fonts/families.js";
 import { decryptPackage, isEncryptedPackage } from "../crypto/offcrypto.js";
 //#region src/core/converter/ream.ts
 /**
@@ -150,7 +151,7 @@ var Ream = class Ream {
 				losses
 			};
 		}
-		const { fonts, registriesByFamily } = await this.resolveFonts(options, losses);
+		const { fonts, registriesByFamily } = await this.resolveFonts(options, losses, flow);
 		const registry = FontRegistry.fromBytes(fonts);
 		const paginated = this.sheet ? projectSheetDoc(this.sheet, {
 			...options.now ? { now: options.now } : {},
@@ -209,7 +210,7 @@ var Ream = class Ream {
 	* @param losses  The mutable loss list a substitution is appended to.
 	* @returns The font bytes and, for docx, optional per-family registries.
 	*/
-	async resolveFonts(options, losses) {
+	async resolveFonts(options, losses, flow) {
 		const explicit = options.fonts ?? (options.fontBytes ? { regular: options.fontBytes } : void 0);
 		if (explicit) return { fonts: explicit };
 		if (options.fontProviders && options.fontProviders.length > 0) {
@@ -217,11 +218,60 @@ var Ream = class Ream {
 			if (loss) losses.push(loss);
 			if (fonts) return { fonts };
 		}
-		if (this.readerId === "docx") return resolveDocxAutoFonts(this.source, options);
-		return { fonts: await fetchFontSet({
-			...options.fontFamily ? { family: options.fontFamily } : {},
-			...options.fontFetch ? { fetch: options.fontFetch } : {}
-		}) };
+		const fetchOpt = options.fontFetch ? { fetch: options.fontFetch } : {};
+		const keys = options.fontFamily ? new Set([resolveFamilyKey(options.fontFamily)]) : familiesInFlow(flow);
+		if (keys.size <= 1 && scriptsInFlow(flow).scripts.size === 0) {
+			const family = keys.values().next().value;
+			return { fonts: await fetchFontSet({
+				...family ? { family } : {},
+				...fetchOpt
+			}) };
+		}
+		const registriesByFamily = /* @__PURE__ */ new Map();
+		let baseBytes;
+		for (const key of keys) {
+			const bytes = await fetchFontSet({
+				family: key,
+				...fetchOpt
+			});
+			registriesByFamily.set(key, FontRegistry.fromBytes(bytes));
+			if (key === "arimo" || !baseBytes) baseBytes = bytes;
+		}
+		await this.addScriptFonts(registriesByFamily, flow, options, losses);
+		return {
+			fonts: baseBytes,
+			registriesByFamily
+		};
+	}
+	/**
+	* Fetch one face per writing system the document holds text in — the curated
+	* families are Latin, and Han, Kana, Hangul, Arabic and the geometric symbols
+	* are a notdef box in every one of them.
+	*
+	* Only the regular weight is fetched: Noto Sans SC is ten megabytes, and a
+	* bold run in it is better stroked (see `SyntheticFace`) than downloaded four
+	* times over. A face that fails to arrive is a recorded loss, not a throw —
+	* the rest of the document still renders.
+	*
+	* @param into    The registry map the run resolver looks in.
+	* @param flow    The parsed document.
+	* @param options The convert options (for the injectable `fetch`).
+	* @param losses  Where a face that could not be fetched records itself.
+	*/
+	async addScriptFonts(into, flow, options, losses) {
+		const { scripts } = scriptsInFlow(flow);
+		for (const script of scripts) {
+			const bytes = await fetchScriptFont(script, options.fontFetch);
+			if (!bytes) {
+				losses.push({
+					feature: "font",
+					detail: `no face could be fetched for the ${script} script; its text draws as boxes`,
+					severity: "substituted"
+				});
+				continue;
+			}
+			into.set(script, FontRegistry.fromBytes(bytes));
+		}
 	}
 	/**
 	* In strict mode, throw {@link ConversionLossError} for the first recorded loss.

package/dist/esm/core/document-model/types.d.ts

@@ -1025,6 +1025,24 @@ export interface ShapeFill {
      * text box: stretched, such a fill is a blur where it should be a pattern.
      */
     readonly tiled?: boolean;
+    /**
+     * The size ONE copy of a tiled fill occupies, when the shape states it —
+     * MS-ODRAW §2.3.7.11/.12 `fillWidth` / `fillHeight`. Absent, a tile is the
+     * picture at its own resolution, which is the default both formats give.
+     */
+    readonly tileSizePt?: {
+        readonly widthPt: number;
+        readonly heightPt: number;
+    };
+    /**
+     * §20.1.8.58 `a:tile @sx @sy` — how far the picture is scaled BEFORE it is
+     * repeated, as fractions of its own size (1 = 100 %). A texture halved tiles
+     * four times as often, and read as a plain repeat it tiles once.
+     */
+    readonly tileScale?: {
+        readonly sx: number;
+        readonly sy: number;
+    };
     /**
      * §20.1.8.14 `a:blipFill` — the picture painted across the shape's box. A
      * DrawingML picture IS a shape with one of these, which is how a `pic:pic`

package/dist/esm/core/drawingml/chart-geometry.js

@@ -46,7 +46,7 @@ function niceScale(dataMin, dataMax, maxTicks = 6) {
 	const lo = Math.min(dataMin, dataMax);
 	let hi = Math.max(dataMin, dataMax);
 	if (lo === hi) hi = lo + 1;
-	const step = niceNum(niceNum(hi - lo, false) / Math.max(1, maxTicks - 1), true);
+	const step = niceNum((hi - lo) / Math.max(1, maxTicks - 1), true);
 	const headroom = hi > 0 ? hi * 1.05 : hi;
 	return {
 		min: Math.floor(lo / step) * step,
@@ -712,11 +712,17 @@ function autoRange(vals) {
 	return [lo > 0 && lo < 5 / 6 * hi ? 0 : lo, hi];
 }
 /**
-* Ticks that fit along an axis `extentPt` long (mirrors {@link axisScale}).
-* A tick every 32pt is what both references draw: at 24 a 250pt plot carried
-* eleven of them (0, 0.5, 1 … 5.5) where both label 0…6 in whole numbers.
+* How many ticks an axis `extentPt` long carries (mirrors {@link axisScale}).
+*
+* A tall axis takes more of them — a fixed six drew 0/100/200/300 down a plot
+* where both references fit 0/50/…/300 — but the appetite is milder than it
+* looks: asked for one every 32pt, a 427pt chart wanted ten, and Excel labels
+* that chart's 0…5 data 0/1/…/6 where we drew half-steps (chart-texture-bg
+* .pptx). One per ~48pt and never more than eight satisfies both, now that
+* {@link niceScale} measures its step against the range the data spans rather
+* than against Heckbert's rounded-up one.
 */
-var tickBudget = (extentPt) => Math.min(10, Math.max(4, Math.round(extentPt / 32)));
+var tickBudget = (extentPt) => Math.min(8, Math.max(4, Math.round(extentPt / 48)));
 /** Side (points) of the square stamped for a series that names no symbol. */
 var DEFAULT_MARKER_PT = 4;
 /**

package/dist/esm/core/drawingml/colors.d.ts

@@ -3,10 +3,12 @@ import { PoNode } from '../po-helpers.js';
  * A colour transform child (§20.1.2.3): `lumMod`/`lumOff` modulate luminance,
  * `shade` darkens toward black, `tint` lightens toward white. `val` is normalised
  * to 0..1 (the XML stores thousandths of a percent). `alpha` composites over white
- * (solid fills emit no transparency).
+ * (solid fills emit no transparency). `gamma`/`invGamma` carry no value: they
+ * shift the colour into the other light and back, which changes what the
+ * transforms between them mean.
  */
 export interface ColorMod {
-    readonly kind: 'lumMod' | 'lumOff' | 'shade' | 'tint' | 'alpha' | 'satMod' | 'hueMod' | 'hueOff' | 'satOff';
+    readonly kind: 'lumMod' | 'lumOff' | 'shade' | 'tint' | 'alpha' | 'satMod' | 'hueMod' | 'hueOff' | 'satOff' | 'gamma' | 'invGamma';
     readonly val: number;
 }
 /**

package/dist/esm/core/drawingml/colors.js

@@ -99,6 +99,13 @@ function applyColorMods(hex, mods) {
 		r = toSrgb(toLinear(r) * m.val + (1 - m.val));
 		g = toSrgb(toLinear(g) * m.val + (1 - m.val));
 		b = toSrgb(toLinear(b) * m.val + (1 - m.val));
+	} else if (m.kind === "gamma" || m.kind === "invGamma") {
+		const shift = m.kind === "gamma" ? toSrgb : toLinear;
+		[r, g, b] = [
+			shift(r),
+			shift(g),
+			shift(b)
+		];
 	} else if (m.kind === "lumMod" || m.kind === "lumOff") {
 		const [h, s, l] = rgbToHsl(r, g, b);
 		const l2 = m.kind === "lumMod" ? l * m.val : clamp01(l + m.val);
@@ -230,6 +237,14 @@ function readColorMods(colorNode) {
 				val: v / 1e5
 			});
 		}
+		if (poIs(c, "a:gamma")) mods.push({
+			kind: "gamma",
+			val: 0
+		});
+		if (poIs(c, "a:invGamma")) mods.push({
+			kind: "invGamma",
+			val: 0
+		});
 		if (poIs(c, "a:hueOff")) {
 			const v = poIntAttr(c, "val");
 			if (v !== void 0) mods.push({

package/dist/esm/core/drawingml/theme-parser.d.ts

@@ -1,4 +1,42 @@
 import { PoNode } from '../po-helpers.js';
+/**
+ * §20.1.4.1.16 `a:fontScheme` — the two typefaces a theme names, each in three
+ * scripts. A document does not repeat them: it refers to them by TOKEN
+ * (`+mj-lt`, `+mn-ea`, …), which every reader is expected to resolve.
+ */
+export interface ThemeFonts {
+    /** `a:majorFont` — headings. */
+    readonly major: ThemeFontSlots;
+    /** `a:minorFont` — body text. */
+    readonly minor: ThemeFontSlots;
+}
+/** One font of a scheme, in the three scripts a run may pick from. */
+export interface ThemeFontSlots {
+    readonly latin?: string;
+    readonly ea?: string;
+    readonly cs?: string;
+}
+/**
+ * Parse a theme's font scheme (§20.1.4.1.16).
+ *
+ * @param themeXml The raw theme part bytes, UTF-8.
+ * @returns The two fonts; slots the theme leaves empty are absent.
+ */
+export declare function parseThemeFonts(themeXml: Uint8Array): ThemeFonts;
+/**
+ * Resolve a typeface written as a theme TOKEN to the name it stands for.
+ *
+ * A slide states its fonts as `+mn-lt` far more often than by name, and left
+ * unresolved that string travels into the model as if it WERE a typeface: no
+ * substitution table knows it, so a deck whose theme is Times came out in a
+ * grotesque (45541_Header).
+ *
+ * @param typeface The `@typeface` as the file writes it.
+ * @param fonts    The theme's font scheme, when the part was read.
+ * @returns The resolved name; the input unchanged when it is not a token, and
+ *          `undefined` when it is a token the theme leaves empty.
+ */
+export declare function resolveThemeFont(typeface: string | undefined, fonts: ThemeFonts | undefined): string | undefined;
 /**
  * Parse a DrawingML theme part (ECMA-376 §20.1.6.2, `a:clrScheme`) into a
  * `name → hex` colour map. Reads the twelve scheme slots — `dk1`/`lt1`/`dk2`/

package/dist/esm/core/drawingml/theme-parser.js

@@ -26,6 +26,69 @@ var SCHEME_SLOTS = new Set([
 	"folHlink"
 ]);
 /**
+* Parse a theme's font scheme (§20.1.4.1.16).
+*
+* @param themeXml The raw theme part bytes, UTF-8.
+* @returns The two fonts; slots the theme leaves empty are absent.
+*/
+function parseThemeFonts(themeXml) {
+	const scheme = poFindByPath(parser.parse(decoder.decode(themeXml)), [
+		"a:theme",
+		"a:themeElements",
+		"a:fontScheme"
+	]);
+	const read = (tag) => {
+		const font = scheme ? poChildren(scheme).find((c) => poIs(c, tag)) : void 0;
+		const slot = (name) => {
+			const node = font ? poChildren(font).find((c) => poIs(c, name)) : void 0;
+			const face = node ? poAttr(node, "typeface")?.trim() : void 0;
+			return face === void 0 || face === "" ? void 0 : face;
+		};
+		const [latin, ea, cs] = [
+			slot("a:latin"),
+			slot("a:ea"),
+			slot("a:cs")
+		];
+		return {
+			...latin !== void 0 ? { latin } : {},
+			...ea !== void 0 ? { ea } : {},
+			...cs !== void 0 ? { cs } : {}
+		};
+	};
+	return {
+		major: read("a:majorFont"),
+		minor: read("a:minorFont")
+	};
+}
+var THEME_FONT_TOKENS = new Map([
+	["+mj-lt", ["major", "latin"]],
+	["+mn-lt", ["minor", "latin"]],
+	["+mj-ea", ["major", "ea"]],
+	["+mn-ea", ["minor", "ea"]],
+	["+mj-cs", ["major", "cs"]],
+	["+mn-cs", ["minor", "cs"]]
+]);
+/**
+* Resolve a typeface written as a theme TOKEN to the name it stands for.
+*
+* A slide states its fonts as `+mn-lt` far more often than by name, and left
+* unresolved that string travels into the model as if it WERE a typeface: no
+* substitution table knows it, so a deck whose theme is Times came out in a
+* grotesque (45541_Header).
+*
+* @param typeface The `@typeface` as the file writes it.
+* @param fonts    The theme's font scheme, when the part was read.
+* @returns The resolved name; the input unchanged when it is not a token, and
+*          `undefined` when it is a token the theme leaves empty.
+*/
+function resolveThemeFont(typeface, fonts) {
+	if (typeface === void 0 || !typeface.startsWith("+")) return typeface;
+	const slot = THEME_FONT_TOKENS.get(typeface.toLowerCase());
+	if (!slot || !fonts) return void 0;
+	const [which, script] = slot;
+	return fonts[which][script];
+}
+/**
 * Parse a DrawingML theme part (ECMA-376 §20.1.6.2, `a:clrScheme`) into a
 * `name → hex` colour map. Reads the twelve scheme slots — `dk1`/`lt1`/`dk2`/
 * `lt2`, `accent1`–`accent6`, `hlink`/`folHlink` — taking each slot's
@@ -154,4 +217,4 @@ function colorOf(slot) {
 	}
 }
 //#endregion
-export { parseTheme, parseThemeBgFillStyles, parseThemeEffectStyles, parseThemeFillStyles, parseThemeLineWidths };
+export { parseTheme, parseThemeBgFillStyles, parseThemeEffectStyles, parseThemeFillStyles, parseThemeFonts, parseThemeLineWidths, resolveThemeFont };

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

@@ -0,0 +1,10 @@
+import { FamilyKey } from './remote-fonts.js';
+import { FlowDoc } from '../ir/flow.js';
+/**
+ * The curated substitute families a document's text needs, always including the
+ * sans default as the fallback for unstyled runs, math and chart labels.
+ *
+ * @param flow The parsed document.
+ * @returns One {@link FamilyKey} per distinct family the document names.
+ */
+export declare function familiesInFlow(flow: FlowDoc): Set<FamilyKey>;

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

@@ -0,0 +1,44 @@
+import { resolveFamilyKey } from "./remote-fonts.js";
+//#region src/core/fonts/families.ts
+/**
+* The curated substitute families a document's text needs, always including the
+* sans default as the fallback for unstyled runs, math and chart labels.
+*
+* @param flow The parsed document.
+* @returns One {@link FamilyKey} per distinct family the document names.
+*/
+function familiesInFlow(flow) {
+	const names = /* @__PURE__ */ new Set();
+	const add = (name) => {
+		if (name !== void 0 && name.trim() !== "") names.add(name.trim().toLowerCase());
+	};
+	add(flow.styles.defaultRunProperties.fontFamily?.ascii);
+	for (const style of flow.styles.styles.values()) {
+		add(style.runProperties.fontFamily?.ascii);
+		add(style.paragraphProperties.runProperties?.fontFamily?.ascii);
+		add(style.tableLayer?.runProperties?.fontFamily?.ascii);
+		for (const c of style.tableConditions ?? []) add(c.layer.runProperties?.fontFamily?.ascii);
+	}
+	for (const abstract of flow.numbering?.abstractNums.values() ?? []) for (const level of abstract.levels.values()) add(level.runProperties.fontFamily?.ascii);
+	const shapeText = (shape) => {
+		if (shape.text) visit(shape.text.content);
+		for (const child of shape.children ?? []) shapeText(child.shape);
+	};
+	const visit = (elements) => {
+		for (const el of elements) if (el.kind === "paragraph") {
+			add(el.paragraph.properties.runProperties?.fontFamily?.ascii);
+			for (const run of el.paragraph.runs) add(run.properties.fontFamily?.ascii);
+		} else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
+		else if (el.kind === "shape") shapeText(el.shape);
+	};
+	visit(flow.body);
+	for (const band of flow.headersFooters?.values() ?? []) visit(band);
+	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 keys = new Set(["arimo"]);
+	for (const name of names) keys.add(resolveFamilyKey(name));
+	return keys;
+}
+//#endregion
+export { familiesInFlow };

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

@@ -1,2 +1,3 @@
-export { fetchFontSet, resolveFamilyKey, clearFontCache } from './remote-fonts.js';
-export type { FamilyKey, FetchFontSetOptions, FetchLike } from './remote-fonts.js';
+export { fetchFontSet, fetchScriptFont, isScriptKey, 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';

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

@@ -1,11 +1,61 @@
 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';
+/**
+ * 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 —
+ * and 2145 characters of the corpus fall outside them: Han, Kana, Hangul,
+ * Arabic, the geometric symbols a form's checkbox is made of.
+ *
+ * These are fetched only when a document actually holds such a character, and
+ * only in the regular weight: Noto Sans SC is ten megabytes, and a bold run in
+ * it is better stroked (see `SyntheticFace`) than downloaded four times over.
+ */
+export type ScriptKey = 'jp' | 'kr' | 'sc' | 'arabic' | 'hebrew' | 'thai' | 'symbols';
+/** Either kind of substitute — a Latin family or a per-script face. */
+export type SubstituteKey = FamilyKey | ScriptKey;
+/** Whether a substitute key names a writing system rather than a Latin family. */
+export declare function isScriptKey(key: SubstituteKey): key is ScriptKey;
+/**
+ * Fetch the ONE face a writing system is drawn with.
+ *
+ * @param script The writing system.
+ * @param fetchImpl Injectable `fetch` (defaults to the global one).
+ * @returns The regular face, or `undefined` when the download fails.
+ */
+export declare function fetchScriptFont(script: ScriptKey, fetchImpl?: FetchLike): Promise<FontBytesByVariant | undefined>;
+/** A family name, read: which substitute it maps to and what it says about the face. */
+export interface FamilyStyle {
+    readonly key: FamilyKey;
+    /** The NAME asks for a heavy face (`Arial Black`, `DIN-Bold`). */
+    readonly bold?: boolean;
+    /** …or a slanted one (`Frutiger Oblique`). */
+    readonly italic?: boolean;
+    /**
+     * …or a narrow one (`Arial Narrow`), as the fraction of the normal advance it
+     * sets at. No curated family ships a condensed cut, so the substitute is
+     * squeezed instead — Arial Narrow's own widths are 82 % of Arial's, which is
+     * also what LibreOffice's Liberation Sans Narrow reproduces.
+     */
+    readonly widthScale?: number;
+}
 /**
  * Map a document-referenced font family to a curated open substitute: an exact
  * metric twin when one is known (e.g. Calibri → Carlito), otherwise a
  * serif/mono/sans style fallback.
  *
+ * The name may also carry the FACE — `Times New Roman Bold` is the Times
+ * family, and read whole it matches no twin at all and fell through to the
+ * generic sans, which is how a Times heading came out in a grotesque.
+ *
+ * @param name The referenced family name (case-insensitive); empty ⇒ Arimo.
+ * @returns The chosen family and what the name said about the face.
+ */
+export declare function resolveFamilyStyle(name: string | undefined): FamilyStyle;
+/**
+ * The curated substitute for a family name — {@link resolveFamilyStyle} without
+ * the face it also carries.
+ *
  * @param name The referenced family name (case-insensitive); empty ⇒ Arimo.
  * @returns The chosen {@link FamilyKey}.
  */

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

@@ -6,6 +6,48 @@ var VARIANT_SUFFIX = {
 	italic: "400Regular_Italic",
 	boldItalic: "700Bold_Italic"
 };
+var SCRIPTS = {
+	jp: {
+		pkg: "noto-sans-jp",
+		file: "NotoSansJP"
+	},
+	kr: {
+		pkg: "noto-sans-kr",
+		file: "NotoSansKR"
+	},
+	sc: {
+		pkg: "noto-sans-sc",
+		file: "NotoSansSC"
+	},
+	arabic: {
+		pkg: "noto-sans-arabic",
+		file: "NotoSansArabic"
+	},
+	hebrew: {
+		pkg: "noto-sans-hebrew",
+		file: "NotoSansHebrew"
+	},
+	thai: {
+		pkg: "noto-sans-thai",
+		file: "NotoSansThai"
+	},
+	symbols: {
+		pkg: "noto-sans-symbols-2",
+		file: "NotoSansSymbols2"
+	}
+};
+/**
+* Fetch the ONE face a writing system is drawn with.
+*
+* @param script The writing system.
+* @param fetchImpl Injectable `fetch` (defaults to the global one).
+* @returns The regular face, or `undefined` when the download fails.
+*/
+async function fetchScriptFont(script, fetchImpl = globalThis.fetch.bind(globalThis)) {
+	const family = SCRIPTS[script];
+	const bytes = await fetchTtf(`${CDN_BASE}/${family.pkg}/400Regular/${family.file}_400Regular.ttf`, fetchImpl, false);
+	return bytes ? { regular: bytes } : void 0;
+}
 var FAMILIES = {
 	arimo: {
 		pkg: "arimo",
@@ -31,6 +73,7 @@ var FAMILIES = {
 };
 var EXACT = {
 	calibri: "carlito",
+	"calibri light": "carlito",
 	cambria: "caladea",
 	arial: "arimo",
 	helvetica: "arimo",
@@ -59,22 +102,85 @@ var MONO = new Set([
 	"dejavu sans mono",
 	"monospace"
 ]);
+var WEIGHT_WORDS = new Map([
+	["black", "bold"],
+	["heavy", "bold"],
+	["bold", "bold"],
+	["semibold", "bold"],
+	["demibold", "bold"],
+	["demi", "bold"],
+	["italic", "italic"],
+	["oblique", "italic"],
+	["light", "none"],
+	["thin", "none"],
+	["medium", "none"],
+	["regular", "none"],
+	["book", "none"],
+	["narrow", "narrow"],
+	["condensed", "narrow"],
+	["cond", "narrow"],
+	["expanded", "none"],
+	["extra", "none"],
+	["ultra", "none"],
+	["pro", "none"]
+]);
+/** Arial Narrow's advance widths, as a fraction of Arial's. */
+var NARROW_SCALE = .82;
 /**
 * Map a document-referenced font family to a curated open substitute: an exact
 * metric twin when one is known (e.g. Calibri → Carlito), otherwise a
 * serif/mono/sans style fallback.
 *
+* The name may also carry the FACE — `Times New Roman Bold` is the Times
+* family, and read whole it matches no twin at all and fell through to the
+* generic sans, which is how a Times heading came out in a grotesque.
+*
+* @param name The referenced family name (case-insensitive); empty ⇒ Arimo.
+* @returns The chosen family and what the name said about the face.
+*/
+function resolveFamilyStyle(name) {
+	if (!name) return { key: "arimo" };
+	const words = name.trim().toLowerCase().split(/[\s\-_,]+/u).filter((w) => w !== "");
+	let bold = false;
+	let italic = false;
+	let narrow = false;
+	while (words.length > 1) {
+		const word = WEIGHT_WORDS.get(words[words.length - 1]);
+		if (word === void 0) break;
+		if (word === "bold") bold = true;
+		if (word === "italic") italic = true;
+		if (word === "narrow") narrow = true;
+		words.pop();
+	}
+	const tries = [
+		words.join(" "),
+		words[words.length - 1],
+		words[0]
+	];
+	let key = "arimo";
+	for (const n of tries) {
+		const found = EXACT[n] ?? (MONO.has(n) ? "cousine" : SERIF.has(n) ? "tinos" : void 0);
+		if (found) {
+			key = found;
+			break;
+		}
+	}
+	return {
+		key,
+		...bold ? { bold } : {},
+		...italic ? { italic } : {},
+		...narrow ? { widthScale: NARROW_SCALE } : {}
+	};
+}
+/**
+* The curated substitute for a family name — {@link resolveFamilyStyle} without
+* the face it also carries.
+*
 * @param name The referenced family name (case-insensitive); empty ⇒ Arimo.
 * @returns The chosen {@link FamilyKey}.
 */
 function resolveFamilyKey(name) {
-	if (!name) return "arimo";
-	const n = name.trim().toLowerCase();
-	const exact = EXACT[n];
-	if (exact) return exact;
-	if (MONO.has(n)) return "cousine";
-	if (SERIF.has(n)) return "tinos";
-	return "arimo";
+	return resolveFamilyStyle(name).key;
 }
 function fontUrl(family, variant) {
 	const suffix = VARIANT_SUFFIX[variant];
@@ -128,4 +234,4 @@ async function fetchFontSet(options = {}) {
 	};
 }
 //#endregion
-export { fetchFontSet, resolveFamilyKey };
+export { fetchFontSet, fetchScriptFont, resolveFamilyKey, resolveFamilyStyle };

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

@@ -0,0 +1,26 @@
+import { FlowDoc } from '../ir/flow.js';
+import { ScriptKey } from './remote-fonts.js';
+/**
+ * The writing system a character needs a face for, or `undefined` when a Latin
+ * family covers it.
+ *
+ * @param cp       The code point.
+ * @param hanFace  Which face draws unified Han in this document (see
+ *                 {@link scriptsInFlow}); defaults to Simplified.
+ */
+export declare function scriptForCodepoint(cp: number, hanFace?: ScriptKey): ScriptKey | undefined;
+/**
+ * The writing systems a document holds text in, beside the Latin one.
+ *
+ * Unified Han is written the same in Japanese, Korean and Chinese and drawn
+ * differently in each, and the character does not say which — the document
+ * does: Kana beside it means Japanese, Hangul means Korean. So the whole text
+ * is read once, and the answer applies to every Han character in it.
+ *
+ * @param flow The parsed document.
+ * @returns The scripts to fetch a face for, and the one Han is drawn with.
+ */
+export declare function scriptsInFlow(flow: FlowDoc): {
+    scripts: Set<ScriptKey>;
+    hanFace: ScriptKey;
+};