reamkit 1.21.0 → 1.23.0

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

@@ -117,6 +117,242 @@ function presetPaths(preset, w, h, adjust) {
 		case "leftArrow": return [blockArrow(w, h, adjust, "left")];
 		case "upArrow": return [blockArrow(w, h, adjust, "up")];
 		case "downArrow": return [blockArrow(w, h, adjust, "down")];
+		case "leftRightArrow": {
+			const ss = Math.min(w, h);
+			const t = clamp(frac(adjust, "adj1", 5e4), 0, 1) * ss;
+			const hl = clamp(frac(adjust, "adj2", 5e4), 0, 1) * ss;
+			const [sb, st] = [(h - t) / 2, (h + t) / 2];
+			return [polygon([
+				[0, h / 2],
+				[hl, h],
+				[hl, st],
+				[w - hl, st],
+				[w - hl, h],
+				[w, h / 2],
+				[w - hl, 0],
+				[w - hl, sb],
+				[hl, sb],
+				[hl, 0]
+			])];
+		}
+		case "notchedRightArrow": {
+			const ss = Math.min(w, h);
+			const t = clamp(frac(adjust, "adj1", 5e4), 0, 1) * ss;
+			const hl = clamp(frac(adjust, "adj2", 5e4), 0, 1) * ss;
+			const [sb, st] = [(h - t) / 2, (h + t) / 2];
+			const notch = Math.min(hl, w / 2);
+			return [polygon([
+				[0, sb],
+				[w - hl, sb],
+				[w - hl, 0],
+				[w, h / 2],
+				[w - hl, h],
+				[w - hl, st],
+				[0, st],
+				[notch, h / 2]
+			])];
+		}
+		case "stripedRightArrow": {
+			const ss = Math.min(w, h);
+			const t = clamp(frac(adjust, "adj1", 5e4), 0, 1) * ss;
+			const hl = clamp(frac(adjust, "adj2", 5e4), 0, 1) * ss;
+			const [sb, st] = [(h - t) / 2, (h + t) / 2];
+			const unit = ss / 12;
+			return [
+				polygon([
+					[0, sb],
+					[unit, sb],
+					[unit, st],
+					[0, st]
+				]),
+				polygon([
+					[unit * 2, sb],
+					[unit * 4, sb],
+					[unit * 4, st],
+					[unit * 2, st]
+				]),
+				polygon([
+					[unit * 5, sb],
+					[w - hl, sb],
+					[w - hl, 0],
+					[w, h / 2],
+					[w - hl, h],
+					[w - hl, st],
+					[unit * 5, st]
+				])
+			];
+		}
+		case "bentUpArrow": {
+			const ss = Math.min(w, h);
+			const t = clamp(frac(adjust, "adj2", 25e3), 0, 1) * ss;
+			const hw = clamp(frac(adjust, "adj3", 25e3), 0, 1) * ss * 2;
+			const hh = Math.min(hw, h);
+			const cx = w - hw / 2;
+			return [polygon([
+				[0, 0],
+				[cx + t / 2, 0],
+				[cx + t / 2, h - hh],
+				[w, h - hh],
+				[cx, h],
+				[cx - hw / 2, h - hh],
+				[cx - t / 2, h - hh],
+				[cx - t / 2, t],
+				[0, t]
+			])];
+		}
+		case "chevron":
+		case "homePlate": {
+			const ss = Math.min(w, h);
+			const x = Math.min(clamp(frac(adjust, "adj", 5e4), 0, 1) * ss, w);
+			const points = [
+				[0, 0],
+				[w - x, 0],
+				[w, h / 2],
+				[w - x, h],
+				[0, h]
+			];
+			if (preset === "chevron") points.push([x, h / 2]);
+			return [polygon(points)];
+		}
+		case "corner": {
+			const ss = Math.min(w, h);
+			const th = clamp(frac(adjust, "adj1", 5e4), 0, 1) * ss;
+			const tw = clamp(frac(adjust, "adj2", 5e4), 0, 1) * ss;
+			return [polygon([
+				[0, 0],
+				[w, 0],
+				[w, th],
+				[tw, th],
+				[tw, h],
+				[0, h]
+			])];
+		}
+		case "pie":
+		case "blockArc": {
+			const [rx, ry] = [w / 2, h / 2];
+			const start = -((adjust.get("adj1") ?? 0) / 6e4) * (Math.PI / 180);
+			let sweep = -((adjust.get("adj2") ?? (preset === "pie" ? 162e5 : 108e5)) / 6e4) * (Math.PI / 180) - start;
+			if (sweep > 0) sweep -= 2 * Math.PI;
+			const at = (a, r) => [rx + rx * r * Math.cos(a), ry + ry * r * Math.sin(a)];
+			const b = new PathBuilder();
+			const [sx0, sy0] = at(start, 1);
+			b.moveTo(sx0, sy0).append(arcToBeziers(rx, ry, rx, ry, start, sweep));
+			if (preset === "pie") return [b.lineTo(rx, ry).close().build()];
+			const inner = 1 - clamp(frac(adjust, "adj3", 25e3), 0, 1);
+			const [ix, iy] = at(start + sweep, inner);
+			return [b.lineTo(ix, iy).append(arcToBeziers(rx, ry, rx * inner, ry * inner, start + sweep, -sweep)).close().build()];
+		}
+		case "gear6":
+		case "gear9": {
+			const teeth = preset === "gear6" ? 6 : 9;
+			const ss = Math.min(w, h);
+			const depth = clamp(frac(adjust, "adj1", 15e3), 0, .4) * ss;
+			const [cx, cy] = [w / 2, h / 2];
+			const outer = Math.min(w, h) / 2;
+			const root = outer - depth;
+			const half = Math.PI / teeth / 2.6;
+			const pts = [];
+			for (let i = 0; i < teeth; i++) {
+				const a = i * 2 * Math.PI / teeth;
+				const gap = Math.PI / teeth;
+				pts.push([cx + root * Math.cos(a - gap + half), cy + root * Math.sin(a - gap + half)]);
+				pts.push([cx + outer * Math.cos(a - half), cy + outer * Math.sin(a - half)]);
+				pts.push([cx + outer * Math.cos(a + half), cy + outer * Math.sin(a + half)]);
+				pts.push([cx + root * Math.cos(a + gap - half), cy + root * Math.sin(a + gap - half)]);
+			}
+			return [polygon(pts)];
+		}
+		case "circularArrow":
+		case "leftCircularArrow": {
+			const ss = Math.min(w, h);
+			const t = clamp(frac(adjust, "adj1", 12500), .02, .45) * ss;
+			const [rx, ry] = [Math.max(t, w / 2 - t), Math.max(t, h / 2 - t)];
+			const [cx, cy] = [w / 2, h / 2];
+			const deg = (v) => -(v / 6e4) * (Math.PI / 180);
+			const tail = deg(adjust.get("adj3") ?? (preset === "circularArrow" ? 20457681 : 125e5));
+			let sweep = deg(adjust.get("adj2") ?? (preset === "circularArrow" ? 1142319 : 1142319)) - tail;
+			const turn = preset === "circularArrow" ? -1 : 1;
+			while (sweep * turn < 0) sweep += turn * 2 * Math.PI;
+			while (Math.abs(sweep) > 2 * Math.PI) sweep -= turn * 2 * Math.PI;
+			const headSweep = turn * Math.min(Math.abs(sweep) / 3, .35);
+			const bandEnd = tail + sweep - headSweep;
+			const at = (a, r) => [clamp(cx + (rx + r) * Math.cos(a), 0, w), clamp(cy + (ry + r) * Math.sin(a), 0, h)];
+			const b = new PathBuilder();
+			const [ox, oy] = at(tail, t / 2);
+			b.moveTo(ox, oy).append(arcToBeziers(cx, cy, rx + t / 2, ry + t / 2, tail, bandEnd - tail).map((seg) => seg.op === "cubic" ? {
+				op: "cubic",
+				x1: clamp(seg.x1, 0, w),
+				y1: clamp(seg.y1, 0, h),
+				x2: clamp(seg.x2, 0, w),
+				y2: clamp(seg.y2, 0, h),
+				x: clamp(seg.x, 0, w),
+				y: clamp(seg.y, 0, h)
+			} : seg));
+			const [hx1, hy1] = at(bandEnd, t);
+			const [tipX, tipY] = at(tail + sweep, 0);
+			const [hx2, hy2] = at(bandEnd, -t);
+			const [ix, iy] = at(bandEnd, -t / 2);
+			return [b.lineTo(hx1, hy1).lineTo(tipX, tipY).lineTo(hx2, hy2).lineTo(ix, iy).append(arcToBeziers(cx, cy, rx - t / 2, ry - t / 2, bandEnd, tail - bandEnd)).close().build()];
+		}
+		case "actionButtonBlank": return [{ segments: roundRectSegments(w, h, Math.min(w, h) * .1) }];
+		case "flowChartMerge": return [polygon([
+			[0, h],
+			[w, h],
+			[w / 2, 0]
+		])];
+		case "flowChartExtract": return [polygon([
+			[0, 0],
+			[w, 0],
+			[w / 2, h]
+		])];
+		case "flowChartDelay": return [new PathBuilder().moveTo(0, 0).lineTo(w / 2, 0).append(arcToBeziers(w / 2, h / 2, w / 2, h / 2, -Math.PI / 2, Math.PI)).lineTo(0, h).close().build()];
+		case "flowChartMagneticDisk": {
+			const ry = h / 6;
+			return [new PathBuilder().moveTo(0, h - ry).append(arcToBeziers(w / 2, h - ry, w / 2, ry, Math.PI, -2 * Math.PI)).moveTo(0, h - ry).lineTo(0, ry).append(arcToBeziers(w / 2, ry, w / 2, ry, Math.PI, -Math.PI)).lineTo(w, h - ry).build()];
+		}
+		case "flowChartMagneticTape": {
+			const foot = h / 8;
+			return [{ segments: ellipseSegments(w, h) }, polygon([
+				[w / 2, 0],
+				[w, 0],
+				[w, foot],
+				[w / 2, foot]
+			])];
+		}
+		case "flowChartPunchedTape": {
+			const wave = h / 5;
+			return [new PathBuilder().moveTo(0, wave).cubicTo(w / 4, wave * 2, w * 3 / 4, 0, w, wave).lineTo(w, h - wave).cubicTo(w * 3 / 4, h - wave * 2, w / 4, h, 0, h - wave).close().build()];
+		}
+		case "wedgeRoundRectCallout": {
+			const r = clamp(frac(adjust, "adj3", 16667), 0, .5) * Math.min(w, h);
+			const tipX = w / 2 + frac(adjust, "adj1", -20833) * w;
+			const tipY = h / 2 - frac(adjust, "adj2", 62500) * h;
+			const [cx, cy] = [w / 2, h / 2];
+			const len = Math.hypot(tipX - cx, tipY - cy) || 1;
+			const [ux, uy] = [(tipX - cx) / len, (tipY - cy) / len];
+			const base = Math.min(w, h) / 6;
+			return [{ segments: roundRectSegments(w, h, r) }, polygon([
+				[cx - uy * base, cy + ux * base],
+				[cx + uy * base, cy - ux * base],
+				[tipX, tipY]
+			])];
+		}
+		case "leftBracket":
+		case "rightBracket":
+		case "leftBrace":
+		case "rightBrace": {
+			const brace = preset === "leftBrace" || preset === "rightBrace";
+			const r = Math.min(clamp(frac(adjust, "adj1", 8333), 0, .5) * h, brace ? w / 2 : w);
+			const mirrored = preset === "rightBracket" || preset === "rightBrace";
+			const x = (v) => mirrored ? w - v : v;
+			const spine = brace ? r : 0;
+			const b = new PathBuilder().moveTo(x(w), 0).lineTo(x(spine + r), 0).lineTo(x(spine), r);
+			if (brace) {
+				const mid = clamp(frac(adjust, "adj2", 5e4), 0, 1) * h;
+				b.lineTo(x(spine), Math.max(r, mid - r)).lineTo(x(0), mid).lineTo(x(spine), Math.min(h - r, mid + r));
+			}
+			return [b.lineTo(x(spine), h - r).lineTo(x(spine + r), h).lineTo(x(w), h).build()];
+		}
 		default: return null;
 	}
 }

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;
+};