@furifont/core 0.1.1 → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1346 @@
+import * as v from "valibot";
+//#region src/defaults.ts
+/**
+* Every default of a build, and how the prebuilt fonts are built, in one place.
+* Config files, the CLI, the studio and `scripts/build-fonts.ts` all read it, so
+* a change here reaches them together. What an option means is in `schema.ts`.
+*/
+const DEFAULTS = {
+	/** What a plan does when a config leaves an option out. */
+	plan: {
+		family: "Furifont Sans",
+		rubyScript: "hiragana",
+		/** Newspaper frequency buckets, nf01 to nf48: the window of words that get ruby. All of them: it adds about 400 glyphs. */
+		nfMin: 1,
+		nfMax: 48,
+		/** JMdict priority tags that select a word whatever its bucket: the first tier of each list, which JMdict marks as common. */
+		selectTags: [
+			"ichi1",
+			"news1",
+			"spec1",
+			"gai1"
+		],
+		/** Uses in Tatoeba's example sentences that select a word whatever its bucket: about 1,000 more words, and 50 glyphs. */
+		minTatoeba: 3,
+		places: true,
+		isolated: true,
+		isolatedMinShare: .8,
+		/** Sizes in em, relative to the base font. */
+		metrics: {
+			rubyScale: .5,
+			rubyGap: .05,
+			compressionFloor: .8,
+			maxRubyWidth: 1.5
+		}
+	},
+	/** What the CLI adds to a plan: where the glyphs are drawn, and what is written. */
+	build: {
+		base: "Source Han Sans JP VF",
+		formats: ["otf", "woff2"]
+	}
+};
+/** The prebuilt fonts, which each release carries; the site serves their variable WOFF2s. */
+const PREBUILT = {
+	/** Each Source Han face in each ruby script. The first is the default family. */
+	fonts: [
+		{
+			family: "Furifont Sans",
+			base: "Source Han Sans JP",
+			face: "sans",
+			rubyScript: "hiragana"
+		},
+		{
+			family: "Furifont Sans Romaji",
+			base: "Source Han Sans JP",
+			face: "sans",
+			rubyScript: "hepburn"
+		},
+		{
+			family: "Furifont Serif",
+			base: "Source Han Serif JP",
+			face: "serif",
+			rubyScript: "hiragana"
+		},
+		{
+			family: "Furifont Serif Romaji",
+			base: "Source Han Serif JP",
+			face: "serif",
+			rubyScript: "hepburn"
+		}
+	],
+	/** The static weights of the release, each of the base's weights by name. Bold is the variable font's. */
+	weights: [{
+		style: "Regular",
+		weight: 400
+	}],
+	/**
+	* Every weight in one font, from the base's variable font (`<base> VF`). It
+	* is named apart, `<family> VF`, so it installs beside the static weights.
+	*/
+	variable: {
+		style: "VF",
+		weights: [250, 900]
+	},
+	/** Options set on every prebuilt font over the defaults above, such as `{ nfMax: 24 }`. */
+	options: {}
+};
+/**
+* The sequence, 。 and VS1, a page measures to tell which version of Furifont
+* it has: the font maps it to an empty glyph two ems wide plus the revision in
+* ems (`0.1.2`, revision 0.102, is 2.102 ems). A font from before it draws the
+* 。 alone, an em wide at most.
+*/
+const VERSION_PROBE = {
+	base: 12290,
+	selector: 65024
+};
+//#endregion
+//#region src/dictionary.ts
+const HAN = /\p{Script=Han}/u;
+function isHan(char) {
+	return HAN.test(char);
+}
+function parseFurigana(furigana) {
+	return furigana.split(";").filter(Boolean).map((part) => {
+		const [range, ruby = ""] = part.split(":");
+		const [start, end = start] = range.split("-").map(Number);
+		return {
+			start,
+			end: end + 1,
+			ruby
+		};
+	});
+}
+/**
+* Splits a form into its Han runs. Browsers itemize text by script before
+* shaping, so a font only ever sees one run at a time: okurigana and other
+* kana are never visible as context. Runs with an unannotated kanji or an
+* annotation leaking outside the run are dropped.
+*/
+function hanRuns(form, spans) {
+	const chars = [...form];
+	const runs = [];
+	for (let i = 0; i < chars.length;) {
+		if (!isHan(chars[i])) {
+			i++;
+			continue;
+		}
+		let end = i;
+		while (end < chars.length && isHan(chars[end])) end++;
+		const inside = spans.filter((s) => s.start < end && s.end > i);
+		if (inside.reduce((n, s) => n + s.end - s.start, 0) === end - i && inside.every((s) => s.start >= i && s.end <= end && s.ruby)) runs.push({
+			text: chars.slice(i, end).join(""),
+			spans: inside.map((s) => ({
+				...s,
+				start: s.start - i,
+				end: s.end - i
+			}))
+		});
+		i = end;
+	}
+	return runs;
+}
+/**
+* Parses the inline notation for custom words: `日[に]本[ほん]` for one reading
+* per kanji, `今日[きょう]` for a reading over several kanji, kana as written.
+*/
+function parseNotation(notation) {
+	const spans = [];
+	let form = "";
+	for (const match of notation.matchAll(/([^[\]]*)\[([^\]]*)\]|([^[\]]+)$/g)) {
+		const [, base = match[3], ruby] = match;
+		const chars = [...base];
+		const start = [...form].length;
+		form += base;
+		if (ruby === void 0) continue;
+		let kanjiFrom = chars.length;
+		while (kanjiFrom > 0 && isHan(chars[kanjiFrom - 1])) kanjiFrom--;
+		if (kanjiFrom === chars.length) throw new Error(`"[${ruby}]" in "${notation}" does not follow a kanji`);
+		spans.push({
+			start: start + kanjiFrom,
+			end: start + chars.length,
+			ruby
+		});
+	}
+	if (!spans.length) throw new Error(`"${notation}" has no reading, write it like 日[に]本[ほん]`);
+	return {
+		form,
+		spans
+	};
+}
+function formatNotation(text, spans) {
+	const chars = [...text];
+	let out = "";
+	let at = 0;
+	for (const s of spans) {
+		out += `${chars.slice(at, s.end).join("")}[${s.ruby}]`;
+		at = s.end;
+	}
+	return out + chars.slice(at).join("");
+}
+//#endregion
+//#region src/glyphs.ts
+function glyphName(codepoint) {
+	const hex = codepoint.toString(16).toUpperCase();
+	return codepoint > 65535 ? `u${hex}` : `uni${hex.padStart(4, "0")}`;
+}
+function codepoints(text) {
+	return [...text].map((c) => c.codePointAt(0));
+}
+function isGrouped(run) {
+	return run.spans.some((s) => s.end - s.start > 1);
+}
+/** Glyphs keyed by what they draw, so every word sharing a reading shares the glyph. */
+function createGlyphRegistry(render) {
+	const glyphs = /* @__PURE__ */ new Map();
+	const counters = /* @__PURE__ */ new Map();
+	const draw = (text, ruby) => {
+		const key = `${text}|${ruby.map((r) => `${r.start}-${r.end}:${r.text}`).join(";")}`;
+		const existing = glyphs.get(key);
+		if (existing) return existing;
+		const bases = codepoints(text);
+		const base = bases.map(glyphName).join("_");
+		const n = (counters.get(base) ?? 0) + 1;
+		counters.set(base, n);
+		const glyph = {
+			name: base.length > 56 ? `run${glyphs.size}.rb.${n}` : `${base}.rb.${n}`,
+			bases,
+			ruby
+		};
+		glyphs.set(key, glyph);
+		return glyph;
+	};
+	const kanji = (run, index) => {
+		const span = run.spans[index];
+		return draw([...run.text].slice(span.start, span.end).join(""), [{
+			start: 0,
+			end: 1,
+			text: render(run, index)
+		}]);
+	};
+	return {
+		all: () => [...glyphs.values()],
+		run: (run) => isGrouped(run) ? [draw(run.text, run.spans.map((s, i) => ({
+			start: s.start,
+			end: s.end,
+			text: render(run, i)
+		})))] : run.spans.map((_, i) => kanji(run, i)),
+		lone: (text, ruby) => kanji({
+			text,
+			spans: [{
+				start: 0,
+				end: 1,
+				ruby
+			}]
+		}, 0)
+	};
+}
+/** Single substitutions, packed so each lookup maps an input glyph at most once. */
+function createSingleLookups() {
+	const byInput = /* @__PURE__ */ new Map();
+	return {
+		lookupFor(input, output) {
+			let outputs = byInput.get(input);
+			if (!outputs) byInput.set(input, outputs = /* @__PURE__ */ new Map());
+			let slot = outputs.get(output);
+			if (!slot) outputs.set(output, slot = outputs.size + 1);
+			return `rb_${slot}`;
+		},
+		all: () => [...byInput].flatMap(([input, outputs]) => [...outputs].map(([output, slot]) => ({
+			lookup: `rb_${slot}`,
+			input,
+			output
+		})))
+	};
+}
+//#endregion
+//#region src/kana.ts
+/** Hiragana U+3041..U+3096 sit exactly 0x60 below their katakana. */
+const KATAKANA_OFFSET = 96;
+function toKatakana(hiragana) {
+	return hiragana.replace(/[\u3041-\u3096]/g, (c) => String.fromCharCode(c.charCodeAt(0) + KATAKANA_OFFSET));
+}
+function toHiragana(katakana) {
+	return katakana.replace(/[\u30A1-\u30F6]/g, (c) => String.fromCharCode(c.charCodeAt(0) - KATAKANA_OFFSET));
+}
+const VOICED = {
+	か: ["が"],
+	き: ["ぎ"],
+	く: ["ぐ"],
+	け: ["げ"],
+	こ: ["ご"],
+	さ: ["ざ"],
+	し: ["じ"],
+	す: ["ず"],
+	せ: ["ぜ"],
+	そ: ["ぞ"],
+	た: ["だ"],
+	ち: ["ぢ", "じ"],
+	つ: ["づ", "ず"],
+	て: ["で"],
+	と: ["ど"],
+	は: ["ば", "ぱ"],
+	ひ: ["び", "ぴ"],
+	ふ: ["ぶ", "ぷ"],
+	へ: ["べ", "ぺ"],
+	ほ: ["ぼ", "ぽ"]
+};
+/**
+* Whether `reading` is one of the kanji's on'yomi as it surfaces inside a word:
+* as listed, with its first kana voiced (rendaku), or with a final く/き/ち/つ
+* turned into っ (sokuon), e.g. 学 ガク surfacing as がっ in 学校.
+*/
+function isOnyomi(reading, onyomi) {
+	return onyomi.some((on) => {
+		const forms = [on, ...(VOICED[on[0]] ?? []).map((v) => v + on.slice(1))];
+		if (/[くきちつ]$/.test(on)) forms.push(...forms.map((f) => `${f.slice(0, -1)}っ`));
+		return forms.includes(reading);
+	});
+}
+const ROMAJI = {
+	あ: "a",
+	い: "i",
+	う: "u",
+	え: "e",
+	お: "o",
+	か: "ka",
+	き: "ki",
+	く: "ku",
+	け: "ke",
+	こ: "ko",
+	が: "ga",
+	ぎ: "gi",
+	ぐ: "gu",
+	げ: "ge",
+	ご: "go",
+	さ: "sa",
+	し: "shi",
+	す: "su",
+	せ: "se",
+	そ: "so",
+	ざ: "za",
+	じ: "ji",
+	ず: "zu",
+	ぜ: "ze",
+	ぞ: "zo",
+	た: "ta",
+	ち: "chi",
+	つ: "tsu",
+	て: "te",
+	と: "to",
+	だ: "da",
+	ぢ: "ji",
+	づ: "zu",
+	で: "de",
+	ど: "do",
+	な: "na",
+	に: "ni",
+	ぬ: "nu",
+	ね: "ne",
+	の: "no",
+	は: "ha",
+	ひ: "hi",
+	ふ: "fu",
+	へ: "he",
+	ほ: "ho",
+	ば: "ba",
+	び: "bi",
+	ぶ: "bu",
+	べ: "be",
+	ぼ: "bo",
+	ぱ: "pa",
+	ぴ: "pi",
+	ぷ: "pu",
+	ぺ: "pe",
+	ぽ: "po",
+	ま: "ma",
+	み: "mi",
+	む: "mu",
+	め: "me",
+	も: "mo",
+	や: "ya",
+	ゆ: "yu",
+	よ: "yo",
+	ら: "ra",
+	り: "ri",
+	る: "ru",
+	れ: "re",
+	ろ: "ro",
+	わ: "wa",
+	ゐ: "i",
+	ゑ: "e",
+	を: "o",
+	ゔ: "vu",
+	ぁ: "a",
+	ぃ: "i",
+	ぅ: "u",
+	ぇ: "e",
+	ぉ: "o",
+	ゃ: "ya",
+	ゅ: "yu",
+	ょ: "yo",
+	ゎ: "wa"
+};
+const YOON = {
+	ゃ: "a",
+	ゅ: "u",
+	ょ: "o"
+};
+function syllables(kana) {
+	const out = [];
+	for (let i = 0; i < kana.length; i++) {
+		const c = kana[i];
+		const small = YOON[kana[i + 1] ?? ""];
+		const base = ROMAJI[c];
+		if (small && base && base.length > 1 && base.endsWith("i")) {
+			const stem = base.slice(0, -1);
+			out.push({
+				kana: c + kana[++i],
+				romaji: (/(?:sh|ch|j)$/.test(stem) ? stem : `${stem}y`) + small
+			});
+		} else out.push({
+			kana: c,
+			romaji: base ?? c
+		});
+	}
+	return out;
+}
+function doubled(next) {
+	if (next.startsWith("ch")) return "t";
+	return /^[^aeiou\W]/.test(next) ? next[0] : "";
+}
+/** Folds a long vowel into a macron: おう and おお give ō, うう gives ū. */
+function lengthen(out, kana) {
+	if (kana === "う" && /[ou]$/.test(out) || kana === "お" && out.endsWith("o")) return out.slice(0, -1) + (out.endsWith("u") ? "ū" : "ō");
+}
+/**
+* Modified Hepburn with macrons (きょう → kyō, おおきい → ōkii). `following` is
+* the kana written after this one in the word, so a trailing っ can double
+* the next consonant (学 がっ before こう → gak).
+*/
+function toHepburn(kana, following = "") {
+	const parts = syllables(kana);
+	const after = [...parts, ...syllables(following)];
+	let out = "";
+	parts.forEach(({ kana: k, romaji }, i) => {
+		const next = after.slice(i + 1).find((s) => s.kana !== "っ")?.romaji ?? "";
+		if (k === "っ") out += doubled(next);
+		else if (k === "ん") out += i + 1 < parts.length && /^[aeiouy]/.test(next) ? "n'" : "n";
+		else out = lengthen(out, k) ?? out + romaji;
+	});
+	return out;
+}
+//#endregion
+//#region src/fea.ts
+/**
+* Rules per subtable of the main lookup. Breaking it up lets the compiler pack
+* each part as one glyph-keyed format 1 subtable under the 16-bit offset limit,
+* instead of thousands of format 3 subtables; order is kept across the breaks.
+*/
+const RULES_PER_SUBTABLE = 600;
+function block(keyword, name, body) {
+	return `${keyword} ${name}${keyword === "lookup" ? " useExtension" : ""} {\n${body.map((l) => `  ${l}`).join("\n")}\n} ${name};\n`;
+}
+/** A lookup of single substitutions, or none when there are none. */
+function singleLookup(name, substitutions) {
+	return substitutions.length ? [block("lookup", name, substitutions.map((s) => `sub ${s.input} by ${s.output};`))] : [];
+}
+function chainRule(rule) {
+	if (rule.ignore) return `ignore sub ${rule.input.map((g) => `${g}'`).join(" ")};`;
+	return `sub ${rule.input.map((g, i) => `${g}'${rule.lookups[i] ? ` lookup ${rule.lookups[i]}` : ""}`).join(" ")};`;
+}
+const glyphClass = (substitutions) => `[${substitutions.map((s) => s.input).join(" ")}]`;
+/** The chain rules, longest first, then the suffix and lone-kanji class rules. */
+function mainRules(input) {
+	const words = input.rules.flatMap((rule, i) => i && i % RULES_PER_SUBTABLE === 0 ? ["subtable;", chainRule(rule)] : [chainRule(rule)]);
+	const classes = [];
+	const final = input.suffixes.filter((s) => s.final);
+	if (final.length) classes.push(`ignore sub @han ${glyphClass(final)}' @han;`);
+	if (input.suffixes.length) classes.push(`sub @han ${glyphClass(input.suffixes)}' lookup suffixes;`);
+	if (input.isolated.length) {
+		const kanji = glyphClass(input.isolated);
+		classes.push(`ignore sub @han ${kanji}';`, `ignore sub ${kanji}' @han;`, `sub ${kanji}' lookup isolated;`);
+	}
+	return [
+		...words,
+		...words.length && classes.length ? ["subtable;"] : [],
+		...classes
+	];
+}
+/**
+* Writes the feature file. Nested lookups come first so the main one can call
+* them; the fallbacks come after it, in lookup order, so they only see what it
+* left: `ccmp` turns unclaimed variant glyphs back into kanji, `ss01` undoes ruby.
+*/
+function emitFea(input) {
+	const out = ["languagesystem DFLT dflt;\n"];
+	if (input.hanClass.length) out.push(`@han = [${input.hanClass.join(" ")}];\n`);
+	const bySlot = Map.groupBy(input.singles, (s) => s.lookup);
+	for (const [lookup, singles] of [...bySlot].sort((a, b) => a[0].localeCompare(b[0], "en", { numeric: true }))) out.push(block("lookup", lookup, singles.map((s) => `sub ${s.input} by ${s.output};`)));
+	const byLigatureSlot = Map.groupBy(input.ligatures, (l) => l.lookup);
+	for (const [lookup, ligatures] of [...byLigatureSlot].sort((a, b) => a[0].localeCompare(b[0], "en", { numeric: true }))) out.push(block("lookup", lookup, ligatures.map((l) => `sub ${l.components.join(" ")} by ${l.glyph};`)));
+	out.push(...singleLookup("isolated", input.isolated), ...singleLookup("suffixes", input.suffixes));
+	const salt = {
+		lookup: [],
+		feature: []
+	};
+	if (input.alternates.length) {
+		const selectors = `[${input.alternates.flatMap((a) => a.outputs).join(" ")}]`;
+		salt.lookup = [
+			block("lookup", "alternates", input.alternates.map((a) => `sub ${a.input} from [${a.outputs.join(" ")}];`)),
+			block("lookup", "salt_back", input.alternates.flatMap((a) => a.outputs.map((o) => `sub ${o} by ${a.input};`))),
+			block("lookup", "salt_first", [`sub @han ${selectors}' lookup salt_back;`])
+		];
+		salt.feature = [block("feature", "salt", ["lookup alternates;", "lookup salt_first;"])];
+	}
+	out.push(...salt.lookup);
+	const main = mainRules(input);
+	if (main.length) out.push(block("lookup", "furigana", main));
+	out.push(...singleLookup("variant_readings", input.variantReadings), ...singleLookup("variants_off", input.variantsOff));
+	const singles = input.rubyOff.filter((r) => r.bases.length === 1);
+	const ligatures = input.rubyOff.filter((r) => r.bases.length > 1);
+	const off = [];
+	if (singles.length) {
+		out.push(block("lookup", "ruby_off", singles.map((r) => `sub ${r.glyph} by ${r.bases[0]};`)));
+		off.push("lookup ruby_off;");
+	}
+	if (ligatures.length) {
+		out.push(block("lookup", "ruby_off_ligatures", ligatures.map((r) => `sub ${r.glyph} by ${r.bases.join(" ")};`)));
+		off.push("lookup ruby_off_ligatures;");
+	}
+	const rclt = [main.length && "lookup furigana;", input.variantReadings.length && "lookup variant_readings;"].filter((l) => typeof l === "string");
+	if (rclt.length) out.push(block("feature", "rclt", rclt));
+	if (input.variantsOff.length) out.push(block("feature", "ccmp", ["lookup variants_off;"]));
+	if (off.length) out.push(block("feature", "ss01", off));
+	out.push(...salt.feature);
+	return out.join("\n");
+}
+//#endregion
+//#region src/planner.ts
+/** VS225: shows the kanji before it without ruby. */
+const SELECTOR_SUPPRESS = 917984;
+/** VS226: reading 1 of the kanji (or word) before it; VS227 reading 2, and so on. */
+const SELECTOR_FIRST_READING = 917985;
+/** The IVD leaves VS225..VS240 unregistered: one to suppress, fifteen readings. */
+const MAX_READINGS = 15;
+/** A lone kanji's reading needs this share of the evidence to be offered through a selector. */
+const MIN_ALTERNATE_SHARE = .02;
+/** A suffix reading is the one a kanji takes in this share of the runs it ends, out of at least `SUFFIX_MIN_RUNS`. */
+const SUFFIX_MIN_SHARE = .9;
+const SUFFIX_MIN_RUNS = 10;
+/** With this many uses alone in the example sentences, they decide a lone kanji rather than the word lists. */
+const LONE_MIN_USES = 20;
+/** JMdict orders readings within a form; a run read inside a longer form ranks after the form's own readings. */
+const OTHER_FORM_ORDER = 1e3;
+const length = (text) => [...text].length;
+function spanKey(spans) {
+	return spans.map((s) => `${s.start}-${s.end}:${s.ruby}`).join(";");
+}
+function rank(a, b) {
+	return (b.pinned ?? 0) - (a.pinned ?? 0) || Number(b.tagged) - Number(a.tagged) || a.order - b.order || b.weight - a.weight;
+}
+/** Rough corpus frequency of an entry: nf buckets hold ~500 words each, ranked by frequency. */
+function entryWeight(entry) {
+	if (!entry.priority) return 0;
+	const nf = entry.nf || Number(/nf(\d+)/.exec(entry.priority)?.[1] ?? 0);
+	if (nf) return 1 / nf;
+	return /[a-z]1\b/.test(entry.priority) ? 1 / 24 : 1 / 48;
+}
+function keepBest(current, value) {
+	current.weight = Math.max(current.weight, value.weight);
+	if (value.nf && (!current.nf || value.nf < current.nf)) current.nf = value.nf;
+	current.jlpt = Math.max(current.jlpt, value.jlpt);
+	for (const tag of value.tags) current.tags.add(tag);
+}
+function priorityTags(entry) {
+	return new Set(entry.priority.split(" ").filter(Boolean));
+}
+function getOrCreate(map, key, create) {
+	let value = map.get(key);
+	if (value === void 0) map.set(key, value = create());
+	return value;
+}
+function indexRun(index, run, entry) {
+	const order = run.text === entry.form ? entry.order : OTHER_FORM_ORDER + entry.order;
+	const reading = {
+		spans: run.spans,
+		weight: entryWeight(entry),
+		tagged: !!entry.priority,
+		order,
+		nf: entry.priority ? entry.nf : 0,
+		jlpt: entry.jlpt ?? 0,
+		tags: priorityTags(entry),
+		tatoeba: entry.tatoeba ?? 0
+	};
+	const readings = getOrCreate(index.runs, run.text, () => /* @__PURE__ */ new Map());
+	const current = readings.get(spanKey(run.spans));
+	if (!current) {
+		readings.set(spanKey(run.spans), reading);
+		return;
+	}
+	keepBest(current, reading);
+	current.tagged ||= reading.tagged;
+	current.order = Math.min(current.order, reading.order);
+	current.tatoeba = Math.max(current.tatoeba ?? 0, reading.tatoeba);
+}
+function indexSingle(index, run, entry) {
+	const ruby = run.spans[0].ruby;
+	const readings = getOrCreate(index.singles, run.text, () => /* @__PURE__ */ new Map());
+	for (const r of entry.conjugatesReading && ruby === "く" ? [
+		"く",
+		"き",
+		"こ"
+	] : [ruby]) {
+		const value = {
+			weight: entryWeight(entry),
+			nf: entry.nf,
+			jlpt: entry.jlpt ?? 0,
+			tags: priorityTags(entry)
+		};
+		const current = readings.get(r);
+		if (current) keepBest(current, value);
+		else readings.set(r, value);
+	}
+}
+const OKURIGANA = /[\u3041-\u3096]/;
+function indexEntry(index, entry) {
+	for (const run of hanRuns(entry.form, parseFurigana(entry.furigana))) {
+		if (length(run.text) > 1) {
+			indexRun(index, run, entry);
+			continue;
+		}
+		if (entry.tatoeba && !entry.conjugatesReading) {
+			const uses = getOrCreate(index.loneUses, run.text, () => /* @__PURE__ */ new Map());
+			uses.set(run.spans[0].ruby, (uses.get(run.spans[0].ruby) ?? 0) + entry.tatoeba);
+		}
+		if (entry.priority) indexSingle(index, run, entry);
+		else if (OKURIGANA.test(entry.form[entry.form.indexOf(run.text) + run.text.length] ?? "")) getOrCreate(index.inflecting, run.text, () => /* @__PURE__ */ new Set()).add(run.spans[0].ruby);
+	}
+}
+function createContext(dictionary, options, coverage) {
+	const covered = (text) => codepoints(text).every((cp) => coverage.has(cp));
+	const render = (run, index) => {
+		const span = run.spans[index];
+		if (options.rubyScript === "hepburn") return toHepburn(span.ruby, run.spans.slice(index + 1).map((s) => s.ruby).join(""));
+		const kanji = [...run.text].slice(span.start, span.end);
+		if (options.rubyScript === "katakanaOn" && kanji.length === 1 && isOnyomi(span.ruby, dictionary.onyomi[kanji[0]] ?? [])) return toKatakana(span.ruby);
+		return span.ruby;
+	};
+	const known = options.skipJlpt ? Number(options.skipJlpt.slice(1)) : Infinity;
+	return {
+		options,
+		removed: /* @__PURE__ */ new Set([...dictionary.bare ?? [], ...options.words.remove]),
+		covered,
+		selected: (r) => r.nf >= options.nfMin && r.nf <= options.nfMax || options.selectTags.some((t) => r.tags.has(t)) || options.minTatoeba > 0 && (r.tatoeba ?? 0) >= options.minTatoeba,
+		skipped: (r) => r.nf > 0 && r.nf < options.nfMin || r.jlpt >= known,
+		render,
+		renderable: (run) => covered(run.text) && run.spans.every((_, i) => covered(render(run, i)))
+	};
+}
+function addCustomWord(patterns, lonePins, notation, pinned, ctx) {
+	const { form, spans } = parseNotation(notation);
+	for (const run of hanRuns(form, spans).filter(ctx.renderable)) {
+		if (length(run.text) === 1) {
+			if (pinned) lonePins.set(run.text, run.spans[0].ruby);
+			continue;
+		}
+		if (pinned === 1 && !patterns.has(run.text)) continue;
+		const readings = getOrCreate(patterns, run.text, () => []);
+		const existing = readings.find((r) => spanKey(r.spans) === spanKey(run.spans));
+		if (existing) existing.pinned = Math.max(existing.pinned ?? 0, pinned);
+		else readings.push({
+			spans: run.spans,
+			weight: 1,
+			tagged: true,
+			order: Number.MAX_SAFE_INTEGER,
+			nf: 1,
+			jlpt: 0,
+			tags: /* @__PURE__ */ new Set(),
+			pinned
+		});
+	}
+}
+/** Place names fill the runs no common word claims, nor a skipped one. */
+function addPlaces(patterns, places, skipped, ctx) {
+	for (const place of places ?? []) {
+		const spans = parseFurigana(place.furigana);
+		if (patterns.has(place.form) || skipped.has(place.form) || ctx.removed.has(place.form) || !ctx.renderable({
+			text: place.form,
+			spans
+		})) continue;
+		patterns.set(place.form, [{
+			spans,
+			weight: 0,
+			tagged: false,
+			order: 0,
+			nf: 0,
+			jlpt: 0,
+			tags: /* @__PURE__ */ new Set(),
+			place: true
+		}]);
+	}
+}
+/**
+* Runs of common words, then place names and custom words; pinned readings of
+* lone kanji are returned apart. A word is skipped whole: were only its known
+* reading dropped, 今日 would show こんにち.
+*/
+function selectWords(index, dictionary, ctx) {
+	const patterns = /* @__PURE__ */ new Map();
+	const skipped = /* @__PURE__ */ new Set();
+	for (const [text, readings] of index.runs) {
+		if (ctx.removed.has(text)) continue;
+		if ([...readings.values()].some(ctx.skipped)) {
+			skipped.add(text);
+			continue;
+		}
+		const common = [...readings.values()].filter((r) => ctx.selected(r) && ctx.renderable({
+			text,
+			spans: r.spans
+		}));
+		if (common.length) patterns.set(text, common.map((r) => ({ ...r })));
+	}
+	if (ctx.options.places) addPlaces(patterns, dictionary.places, skipped, ctx);
+	const lonePins = /* @__PURE__ */ new Map();
+	for (const notation of ctx.options.words.add) addCustomWord(patterns, lonePins, notation, 0, ctx);
+	for (const notation of dictionary.defaults ?? []) addCustomWord(patterns, lonePins, notation, 1, ctx);
+	for (const notation of ctx.options.words.pin) addCustomWord(patterns, lonePins, notation, 2, ctx);
+	for (const readings of patterns.values()) readings.sort(rank).splice(15);
+	return {
+		patterns,
+		lonePins,
+		skipped
+	};
+}
+/** Readings of a lone kanji the font can draw, heaviest first, with their share of the evidence. */
+function loneReadings(kanji, readings, ctx) {
+	const drawable = [...readings].filter(([ruby]) => ctx.renderable({
+		text: kanji,
+		spans: [{
+			start: 0,
+			end: 1,
+			ruby
+		}]
+	}));
+	const total = drawable.reduce((sum, [, r]) => sum + r.weight, 0);
+	return drawable.map(([ruby, r]) => ({
+		ruby,
+		weight: r.weight,
+		share: r.weight / total
+	})).sort((a, b) => b.weight - a.weight);
+}
+/** The reading running text gives a lone kanji most, with its share of the uses, when the sentences use the kanji alone often enough to tell. */
+function usedReading(kanji, uses, ctx) {
+	const drawable = [...uses ?? []].filter(([ruby]) => ctx.renderable({
+		text: kanji,
+		spans: [{
+			start: 0,
+			end: 1,
+			ruby
+		}]
+	}));
+	const total = drawable.reduce((sum, [, n]) => sum + n, 0);
+	if (ctx.options.minTatoeba === 0 || total < LONE_MIN_USES) return;
+	const [ruby, n] = drawable.sort((a, b) => b[1] - a[1])[0];
+	return {
+		ruby,
+		share: n / total
+	};
+}
+function addWordEvidence(patterns, add) {
+	for (const [text, readings] of patterns) {
+		const chars = [...text];
+		for (const r of readings.filter((r) => !r.place)) for (const s of r.spans.filter((s) => s.end - s.start === 1)) add(chars[s.start], s.ruby, r.weight || 1e-6);
+	}
+}
+/** Last in each list: readings a selector helper may need for verbs too rare to rank. */
+function addRareVerbEvidence(inflecting, ctx, add) {
+	for (const [kanji, rubies] of inflecting) for (const ruby of [...rubies].filter((ruby) => !ctx.removed.has(kanji) && ctx.renderable({
+		text: kanji,
+		spans: [{
+			start: 0,
+			end: 1,
+			ruby
+		}]
+	}))) add(kanji, ruby, 1e-9);
+}
+/**
+* A kanji alone in its run gets ruby only when one reading clearly dominates
+* the common words it stands alone in, whatever the word list's size: verbs
+* like 書く rank low in newspapers yet decide how 書 reads. Every kanji also
+* gets an ordered list of its readings, which the variation selectors index
+* into, except a kanji whose dominant reading the reader is taken to know.
+*/
+function chooseLoneKanji(index, patterns, lonePins, ctx) {
+	const isolated = new Map(ctx.options.isolated ? lonePins : []);
+	const skipped = /* @__PURE__ */ new Set();
+	const evidence = /* @__PURE__ */ new Map();
+	const add = (kanji, ruby, weight) => {
+		const readings = getOrCreate(evidence, kanji, () => /* @__PURE__ */ new Map());
+		readings.set(ruby, (readings.get(ruby) ?? 0) + weight);
+	};
+	for (const [kanji, ruby] of lonePins) add(kanji, ruby, 1);
+	for (const [kanji, readings] of index.singles) {
+		if (ctx.removed.has(kanji)) continue;
+		const ranked = loneReadings(kanji, readings, ctx).filter((r) => r.share >= MIN_ALTERNATE_SHARE);
+		const top = ranked[0];
+		const chosen = usedReading(kanji, index.loneUses.get(kanji), ctx) ?? top;
+		if (top && !lonePins.has(kanji) && ctx.skipped(readings.get(top.ruby))) skipped.add(kanji);
+		else if (chosen && chosen.share >= ctx.options.isolatedMinShare && ctx.options.isolated && !isolated.has(kanji)) isolated.set(kanji, chosen.ruby);
+		for (const r of ranked) add(kanji, r.ruby, r.weight);
+	}
+	addWordEvidence(patterns, add);
+	addRareVerbEvidence(index.inflecting, ctx, add);
+	const kanjiReadings = /* @__PURE__ */ new Map();
+	for (const [kanji, readings] of evidence) {
+		if (skipped.has(kanji)) continue;
+		const ordered = [...readings].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+		kanjiReadings.set(kanji, ordered.slice(0, 15).map(([r]) => r));
+	}
+	return {
+		isolated,
+		kanjiReadings
+	};
+}
+/**
+* A kanji no word claimed after another kanji, as 的 in 平均的 or 者 in
+* 被災者支援, reads as it reads ending the dictionary's runs, when one reading
+* clearly dominates there: 的 てき, 化 か; not 人, にん or じん.
+*/
+function chooseSuffixes(index, ctx) {
+	const suffixes = {
+		readings: /* @__PURE__ */ new Map(),
+		final: /* @__PURE__ */ new Set()
+	};
+	if (!ctx.options.isolated) return suffixes;
+	const evidence = /* @__PURE__ */ new Map();
+	const count = (counts, key) => void counts.set(key, (counts.get(key) ?? 0) + 1);
+	const starts = /* @__PURE__ */ new Map();
+	const ends = /* @__PURE__ */ new Map();
+	for (const [text, readings] of index.runs) {
+		const chars = [...text];
+		count(starts, chars[0]);
+		count(ends, chars.at(-1));
+		for (const { spans } of readings.values()) {
+			const span = spans.at(-1);
+			if (span.end - span.start === 1) count(getOrCreate(evidence, chars.at(-1), () => /* @__PURE__ */ new Map()), span.ruby);
+		}
+	}
+	for (const [kanji, counts] of evidence) {
+		const total = [...counts.values()].reduce((a, b) => a + b, 0);
+		const [ruby, top] = [...counts].sort((a, b) => b[1] - a[1])[0];
+		if (total < SUFFIX_MIN_RUNS || top / total < SUFFIX_MIN_SHARE || ctx.removed.has(kanji) || !ctx.renderable({
+			text: kanji,
+			spans: [{
+				start: 0,
+				end: 1,
+				ruby
+			}]
+		})) continue;
+		suffixes.readings.set(kanji, ruby);
+		if ((starts.get(kanji) ?? 0) > ends.get(kanji)) suffixes.final.add(kanji);
+	}
+	return suffixes;
+}
+/** Per character, the span reading it; keys are relative so they compare at any offset. */
+function assignment(spans, size) {
+	const out = Array.from({ length: size });
+	for (const s of spans) for (let i = s.start; i < s.end; i++) out[i] = `${s.start - i}:${s.end - i}:${s.ruby}`;
+	return out;
+}
+/** The suffix reading of the kanji at `p` of a run when no word claimed it. */
+function suffixAt(chars, p, suffixes) {
+	const kanji = chars[p];
+	return p > 0 && (p === chars.length - 1 || !suffixes.final.has(kanji)) ? suffixes.readings.get(kanji) : void 0;
+}
+/** Runs the longest-match rules, then the suffix ones, over `chars` and reports whether any kanji gets a reading other than `expected`. */
+function misreads(chars, expected, known, longest, suffixes) {
+	for (let p = 0; p < chars.length;) {
+		let size = Math.min(longest, chars.length - p);
+		for (; size >= 2; size--) {
+			const hit = known.get(chars.slice(p, p + size).join(""));
+			if (hit !== void 0) {
+				if (hit?.some((key, i) => key !== void 0 && key !== expected[p + i])) return true;
+				break;
+			}
+		}
+		const suffix = size < 2 ? suffixAt(chars, p, suffixes) : void 0;
+		if (suffix !== void 0 && expected[p] !== `0:1:${suffix}`) return true;
+		p += Math.max(size, 1);
+	}
+	return false;
+}
+/**
+* Longer dictionary words that the selected words would misread, such as
+* 大人気 read through 大人: annotated with their own reading when that only
+* takes readings the font already has, left bare otherwise. Skipped words are
+* always left bare.
+*/
+function findMisreadRuns(index, patterns, kanjiReadings, suffixes, skipped, ctx) {
+	const known = new Map([...patterns].map(([text, readings]) => [text, assignment(readings[0].spans, length(text))]));
+	const protectedRuns = /* @__PURE__ */ new Map();
+	for (const text of [...ctx.removed].filter((t) => length(t) > 1)) {
+		known.set(text, null);
+		protectedRuns.set(text, null);
+	}
+	const protect = (text, readings, longest) => {
+		const chars = [...text];
+		const candidates = [...new Set([...readings.values()].map((r) => assignment(r.spans, chars.length).join("|")))];
+		const expected = [...readings.values()].map((r) => assignment(r.spans, chars.length));
+		if (!expected.some((e) => misreads(chars, e, known, longest, suffixes))) return false;
+		const truth = [...readings.values()].sort(rank)[0];
+		const run = {
+			text,
+			spans: truth.spans
+		};
+		const reusable = !skipped.has(text) && candidates.length === 1 && !isGrouped(run) && ctx.renderable(run) && truth.spans.every((s) => kanjiReadings.get(chars[s.start])?.includes(s.ruby));
+		protectedRuns.set(text, reusable ? truth.spans : null);
+		known.set(text, reusable ? expected[0] : null);
+		return true;
+	};
+	for (let pass = 0, changed = true; changed && pass < 5; pass++) {
+		let longest = 2;
+		for (const text of known.keys()) longest = Math.max(longest, length(text));
+		changed = false;
+		for (const [text, readings] of index.runs) if (!known.has(text) && ctx.covered(text) && protect(text, readings, longest)) changed = true;
+	}
+	return protectedRuns;
+}
+/**
+* A base kanji followed by a variation selector is its own glyph, mapped in
+* `cmap` format 14 like any registered ideographic variation. Browsers keep a
+* supported sequence in the run they shape (they split unsupported ones off),
+* and the rules see the choice as a glyph. The glyph itself is empty: the rules
+* always replace it, by a ruby glyph or, failing that, by the bare kanji.
+*/
+function createVariants() {
+	const variants = /* @__PURE__ */ new Map();
+	return {
+		/** `kanji` written with VS225 + `n`: n = 0 drops the ruby, n >= 1 picks reading n. */
+		name(kanji, n) {
+			const base = kanji.codePointAt(0);
+			const name = `${glyphName(base)}.vs${n}`;
+			variants.set(name, {
+				name,
+				base,
+				selector: SELECTOR_SUPPRESS + n
+			});
+			return name;
+		},
+		all: () => [...variants.values()]
+	};
+}
+function buildRules(patterns, kanjiReadings, protectedRuns, glyphs) {
+	const ligatures = /* @__PURE__ */ new Map();
+	const perComponents = /* @__PURE__ */ new Map();
+	const ligatureLookup = (components, glyph, codepoints) => {
+		const key = `${components.join(" ")}>${glyph}`;
+		let ligature = ligatures.get(key);
+		if (!ligature) {
+			const n = (perComponents.get(components.join(" ")) ?? 0) + 1;
+			perComponents.set(components.join(" "), n);
+			ligatures.set(key, ligature = {
+				lookup: `lig_${n}`,
+				glyph,
+				components,
+				codepoints
+			});
+		}
+		return ligature.lookup;
+	};
+	const singles = createSingleLookups();
+	const variants = createVariants();
+	/** The rule annotating `run`; with `reading`, written with that reading's selector after its first kanji. */
+	const runRule = (run, reading) => {
+		const cps = codepoints(run.text);
+		const input = cps.map(glyphName);
+		if (reading) {
+			input[0] = variants.name(run.text, reading);
+			cps.splice(1, 0, SELECTOR_SUPPRESS + reading);
+		}
+		const output = glyphs.run(run);
+		if (isGrouped(run)) {
+			const lookup = ligatureLookup(input, output[0].name, cps);
+			return {
+				input,
+				lookups: input.map((_, i) => i === 0 ? lookup : null),
+				codepoints: cps
+			};
+		}
+		return {
+			input,
+			lookups: output.map((g, i) => singles.lookupFor(input[i], g.name)),
+			codepoints: cps
+		};
+	};
+	const rules = [];
+	const ivsWords = {};
+	for (const [text, readings] of patterns) {
+		rules.push(runRule({
+			text,
+			spans: readings[0].spans
+		}));
+		if (readings.length < 2) continue;
+		readings.forEach((r, i) => rules.push(runRule({
+			text,
+			spans: r.spans
+		}, i + 1)));
+		ivsWords[text] = readings.map((r) => formatNotation(text, r.spans));
+	}
+	for (const [text, spans] of protectedRuns) {
+		const cps = codepoints(text);
+		rules.push(spans ? runRule({
+			text,
+			spans
+		}) : {
+			input: cps.map(glyphName),
+			lookups: [],
+			codepoints: cps,
+			ignore: true
+		});
+	}
+	const variantReadings = [];
+	for (const [kanji, readings] of kanjiReadings) {
+		variants.name(kanji, 0);
+		if (readings.length < 2) continue;
+		readings.forEach((ruby, i) => variantReadings.push({
+			input: variants.name(kanji, i + 1),
+			glyph: glyphs.lone(kanji, ruby),
+			selector: SELECTOR_SUPPRESS + i + 1
+		}));
+	}
+	rules.sort((a, b) => a.input[0].localeCompare(b.input[0]) || b.input.length - a.input.length);
+	const top = /* @__PURE__ */ new Map();
+	for (const { base, selector } of variants.all()) if (selector > 917984) top.set(base, Math.max(top.get(base) ?? 0, selector - SELECTOR_SUPPRESS));
+	const alternates = [...top].map(([base, n]) => ({
+		input: glyphName(base),
+		outputs: Array.from({ length: n }, (_, i) => variants.name(String.fromCodePoint(base), i + 1))
+	}));
+	return {
+		rules,
+		ligatures: [...ligatures.values()],
+		singles,
+		variants: variants.all(),
+		variantReadings,
+		alternates,
+		ivsWords
+	};
+}
+function smokeChecks(patterns, lone, glyphs) {
+	const byFrequency = [...patterns].sort((a, b) => (a[1][0].nf || 99) - (b[1][0].nf || 99));
+	const checks = [];
+	for (const grouped of [false, true]) for (const [text, readings] of byFrequency.filter(([text, r]) => isGrouped({
+		text,
+		spans: r[0].spans
+	}) === grouped).slice(0, 3)) checks.push({
+		text,
+		glyphs: glyphs.run({
+			text,
+			spans: readings[0].spans
+		}).map((g) => g.name)
+	});
+	const [word, readings] = byFrequency.find(([, r]) => r.length > 1) ?? [];
+	if (word && readings) {
+		const [first = "", ...rest] = [...word];
+		checks.push({
+			text: first + String.fromCodePoint(917986) + rest.join(""),
+			glyphs: glyphs.run({
+				text: word,
+				spans: readings[1].spans
+			}).map((g) => g.name)
+		});
+	}
+	if (lone[0]) checks.push({
+		text: String.fromCodePoint(lone[0].glyph.bases[0]),
+		glyphs: [lone[0].glyph.name]
+	});
+	return checks;
+}
+/**
+* Indexes the dictionary once into Han runs, then plans fonts from it. Every
+* decision about readings happens here: which words get ruby, which reading
+* is the default, which longer words must be protected from a shorter match.
+*/
+function createFontPlanner(dictionary) {
+	const index = {
+		runs: /* @__PURE__ */ new Map(),
+		singles: /* @__PURE__ */ new Map(),
+		inflecting: /* @__PURE__ */ new Map(),
+		loneUses: /* @__PURE__ */ new Map()
+	};
+	for (const entry of dictionary.entries) indexEntry(index, entry);
+	const sources = Object.entries(dictionary.sources).map(([name, version]) => `${name} ${version}`).join(", ");
+	/** Every decision for one set of options, over the whole dictionary: slow, and the same whatever the preview text. */
+	function analyze(options, coverage) {
+		const ctx = createContext(dictionary, options, coverage);
+		const { patterns, lonePins, skipped } = selectWords(index, dictionary, ctx);
+		const { isolated, kanjiReadings } = chooseLoneKanji(index, patterns, lonePins, ctx);
+		const suffixes = chooseSuffixes(index, ctx);
+		const protectedRuns = findMisreadRuns(index, patterns, kanjiReadings, suffixes, skipped, ctx);
+		const glyphs = createGlyphRegistry(ctx.render);
+		const { rules, ligatures, singles, variants, variantReadings, alternates, ivsWords } = buildRules(patterns, kanjiReadings, protectedRuns, glyphs);
+		const loneGlyphs = (readings) => [...readings].map(([kanji, ruby]) => ({
+			base: glyphName(kanji.codePointAt(0)),
+			glyph: glyphs.lone(kanji, ruby)
+		}));
+		return {
+			patterns,
+			isolated,
+			kanjiReadings,
+			protectedRuns,
+			glyphs,
+			rules,
+			ligatures,
+			singles,
+			variants,
+			variantReadings,
+			alternates,
+			ivsWords,
+			lone: loneGlyphs(isolated),
+			suffixes: loneGlyphs(suffixes.readings),
+			finalSuffixes: new Set([...suffixes.final].map((k) => glyphName(k.codePointAt(0))))
+		};
+	}
+	let last;
+	function analysisFor(options, coverage) {
+		const key = JSON.stringify(options);
+		if (last?.options !== key || last.coverage !== coverage) last = {
+			options: key,
+			coverage,
+			analysis: analyze(options, coverage)
+		};
+		return last.analysis;
+	}
+	/** Plans a font; with `previewText`, keeps only what that text can trigger. */
+	return function planFont(options, coverage, previewText) {
+		const { patterns, isolated, kanjiReadings, protectedRuns, glyphs, rules, ligatures, singles, variants, variantReadings, alternates, ivsWords, lone, suffixes, finalSuffixes } = analysisFor(options, coverage);
+		const sample = previewText === void 0 ? void 0 : new Set(codepoints(previewText));
+		const inSample = (cps) => !sample || cps.every((cp) => sample.has(cp));
+		const keptRules = rules.filter((r) => inSample(r.codepoints));
+		const keptLone = lone.filter((l) => inSample(l.glyph.bases));
+		const keptSuffixes = suffixes.filter((l) => inSample(l.glyph.bases));
+		const keptVariants = variants.filter((v) => inSample([v.base, v.selector]));
+		const keptVariantReadings = variantReadings.filter((v) => inSample([...v.glyph.bases, v.selector]));
+		const keptAlternates = sample ? [] : alternates;
+		const usedLookups = new Set(keptRules.flatMap((r) => r.lookups.map((lookup, i) => `${r.input[i]}@${lookup}`)));
+		const keptSingles = singles.all().filter((s) => usedLookups.has(`${s.input}@${s.lookup}`));
+		const keptLigatures = ligatures.filter((l) => inSample(l.codepoints));
+		const keptNames = /* @__PURE__ */ new Set([
+			...keptSingles.map((s) => s.output),
+			...keptLigatures.map((l) => l.glyph),
+			...keptLone.map((l) => l.glyph.name),
+			...keptSuffixes.map((l) => l.glyph.name),
+			...keptVariantReadings.map((v) => v.glyph.name)
+		]);
+		const keptGlyphs = glyphs.all().filter((g) => keptNames.has(g.name));
+		const han = [...coverage].filter((cp) => inSample([cp]) && isHan(String.fromCodePoint(cp))).sort((a, b) => a - b);
+		const fea = emitFea({
+			hanClass: [
+				...han.map(glyphName),
+				...keptVariants.map((v) => v.name),
+				...keptGlyphs.map((g) => g.name)
+			],
+			singles: keptSingles,
+			ligatures: keptLigatures,
+			isolated: keptLone.map((l) => ({
+				input: l.base,
+				output: l.glyph.name
+			})),
+			suffixes: keptSuffixes.map((l) => ({
+				input: l.base,
+				output: l.glyph.name,
+				final: finalSuffixes.has(l.base)
+			})),
+			rules: keptRules,
+			variantReadings: keptVariantReadings.map((v) => ({
+				input: v.input,
+				output: v.glyph.name
+			})),
+			alternates: keptAlternates,
+			variantsOff: keptVariants.map((v) => ({
+				input: v.name,
+				output: glyphName(v.base)
+			})),
+			rubyOff: keptGlyphs.map((g) => ({
+				glyph: g.name,
+				bases: g.bases.map(glyphName)
+			}))
+		});
+		const named = /* @__PURE__ */ new Set([
+			...han,
+			...keptVariants.map((v) => v.base),
+			...keptGlyphs.flatMap((g) => g.bases)
+		]);
+		return {
+			plan: {
+				version: 1,
+				names: {
+					family: options.family,
+					description: `Furigana rules compiled from ${sources} (CC BY-SA 4.0: EDRDG, JmdictFurigana, stephenmk after Jonathan Waller; CC BY 2.0 FR: Tatoeba).`
+				},
+				metrics: options.metrics,
+				codepoints: [...named].sort((a, b) => a - b),
+				variants: keptVariants,
+				glyphs: keptGlyphs,
+				fea,
+				subset: sample && [.../* @__PURE__ */ new Set([...sample, ...keptGlyphs.flatMap((g) => g.ruby.flatMap((r) => codepoints(r.text)))])].filter((cp) => !keptVariants.some((v) => v.selector === cp)).sort((a, b) => a - b),
+				smoke: sample ? [] : smokeChecks(patterns, lone, glyphs)
+			},
+			report: {
+				stats: {
+					patterns: patterns.size,
+					places: [...patterns.values()].filter((r) => r[0].place).length,
+					ambiguous: Object.keys(ivsWords).length,
+					isolated: isolated.size,
+					suffixes: suffixes.length,
+					protectedAnnotated: [...protectedRuns.values()].filter(Boolean).length,
+					protectedBare: [...protectedRuns.values()].filter((s) => !s).length,
+					glyphs: keptGlyphs.length,
+					rules: keptRules.length
+				},
+				ivs: {
+					kanji: Object.fromEntries(kanjiReadings),
+					words: ivsWords,
+					lone: Object.fromEntries(isolated),
+					salt: keptAlternates.length > 0
+				}
+			}
+		};
+	};
+}
+//#endregion
+//#region src/schema.ts
+const RUBY_SCRIPTS = [
+	"hiragana",
+	"katakanaOn",
+	"hepburn"
+];
+const PRIORITY_TAGS = [
+	"ichi1",
+	"ichi2",
+	"news1",
+	"news2",
+	"spec1",
+	"spec2",
+	"gai1",
+	"gai2"
+];
+/** Easiest first. */
+const JLPT_LEVELS = [
+	"N5",
+	"N4",
+	"N3",
+	"N2",
+	"N1"
+];
+/** Sizes in em, relative to the base font. */
+const RubyMetricsSchema = v.object({
+	/** Ruby size relative to the base characters. */
+	rubyScale: v.optional(v.pipe(v.number(), v.minValue(.2), v.maxValue(.8)), DEFAULTS.plan.metrics.rubyScale),
+	/** Space between the top of the em box and the bottom of the ruby. */
+	rubyGap: v.optional(v.pipe(v.number(), v.minValue(0), v.maxValue(.5)), DEFAULTS.plan.metrics.rubyGap),
+	/** Ruby is squeezed horizontally down to this scale before it may overhang. */
+	compressionFloor: v.optional(v.pipe(v.number(), v.minValue(.3), v.maxValue(1)), DEFAULTS.plan.metrics.compressionFloor),
+	/** Widest a ruby may get, overhanging its base symmetrically. */
+	maxRubyWidth: v.optional(v.pipe(v.number(), v.minValue(1), v.maxValue(3)), DEFAULTS.plan.metrics.maxRubyWidth)
+});
+const Bucket = v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(48));
+/** `schema`, checking that its frequency window `nfMin..nfMax` holds a bucket; for schemas that extend the options too. */
+function withNfWindow(schema) {
+	return v.pipe(schema, v.check((o) => o.nfMin <= o.nfMax, "nfMin must not exceed nfMax"));
+}
+const PlanOptionsSchema = withNfWindow(v.object({
+	family: v.optional(v.pipe(v.string(), v.trim(), v.nonEmpty(), v.check((name) => !/source/i.test(name), "Source is a reserved font name of the base font")), DEFAULTS.plan.family),
+	rubyScript: v.optional(v.picklist(RUBY_SCRIPTS), DEFAULTS.plan.rubyScript),
+	/**
+	* Words whose newspaper frequency bucket is below this stay bare: the most
+	* common ones, which a reader knows. Tags don't bring them back.
+	*/
+	nfMin: v.optional(Bucket, DEFAULTS.plan.nfMin),
+	/** Words whose newspaper frequency bucket is at most this are annotated. */
+	nfMax: v.optional(Bucket, DEFAULTS.plan.nfMax),
+	/**
+	* JMdict priority tags that select a word whatever its frequency bucket:
+	* `spec1` catches words like 日本 that the newspaper ranking misses.
+	*/
+	selectTags: v.optional(v.array(v.picklist(PRIORITY_TAGS)), () => [...DEFAULTS.plan.selectTags]),
+	/**
+	* Words of two or more kanji that Tatoeba's example sentences use at least
+	* this many times are annotated whatever their bucket: everyday words that
+	* no list tags, such as 留守中, which would otherwise be bare or read as a
+	* place name (国中 くになか, not くにじゅう). The sentences also decide how a
+	* lone kanji reads, where they use it alone often enough. 0 turns them off.
+	*/
+	minTatoeba: v.optional(v.pipe(v.number(), v.integer(), v.minValue(0)), DEFAULTS.plan.minTatoeba),
+	/** Words on the JLPT lists of this level and every easier one stay bare. */
+	skipJlpt: v.optional(v.picklist(JLPT_LEVELS)),
+	/** Annotate place names from the dictionary where no common word claims the run. */
+	places: v.optional(v.boolean(), DEFAULTS.plan.places),
+	/** Annotate a kanji alone in its run, or one no word claims after another kanji (a suffix); when off, only selectors give them ruby. */
+	isolated: v.optional(v.boolean(), DEFAULTS.plan.isolated),
+	/** A kanji alone in its run is annotated only when one reading has this share of the evidence. */
+	isolatedMinShare: v.optional(v.pipe(v.number(), v.minValue(.5), v.maxValue(1)), DEFAULTS.plan.isolatedMinShare),
+	words: v.optional(v.object({
+		/** Extra words in inline notation, `日[に]本[ほん]`. */
+		add: v.optional(v.array(v.string()), []),
+		/** Written forms never to annotate. */
+		remove: v.optional(v.array(v.string()), []),
+		/** Readings to make the default, in inline notation. */
+		pin: v.optional(v.array(v.string()), [])
+	}), {}),
+	metrics: v.optional(RubyMetricsSchema, {})
+}));
+function resolveOptions(input = {}) {
+	return v.parse(PlanOptionsSchema, input);
+}
+const Codepoint = v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(1114111));
+/**
+* The contract between the planner and the compiler. The compiler makes no
+* decision about readings: it draws what `glyphs` describes and compiles `fea`.
+* In `fea`, base characters are named `uniXXXX` / `uXXXXX` after their codepoint.
+*/
+const PlanSchema = v.object({
+	version: v.literal(1),
+	names: v.object({
+		family: v.string(),
+		description: v.string()
+	}),
+	metrics: v.object({
+		rubyScale: v.number(),
+		rubyGap: v.number(),
+		compressionFloor: v.number(),
+		maxRubyWidth: v.number()
+	}),
+	/** Base characters the rules name; each must be in the base font's cmap. */
+	codepoints: v.array(Codepoint),
+	/**
+	* Base + variation selector sequences to map in `cmap` format 14, each to an
+	* empty glyph named `name`, with the base's advance: the rules replace it.
+	*/
+	variants: v.array(v.object({
+		name: v.pipe(v.string(), v.regex(/^[A-Z_][\w.]{0,62}$/i)),
+		base: Codepoint,
+		selector: Codepoint
+	})),
+	glyphs: v.array(v.object({
+		name: v.pipe(v.string(), v.regex(/^[A-Z_][\w.]{0,62}$/i)),
+		/** The base characters drawn side by side; more than one makes a ligature. */
+		bases: v.pipe(v.array(Codepoint), v.minLength(1)),
+		/** Ruby text drawn above characters `[start, end)` of `bases`. */
+		ruby: v.array(v.object({
+			start: v.number(),
+			end: v.number(),
+			text: v.pipe(v.string(), v.nonEmpty())
+		}))
+	})),
+	fea: v.string(),
+	/** Subset the base font to these codepoints before building (live previews). */
+	subset: v.optional(v.array(Codepoint)),
+	/** Shaping checks the compiler runs on its output: `text` must shape to `glyphs`. */
+	smoke: v.array(v.object({
+		text: v.string(),
+		glyphs: v.array(v.string())
+	}))
+});
+//#endregion
+export { DEFAULTS, JLPT_LEVELS, MAX_READINGS, PREBUILT, PRIORITY_TAGS, PlanOptionsSchema, PlanSchema, RUBY_SCRIPTS, SELECTOR_FIRST_READING, SELECTOR_SUPPRESS, VERSION_PROBE, createFontPlanner, formatNotation, glyphName, hanRuns, isHan, isOnyomi, parseFurigana, parseNotation, resolveOptions, toHepburn, toHiragana, toKatakana, withNfWindow };