@pptx-studio/cli 0.1.0 → 0.3.0

package/dist/{main-DLx2onii.js → main-3sNR_Xlp.js}

@@ -11,7 +11,7 @@ import { bisectPackages, describeChange, flattenChanges, roundTripPackage, summa
 import { censusPackage, formatCensus } from "@pptx-studio/census";
 import { loadDocument } from "@pptx-studio/model";
 import { renderSlide } from "@pptx-studio/render-svg";
-import { LAST_RESORT_FAMILIES, kerningEnabled, substituteFor } from "@pptx-studio/text";
+import { FACE_BOX_PX, LAST_RESORT_FAMILIES, TextError, cssFamily, fontStack, kerningEnabled, substituteFor } from "@pptx-studio/text";
 //#region src/bisect.ts
 const BISECT_DEFAULTS = {
 	oracle: "validate",
@@ -272,6 +272,7 @@ const RENDER_ERROR_CODES = [
 	"CLI_NO_FACE",
 	"CLI_FONT_SIZE",
 	"CLI_NO_SLIDE",
+	"CLI_WIDTH",
 	"CLI_OUTPUT_PATH"
 ];
 var RenderError = class extends Error {
@@ -305,6 +306,12 @@ const TRUE_TYPE = 65536;
 const TTCF = 1953784678;
 /** `OS/2.fsSelection` bit 7: the typographic metrics are the ones to use. */
 const USE_TYPO_METRICS = 128;
+/** FreeType on Linux, CoreText on macOS, DirectWrite elsewhere. ADR 0045, ADR 0053. */
+function backendFor(platform) {
+	if (platform === "linux") return "freetype";
+	if (platform === "darwin") return "coretext";
+	return "directwrite";
+}
 function readerOf(bytes) {
 	return {
 		bytes,
@@ -323,6 +330,9 @@ function i16(r, at) {
 function u32(r, at) {
 	return r.view.getUint32(at);
 }
+function tagAt(r, at) {
+	return String.fromCharCode(u8(r, at), u8(r, at + 1), u8(r, at + 2), u8(r, at + 3));
+}
 function unreadable(what, subject) {
 	throw new RenderError("CLI_FONT_UNREADABLE", what, subject);
 }
@@ -334,7 +344,7 @@ function directoryAt(bytes, start, subject) {
 	for (let i = 0; i < count; i++) {
 		const at = start + 12 + i * 16;
 		if (at + 16 > bytes.length) unreadable("table directory runs past the file", subject);
-		const tag = String.fromCharCode(u8(r, at), u8(r, at + 1), u8(r, at + 2), u8(r, at + 3));
+		const tag = tagAt(r, at);
 		const offset = u32(r, at + 8);
 		const length = u32(r, at + 12);
 		if (offset < bytes.length) out.set(tag, bytes.subarray(offset, Math.min(offset + length, bytes.length)));
@@ -514,6 +524,10 @@ function valueSize(format) {
 }
 /** `XAdvance` is bit 2, and it is the only field a horizontal advance reads. */
 const X_ADVANCE = 4;
+/** `LookupType` 2, pair adjustment: the only positioning that moves an advance. */
+const PAIR_POS = 2;
+/** `LookupType` 9, Extension Positioning, whose subtable names the real type. */
+const EXTENSION_POS = 9;
 function pairPosLookup(r, at) {
 	const format = u16(r, at);
 	const valueFormat1 = u16(r, at + 4);
@@ -550,10 +564,23 @@ function pairPosLookup(r, at) {
 	};
 }
 /**
+* The pair adjustments behind an `ExtensionPosFormat1` subtable.
+*
+* The extension names the real lookup type and a 32-bit offset from its own
+* start, and may not itself target another, so exactly one level is followed.
+*/
+function extensionPairPos(r, at) {
+	const end = r.bytes.length;
+	if (at + 8 > end || u16(r, at) !== 1 || u16(r, at + 2) !== PAIR_POS) return void 0;
+	const target = at + u32(r, at + 4);
+	return target + 16 > end ? void 0 : pairPosLookup(r, target);
+}
+/**
 * The `kern` feature's pair adjustments, if the font has GPOS.
 *
 * Only the `kern` feature: a font's GPOS also carries mark attachment and
-* cursive positioning, and neither changes an advance.
+* cursive positioning, and neither changes an advance. Its lookups are type 2,
+* or the type 9 Extension a font compiler wraps them in.
 */
 function gposKerning(tables) {
 	const table = tables.get("GPOS");
@@ -566,7 +593,7 @@ function gposKerning(tables) {
 	const featureCount = u16(r, featureList);
 	for (let i = 0; i < featureCount; i++) {
 		const record = featureList + 2 + i * 6;
-		if (String.fromCharCode(u8(r, record), u8(r, record + 1), u8(r, record + 2), u8(r, record + 3)) !== "kern") continue;
+		if (tagAt(r, record) !== "kern") continue;
 		const feature = featureList + u16(r, record + 4);
 		const lookups = u16(r, feature + 2);
 		for (let j = 0; j < lookups; j++) wanted.add(u16(r, feature + 4 + j * 2));
@@ -577,10 +604,12 @@ function gposKerning(tables) {
 	for (const index of wanted) {
 		if (index >= lookupCount) continue;
 		const lookup = lookupList + u16(r, lookupList + 2 + index * 2);
-		if (u16(r, lookup) !== 2) continue;
+		const type = u16(r, lookup);
+		if (type !== PAIR_POS && type !== EXTENSION_POS) continue;
 		const subtables = u16(r, lookup + 4);
 		for (let i = 0; i < subtables; i++) {
-			const pairs = pairPosLookup(r, lookup + u16(r, lookup + 6 + i * 2));
+			const at = lookup + u16(r, lookup + 6 + i * 2);
+			const pairs = type === PAIR_POS ? pairPosLookup(r, at) : extensionPairPos(r, at);
 			if (pairs !== void 0) found.push(pairs);
 		}
 	}
@@ -620,39 +649,98 @@ function legacyKerning(tables) {
 	return (left, right) => pairs.get(left << 16 | right) ?? 0;
 }
 /**
+* The `BASE` horizontal axis' `ideo` coordinate under `DFLT`, in font units.
+*
+* One script and one tag: T13 built a font whose `DFLT`, `latn` and `hani`
+* coordinates all differ and Chromium took `DFLT`, and a second whose `BASE`
+* names every script but `DFLT` and Chromium read none of them. A table this
+* cannot follow is answered with `undefined`, which is what HarfBuzz's
+* sanitiser leaves the browser holding as well.
+*/
+function ideographicOf(tables) {
+	const table = tables.get("BASE");
+	if (table === void 0 || table.length < 8) return void 0;
+	const r = readerOf(table);
+	/** An offset that is neither NULL nor short of the bytes it points at. */
+	const within = (offset, need) => offset > 0 && offset + need <= table.length ? offset : void 0;
+	const axis = within(u16(r, 4), 4);
+	if (axis === void 0) return void 0;
+	const tagList = within(axis + u16(r, axis), 2);
+	const scriptList = within(axis + u16(r, axis + 2), 2);
+	if (tagList === void 0 || scriptList === void 0) return void 0;
+	const tagCount = u16(r, tagList);
+	if (tagList + 2 + tagCount * 4 > table.length) return void 0;
+	let tag = -1;
+	for (let i = 0; i < tagCount && tag < 0; i++) if (tagAt(r, tagList + 2 + i * 4) === "ideo") tag = i;
+	if (tag < 0) return void 0;
+	const scriptCount = u16(r, scriptList);
+	if (scriptList + 2 + scriptCount * 6 > table.length) return void 0;
+	let script;
+	for (let i = 0; i < scriptCount && script === void 0; i++) {
+		const record = scriptList + 2 + i * 6;
+		if (tagAt(r, record) === "DFLT") script = within(scriptList + u16(r, record + 4), 6);
+	}
+	if (script === void 0) return void 0;
+	const values = within(script + u16(r, script), 4);
+	if (values === void 0) return void 0;
+	if (tag >= u16(r, values + 2) || values + 4 + tag * 2 + 2 > table.length) return void 0;
+	const coord = within(values + u16(r, values + 4 + tag * 2), 4);
+	if (coord === void 0) return void 0;
+	const format = u16(r, coord);
+	return format >= 1 && format <= 3 ? -i16(r, coord + 2) : void 0;
+}
+/**
 * The vertical metrics a browser reports for the face.
 *
-* T13 built one font whose `hhea`, `usWin` and `sTypo` pairs are all different
-* and asked Chromium for `fontBoundingBoxAscent`: it answered `usWin`, and
-* answered `sTypo` from the same font with `fsSelection` bit 7 set. So `hhea`
-* is never the answer, and a reader that ignores bit 7 is wrong on every font
-* that sets it, which is most of the ones shipped since 2015.
+* Bit 7 wins on DirectWrite and FreeType, which otherwise answer `usWin` and
+* `hhea`; CoreText answers `hhea` either way, 248/248. ADR 0045, ADR 0053.
 */
-function metricsOf(tables, subject) {
+function metricsOf(tables, subject, backend) {
 	const unitsPerEm = u16(readerOf(required(tables, "head", subject)), 18);
 	if (unitsPerEm <= 0) unreadable("head.unitsPerEm is zero", subject);
+	const ideographic = ideographicOf(tables);
+	const hhea = readerOf(required(tables, "hhea", subject));
+	const hheaPair = {
+		ascent: i16(hhea, 4),
+		descent: -i16(hhea, 6)
+	};
 	const os2 = tables.get("OS/2");
-	if (os2 === void 0 || os2.length < 78) {
-		const hhea = readerOf(required(tables, "hhea", subject));
-		return {
-			unitsPerEm,
-			ascent: i16(hhea, 4),
-			descent: -i16(hhea, 6),
-			source: "usWin"
-		};
-	}
-	const r = readerOf(os2);
-	if ((u16(r, 62) & USE_TYPO_METRICS) !== 0) return {
+	if (os2 === void 0 || os2.length < 78) return {
 		unitsPerEm,
+		...hheaPair,
+		source: "hhea",
+		backend,
+		ideographic,
+		candidates: {
+			hhea: hheaPair,
+			usWin: void 0,
+			sTypo: void 0,
+			useTypoMetrics: false
+		}
+	};
+	const r = readerOf(os2);
+	const usWin = {
+		ascent: u16(r, 74),
+		descent: u16(r, 76)
+	};
+	const sTypo = {
 		ascent: i16(r, 68),
-		descent: -i16(r, 70),
-		source: "sTypo"
+		descent: -i16(r, 70)
 	};
+	const useTypoMetrics = (u16(r, 62) & USE_TYPO_METRICS) !== 0;
+	const source = backend === "coretext" ? "hhea" : useTypoMetrics ? "sTypo" : backend === "freetype" ? "hhea" : "usWin";
 	return {
 		unitsPerEm,
-		ascent: u16(r, 74),
-		descent: u16(r, 76),
-		source: "usWin"
+		...source === "sTypo" ? sTypo : source === "hhea" ? hheaPair : usWin,
+		source,
+		backend,
+		ideographic,
+		candidates: {
+			hhea: hheaPair,
+			usWin,
+			sTypo,
+			useTypoMetrics
+		}
 	};
 }
 function advancesOf(tables, subject) {
@@ -668,7 +756,7 @@ function advancesOf(tables, subject) {
 const BOLD_STYLE = /bold|black|heavy|semibold|extrabold|demibold/i;
 const ITALIC_STYLE = /italic|oblique/i;
 /** Read one font out of an already-located table directory. */
-function faceOf(tables, subject) {
+function faceOf(tables, subject, backend) {
 	const names = namesOf(tables, subject);
 	const family = names.get(1);
 	if (family === void 0 || family === "") unreadable("no family name", subject);
@@ -681,7 +769,7 @@ function faceOf(tables, subject) {
 		family,
 		subfamily,
 		typographicFamily: names.get(16),
-		metrics: metricsOf(tables, subject),
+		metrics: metricsOf(tables, subject, backend),
 		bold: BOLD_STYLE.test(subfamily) || (macStyle & 1) !== 0,
 		italic: ITALIC_STYLE.test(subfamily) || (macStyle & 2) !== 0,
 		advanceOf(codePoint) {
@@ -696,8 +784,8 @@ function faceOf(tables, subject) {
 	};
 }
 /** Every face in a file, which is one unless the file is a collection. */
-function facesIn(bytes, subject) {
-	return fontsIn(bytes, subject).map((tables) => faceOf(tables, subject));
+function facesIn(bytes, subject, backend) {
+	return fontsIn(bytes, subject).map((tables) => faceOf(tables, subject, backend));
 }
 //#endregion
 //#region src/render/faces.ts
@@ -717,6 +805,21 @@ const MAX_DEPTH = 4;
 function key(family) {
 	return family.trim().replace(/\s+/g, " ").toLowerCase();
 }
+/** Whether a name can be written into the markup that would draw it. */
+function emittable(family) {
+	try {
+		cssFamily(family);
+		return true;
+	} catch (error) {
+		if (error instanceof TextError && error.code === "TEXT_FONT_FAMILY") return false;
+		throw error;
+	}
+}
+/** Code unit order, which is the same on every machine and in every locale. */
+function compare(a, b) {
+	if (a === b) return 0;
+	return a < b ? -1 : 1;
+}
 /** Where fonts live on this platform, whether or not the directories exist. */
 function systemFontDirectories(platform = process.platform) {
 	const home = homedir();
@@ -745,7 +848,7 @@ function filesUnder(directory, depth, out) {
 	} catch {
 		return;
 	}
-	for (const entry of entries) {
+	for (const entry of [...entries].sort((a, b) => compare(a.name, b.name))) {
 		const path = join(directory, entry.name);
 		if (entry.isDirectory()) filesUnder(path, depth + 1, out);
 		else if (FONT_FILE.test(entry.name)) out.push(path);
@@ -761,6 +864,32 @@ function slot(bold, italic) {
 	return (bold ? 1 : 0) | (italic ? 2 : 0);
 }
 /**
+* The names a typeface is a variation of, longest first.
+*
+* DrawingML has no weight axis, so `Calibri Light` is a typeface name rather
+* than Calibri at a weight, and Calibri is the nearer face to draw it in.
+*/
+function shorterNames(family) {
+	const words = family.trim().split(/\s+/);
+	const names = [];
+	for (let at = words.length - 1; at > 0; at--) names.push(words.slice(0, at).join(" "));
+	return names;
+}
+/**
+* The families to try for one this machine lacks, in order.
+*
+* The measured chain first - `@pptx-studio/text`'s table and then what
+* PowerPoint itself falls back to, ADR 0033 - and the shorter forms of the
+* asked-for name only after it, where no measurement reaches.
+*/
+function standInsFor(family) {
+	return [
+		substituteFor(family)?.use,
+		...LAST_RESORT_FAMILIES,
+		...shorterNames(family).flatMap((name) => [name, substituteFor(name)?.use])
+	].filter((name) => name !== void 0);
+}
+/**
 * Read every font file under the given directories, once.
 *
 * A file that will not parse is skipped rather than fatal: a font directory on
@@ -777,23 +906,28 @@ function indexFonts(options = {}) {
 	const directories = [...options.extra ?? [], ...options.system === false ? [] : systemFontDirectories(options.platform)];
 	const files = [];
 	for (const directory of directories) filesUnder(directory, 0, files);
+	const backend = backendFor(options.platform ?? process.platform);
 	const indexed = [];
 	const byFamily = /* @__PURE__ */ new Map();
 	const claim = (family, entry) => {
-		const slots = byFamily.get(key(family)) ?? [
-			void 0,
-			void 0,
-			void 0,
-			void 0
-		];
-		const at = slot(entry.face.bold, entry.face.italic);
-		slots[at] ??= entry;
-		byFamily.set(key(family), slots);
+		const at = key(family);
+		if (at === "" || !emittable(family)) return;
+		const found = byFamily.get(at) ?? {
+			name: family,
+			slots: [
+				void 0,
+				void 0,
+				void 0,
+				void 0
+			]
+		};
+		found.slots[slot(entry.face.bold, entry.face.italic)] ??= entry;
+		byFamily.set(at, found);
 	};
 	for (const file of files) {
 		let faces;
 		try {
-			faces = facesIn(new Uint8Array(readFileSync(file)), file);
+			faces = facesIn(new Uint8Array(readFileSync(file)), file, backend);
 		} catch {
 			continue;
 		}
@@ -808,9 +942,7 @@ function indexFonts(options = {}) {
 		}
 	}
 	/** The nearest slot to the one asked for: exact, then drop italic, then bold. */
-	const pick = (family, bold, italic) => {
-		const slots = byFamily.get(key(family));
-		if (slots === void 0) return void 0;
+	const pickIn = (found, bold, italic) => {
 		const wanted = [
 			slot(bold, italic),
 			slot(bold, false),
@@ -822,29 +954,37 @@ function indexFonts(options = {}) {
 			3
 		];
 		for (const at of wanted) {
-			const found = slots[at];
-			if (found !== void 0) return found;
+			const entry = found.slots[at];
+			if (entry !== void 0) return entry;
 		}
 	};
+	const drawnIn = (name, bold, italic, asked) => {
+		const family = byFamily.get(key(name));
+		if (family === void 0) return void 0;
+		const found = pickIn(family, bold, italic);
+		if (found === void 0) return void 0;
+		return {
+			face: found.face,
+			asked,
+			drawn: name,
+			file: found.file,
+			substituted: key(name) !== key(asked)
+		};
+	};
 	return {
 		indexed,
 		directories,
 		resolve(family, bold, italic) {
-			const direct = pick(family, bold, italic);
-			if (direct !== void 0) return {
-				face: direct.face,
-				asked: family,
-				drawn: family,
-				file: direct.file,
-				substituted: false
-			};
-			const chain = [substituteFor(family)?.use, ...LAST_RESORT_FAMILIES].filter((name) => name !== void 0);
-			for (const name of chain) {
-				const found = pick(name, bold, italic);
+			for (const name of [family, ...standInsFor(family)]) {
+				const found = drawnIn(name, bold, italic, family);
+				if (found !== void 0) return found;
+			}
+			for (const [, entry] of [...byFamily].sort((a, b) => compare(a[0], b[0]))) {
+				const found = pickIn(entry, bold, italic);
 				if (found !== void 0) return {
 					face: found.face,
 					asked: family,
-					drawn: name,
+					drawn: entry.name,
 					file: found.file,
 					substituted: true
 				};
@@ -867,17 +1007,16 @@ function indexFonts(options = {}) {
 /**
 * The fixed-point step Chromium reports an advance in.
 *
-* T13 measured 252 widths across seven fonts, six strings and six sizes. Summing
-* exact floats fits 88 of them; quantising each glyph advance toward zero and
-* each kern adjustment to nearest, both at 1/65536 px, fits all 216. The
-* difference is never more than 1.6e-5 px and matters to nothing on a slide -
-* it is here because a rule that reproduces the browser exactly can be tested
-* exactly, and one that is merely close cannot.
+* Quantising each glyph advance toward zero and each kern adjustment to nearest
+* fits all 540 of T13's widths, where summing exact floats fits 234 and is out
+* by up to 1.04e-4 px. ADR 0042.
 */
 const FIXED = 65536;
+/** CoreText's `Fixed`: the em ratio is held as 16.16 before the box rounds. ADR 0053. */
+const EM_FIXED = 65536;
 /**
-* Every advance in this font is positive, so truncation and flooring are the
-* same rule; T13 had no probe that could separate them and does not claim one.
+* `hmtx.advanceWidth` is a `UFWORD`, so this is never negative and truncation
+* and flooring are one rule. ADR 0042.
 */
 function quantiseAdvance(px) {
 	return Math.trunc(px * FIXED) / FIXED;
@@ -886,6 +1025,15 @@ function quantiseKern(px) {
 	return Math.round(px * FIXED) / FIXED;
 }
 /**
+* A box metric as the browser probe reports it: read at `FACE_BOX_PX`, rounded
+* half up to the pixel, and handed back as a fraction of the em. CoreText holds
+* the em ratio as 16.16 fixed point first. T13 30/30, T14 248/248. ADR 0053.
+*/
+function boxPixels(units, unitsPerEm, backend) {
+	const px = backend === "coretext" ? Math.round(units / unitsPerEm * EM_FIXED) / EM_FIXED * FACE_BOX_PX : units * FACE_BOX_PX / unitsPerEm;
+	return Math.floor(px + .5) / FACE_BOX_PX;
+}
+/**
 * A measurer bound to one library.
 *
 * Both probes cache by family, because a slide asks for the same handful of
@@ -897,11 +1045,14 @@ function createFontMeasurer(library) {
 	/** Which face draws a code point the asked-for face has no glyph for. */
 	const fallbacks = /* @__PURE__ */ new Map();
 	const faceFor = (family, bold, italic) => {
-		const cacheKey = `${family}${bold ? "b" : ""}${italic ? "i" : ""}`;
+		const cacheKey = `${family}\u0000${bold ? "b" : ""}${italic ? "i" : ""}`;
 		const cached = resolved.get(cacheKey);
 		if (cached !== void 0) return cached;
 		const found = library.resolve(family, bold, italic);
-		if (found === void 0) throw new RenderError("CLI_NO_FACE", `no face on this machine can stand in for ${JSON.stringify(family)}; ${String(library.indexed.length)} face(s) were indexed from ${library.directories.join(", ")}`, family);
+		if (found === void 0) {
+			const where = library.directories.length === 0 ? "no directory was searched" : `nothing was found in ${library.directories.join(", ")}`;
+			throw new RenderError("CLI_NO_FACE", `no face on this machine can stand in for ${JSON.stringify(family)}: the font library is empty, ${where}`, family);
+		}
 		resolved.set(cacheKey, found);
 		return found;
 	};
@@ -974,14 +1125,20 @@ function createFontMeasurer(library) {
 			const cached = boxes.get(family);
 			if (cached !== void 0) return cached;
 			const { metrics } = faceFor(family, false, false).face;
+			const descent = boxPixels(metrics.descent, metrics.unitsPerEm, metrics.backend);
+			const ideographic = metrics.ideographic === void 0 ? descent : metrics.ideographic / metrics.unitsPerEm;
 			const box = {
-				ascent: metrics.ascent / metrics.unitsPerEm,
-				descent: metrics.descent / metrics.unitsPerEm,
-				ideographic: metrics.descent / metrics.unitsPerEm
+				ascent: boxPixels(metrics.ascent, metrics.unitsPerEm, metrics.backend),
+				descent,
+				ideographic: ideographic > 0 && ideographic < 1 ? ideographic : 0
 			};
 			boxes.set(family, box);
 			return box;
 		} },
+		cssFamilyFor(font) {
+			const face = faceFor(font.family, font.bold === true, font.italic === true);
+			return fontStack(face.asked, face.drawn);
+		},
 		used() {
 			const seen = /* @__PURE__ */ new Map();
 			for (const face of resolved.values()) seen.set(face.asked, {
@@ -1010,11 +1167,10 @@ function createFontMeasurer(library) {
 */
 /** What a slide is drawn at when the caller says nothing. PowerPoint's own. */
 const DEFAULT_WIDTH = 1920;
-const RENDER_DEFAULTS = {
-	width: DEFAULT_WIDTH,
-	systemFonts: true,
-	text: true
-};
+/** Text is drawn unless the caller says otherwise. */
+function drawsText(options) {
+	return options.text ?? true;
+}
 /** The media resolver: an rId means the rels of the part the fill was written in. */
 function mediaFrom(store) {
 	return (embed, part) => {
@@ -1031,46 +1187,50 @@ function mediaFrom(store) {
 /**
 * Render a deck that is already in memory.
 *
-* Separate from `runRender` so that the whole pipeline is exercised by the test
-* suite without a file system, a process or a captured stdout.
+* The library entry point: no file system, no process, no stdout. `runRender` is
+* the verb wrapped around it, and the three fields it adds are its own.
 */
-function renderDeck(bytes, options) {
+function renderDeck(bytes, options = {}) {
+	const width = options.width ?? 1920;
+	if (!Number.isInteger(width) || width < 1) throw new RenderError("CLI_WIDTH", `a width of ${String(width)} is not a positive whole number of pixels`, String(width));
+	const slide = options.slide ?? null;
 	const store = PartStore.open(bytes);
 	const document = loadDocument(store);
 	const size = document.slideSize;
-	const height = Math.round(options.width * size.cy / size.cx);
-	if (options.slide !== null) {
+	const height = Math.round(width * size.cy / size.cx);
+	if (slide !== null) {
 		const count = document.slides.length;
-		if (!Number.isInteger(options.slide) || options.slide < 1 || options.slide > count) throw new RenderError("CLI_NO_SLIDE", `--slide ${String(options.slide)}: the deck has ${String(count)} slide(s)`, String(options.slide));
+		if (!Number.isInteger(slide) || slide < 1 || slide > count) throw new RenderError("CLI_NO_SLIDE", `slide ${String(slide)}: the deck has ${String(count)} slide(s)`, String(slide));
 	}
 	let library = null;
-	const fonts = options.text ? createFontMeasurer(library = indexFonts({
-		extra: options.fontDirs,
-		system: options.systemFonts
+	const fonts = drawsText(options) ? createFontMeasurer(library = indexFonts({
+		extra: options.fontDirs ?? [],
+		system: options.systemFonts !== false
 	})) : null;
 	const media = mediaFrom(store);
 	return {
-		slides: (options.slide === null ? document.slides.map((sheet, at) => ({
+		slides: (slide === null ? document.slides.map((sheet, at) => ({
 			sheet,
 			number: at + 1
 		})) : [{
-			sheet: document.slides[options.slide - 1],
-			number: options.slide
+			sheet: document.slides[slide - 1],
+			number: slide
 		}]).map(({ sheet, number }) => ({
 			number,
 			svg: renderSlide(sheet, size, {
-				width: options.width,
+				width,
 				height,
 				idPrefix: `s${String(number)}`,
 				media,
 				text: fonts === null ? false : {
 					defaultTextStyle: document.defaultTextStyle,
 					measurer: fonts.measurer,
-					faceBox: fonts.faceBox
+					faceBox: fonts.faceBox,
+					cssFamilyFor: fonts.cssFamilyFor
 				}
 			})
 		})),
-		width: options.width,
+		width,
 		height,
 		fonts: fonts?.used() ?? [],
 		missing: fonts?.missing() ?? [],
@@ -1117,7 +1277,7 @@ function report(result, written, options) {
 	const lines = [];
 	const slides = `${String(result.slides.length)} slide(s) at ${String(result.width)}x${String(result.height)}`;
 	lines.push(written.length === 0 ? slides : `${slides} -> ${written.length === 1 ? written[0] : `${String(written.length)} files`}`);
-	if (options.text) {
+	if (drawsText(options)) {
 		const substituted = result.fonts.filter((font) => font.substituted);
 		lines.push(`${String(result.fonts.length)} typeface(s) from ${String(result.facesIndexed)} indexed face(s)` + (substituted.length === 0 ? "" : `, ${String(substituted.length)} substituted`));
 		for (const font of substituted) lines.push(`  ${font.asked} -> ${font.drawn}`);
@@ -1278,15 +1438,18 @@ function usage() {
 		"",
 		"render options:",
 		"  --slide <n>      one slide, 1-based; every slide by default",
-		"  --width <px>     the SVG width attribute; the height follows the aspect",
+		"  --width <px>     the SVG width attribute; the height follows the aspect (default " + String(DEFAULT_WIDTH) + ")",
 		"  --out <path>     a directory, or a file when rendering one slide",
 		"  --font-dir <d>   look for fonts here first; repeatable",
-		"  --no-system-fonts   do not look in this platform own font directories",
+		"  --no-system-fonts   do not look in this platform's own font directories",
 		"  --no-text        draw geometry only, and ask no font questions",
 		"  --json           what was drawn, and which face drew each typeface",
 		"  --quiet          no summary after writing",
 		"",
 		"  With no --out the markup goes to stdout, which is one slide worth doing.",
+		"  In Node, `import { renderDeck } from \"@pptx-studio/cli\"` takes the five",
+		"  drawing options above and defaults every one; --out, --json and --quiet are",
+		"  this command's own.",
 		"",
 		"inspect options:",
 		"  --json           the census as JSON, for a script or for committing as a fixture",
@@ -1474,7 +1637,7 @@ function main(argv, streams = CONSOLE_STREAMS) {
 			streams.err("--slide wants a positive integer, got " + String(values.slide) + "\n");
 			return 2;
 		}
-		const width = positiveInteger(values.width, RENDER_DEFAULTS.width);
+		const width = positiveInteger(values.width, DEFAULT_WIDTH);
 		if (width === null) {
 			streams.err("--width wants a positive integer, got " + String(values.width) + "\n");
 			return 2;
@@ -1565,6 +1728,6 @@ function positiveInteger(value, fallback) {
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
 }
 //#endregion
-export { runRender as a, systemFontDirectories as c, RenderError as d, isRenderError as f, runInspect as h, renderDeck as i, facesIn as l, inspectFile as m, DEFAULT_WIDTH as n, createFontMeasurer as o, INSPECT_DEFAULTS as p, RENDER_DEFAULTS as r, indexFonts as s, main as t, RENDER_ERROR_CODES as u };
+export { createFontMeasurer as a, backendFor as c, RenderError as d, isRenderError as f, runInspect as h, runRender as i, facesIn as l, inspectFile as m, DEFAULT_WIDTH as n, indexFonts as o, INSPECT_DEFAULTS as p, renderDeck as r, systemFontDirectories as s, main as t, RENDER_ERROR_CODES as u };
 
-//# sourceMappingURL=main-DLx2onii.js.map
+//# sourceMappingURL=main-3sNR_Xlp.js.map