@furifont/core 0.4.2 → 0.5.0

package/dist/index.d.mts

@@ -9,7 +9,7 @@ export declare const DEFAULTS: {
   /** What a plan does when a config leaves an option out. */
   readonly plan: {
     readonly family: "Furifont Sans";
-    readonly rubyScript: "hiragana";
+    readonly furiganaScript: "hiragana";
     /** No word is left bare for being common; every word of every source gets ruby. */
     readonly skip: 0;
     readonly isolated: true;
@@ -35,22 +35,22 @@ export declare const PREBUILT: {
     readonly family: "Furifont Sans";
     readonly base: "Source Han Sans JP";
     readonly face: "sans";
-    readonly rubyScript: "hiragana";
+    readonly furiganaScript: "hiragana";
   }, {
     readonly family: "Furifont Sans Romaji";
     readonly base: "Source Han Sans JP";
     readonly face: "sans";
-    readonly rubyScript: "hepburn";
+    readonly furiganaScript: "hepburn";
   }, {
     readonly family: "Furifont Serif";
     readonly base: "Source Han Serif JP";
     readonly face: "serif";
-    readonly rubyScript: "hiragana";
+    readonly furiganaScript: "hiragana";
   }, {
     readonly family: "Furifont Serif Romaji";
     readonly base: "Source Han Serif JP";
     readonly face: "serif";
-    readonly rubyScript: "hepburn";
+    readonly furiganaScript: "hepburn";
   }];
   /** The static weights of the release, each of the base's weights by name. Bold is the variable font's. */
   readonly weights: readonly [{
@@ -82,7 +82,7 @@ export declare const VERSION_PROBE: {
 };
 //#endregion
 //#region src/schema.d.ts
-export declare const RUBY_SCRIPTS: readonly ["hiragana", "katakanaOn", "hepburn"];
+export declare const FURIGANA_SCRIPTS: readonly ["hiragana", "katakanaOn", "hepburn"];
 /** The dictionary's manually maintained sources. */
 export declare const MANUAL_SOURCES: readonly ["mahjong-yaku", "jr-stations", "yojijukugo", "japan-post"];
 type ManualSource = typeof MANUAL_SOURCES[number];
@@ -106,7 +106,7 @@ type Source = typeof SOURCES[number];
 export declare const sourceBit: (source: Source) => number;
 /** The sources a mask of `SOURCES` bits names. */
 export declare const sourcesIn: (mask: number) => Source[];
-type RubyScript = typeof RUBY_SCRIPTS[number];
+type FuriganaScript = typeof FURIGANA_SCRIPTS[number];
 /** Sizes in em, relative to the base font. */
 declare const RubyMetricsSchema: v.ObjectSchema<{
   /** Ruby size relative to the base characters. */
@@ -121,7 +121,7 @@ declare const RubyMetricsSchema: v.ObjectSchema<{
 type RubyMetrics = v.InferOutput<typeof RubyMetricsSchema>;
 export declare const PlanOptionsSchema: v.ObjectSchema<{
   readonly family: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.NonEmptyAction<string, undefined>, v.CheckAction<string, "Source is a reserved font name of the base font">]>, "Furifont Sans">;
-  readonly rubyScript: v.OptionalSchema<v.PicklistSchema<readonly ["hiragana", "katakanaOn", "hepburn"], undefined>, "hiragana">;
+  readonly furiganaScript: v.OptionalSchema<v.PicklistSchema<readonly ["hiragana", "katakanaOn", "hepburn"], undefined>, "hiragana">;
   /** The sources whose words get ruby. */
   readonly sources: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["jmdict", "ichi", "news", "spec", "gai", "nf", "tatoeba", "place", "mahjong-yaku", "jr-stations", "yojijukugo", "japan-post"], undefined>, undefined>, () => ("jmdict" | "ichi" | "news" | "spec" | "gai" | "nf" | "tatoeba" | "place" | "mahjong-yaku" | "jr-stations" | "yojijukugo" | "japan-post")[]>;
   /** The most common words left bare, by score: a reader knows them. Lone kanji count too. */
@@ -357,6 +357,8 @@ export declare const SELECTOR_FIRST_READING = 917985;
 export declare const MAX_READINGS = 15;
 interface PlanReport {
   stats: {
+    /** Words the sources offer, the skipped and the left bare among them: the range of `skip` and `take`. */
+    candidates: number;
     patterns: number;
     places: number;
     ambiguous: number;
@@ -385,11 +387,43 @@ interface PlanResult {
   plan: Plan;
   report: PlanReport;
 }
+/** The words the sources hold, most common first, in three runs: the skipped (the most common, and those the reader knows), the taken, and the rest the font leaves bare. */
+interface WordBuckets {
+  skip: string[];
+  take: string[];
+  rest: string[];
+}
+interface FontPlanner {
+  (options: PlanOptions, coverage: ReadonlySet<number>, previewText?: string): PlanResult;
+  /** The words of the dictionary by what the font does with them, for the options. */
+  wordBuckets: (options: PlanOptions, coverage: ReadonlySet<number>) => WordBuckets;
+}
 /**
  * Indexes the compiled dictionary once, 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.
  */
-export declare function createFontPlanner(dictionary: Dictionary): (options: PlanOptions, coverage: ReadonlySet<number>, previewText?: string) => PlanResult;
+export declare function createFontPlanner(dictionary: Dictionary): FontPlanner;
+//#endregion
+//#region src/prune.d.ts
+/**
+ * Drops the runs the font reads right without them: a run of one reading that
+ * the longest-match rules split into other words, which together write the
+ * run's reading, as 公認会計士 is 公認 and 会計士. Such a run only adds rules.
+ *
+ * The runs are judged shortest first, each against the words kept, as the
+ * font would choose them, so that a dropped run never takes away a part
+ * another run needs. A run stays when any plan could read it differently:
+ * with another reading, a JLPT level or a curated default.
+ *
+ * The parts take over what made the run common: its score, so that any `take`
+ * or `skip` that reaches the run reaches them, and its tags. A plan that
+ * narrows `sources` to where the run comes from but not the parts (a place
+ * name of `place`, whose parts are JMdict's words) reads the parts alone.
+ */
+export declare function pruneRuns(dictionary: Dictionary): {
+  dictionary: Dictionary;
+  pruned: string[];
+};
 //#endregion
-export type { Dictionary, DictionaryEntry, DictionarySources, HanRun, ManualSource, Plan, PlanGlyph, PlanOptions, PlanOptionsInput, PlanReport, PlanResult, Reading, RubyMetrics, RubyScript, RubySpan, Source, WordSource };
+export type { Dictionary, DictionaryEntry, DictionarySources, FuriganaScript, HanRun, ManualSource, Plan, PlanGlyph, PlanOptions, PlanOptionsInput, PlanReport, PlanResult, Reading, RubyMetrics, RubySpan, Source, WordBuckets, WordSource };

package/dist/index.mjs

@@ -9,7 +9,7 @@ const DEFAULTS = {
 	/** What a plan does when a config leaves an option out. */
 	plan: {
 		family: "Furifont Sans",
-		rubyScript: "hiragana",
+		furiganaScript: "hiragana",
 		/** No word is left bare for being common; every word of every source gets ruby. */
 		skip: 0,
 		isolated: true,
@@ -36,25 +36,25 @@ const PREBUILT = {
 			family: "Furifont Sans",
 			base: "Source Han Sans JP",
 			face: "sans",
-			rubyScript: "hiragana"
+			furiganaScript: "hiragana"
 		},
 		{
 			family: "Furifont Sans Romaji",
 			base: "Source Han Sans JP",
 			face: "sans",
-			rubyScript: "hepburn"
+			furiganaScript: "hepburn"
 		},
 		{
 			family: "Furifont Serif",
 			base: "Source Han Serif JP",
 			face: "serif",
-			rubyScript: "hiragana"
+			furiganaScript: "hiragana"
 		},
 		{
 			family: "Furifont Serif Romaji",
 			base: "Source Han Serif JP",
 			face: "serif",
-			rubyScript: "hepburn"
+			furiganaScript: "hepburn"
 		}
 	],
 	/** The static weights of the release, each of the base's weights by name. Bold is the variable font's. */
@@ -180,7 +180,7 @@ function getOrCreate(map, key, create) {
 }
 //#endregion
 //#region src/schema.ts
-const RUBY_SCRIPTS = [
+const FURIGANA_SCRIPTS = [
 	"hiragana",
 	"katakanaOn",
 	"hepburn"
@@ -245,7 +245,7 @@ const RubyMetricsSchema = v.object({
 const Count = v.pipe(v.number(), v.integer(), v.minValue(0));
 const PlanOptionsSchema = 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),
+	furiganaScript: v.optional(v.picklist(FURIGANA_SCRIPTS), DEFAULTS.plan.furiganaScript),
 	/** The sources whose words get ruby. */
 	sources: v.optional(v.array(v.picklist(WORD_SOURCES)), () => [...WORD_SOURCES]),
 	/** The most common words left bare, by score: a reader knows them. Lone kanji count too. */
@@ -454,8 +454,17 @@ function sourcesOf(evidence) {
 	const level = evidence.jlpt && JLPT_LEVELS[5 - evidence.jlpt];
 	return evidence.sources | (level ? sourceBit(level) : 0) | ((evidence.uses ?? 0) >= MIN_USES ? sourceBit("tatoeba") : 0);
 }
-/** How common a run's reading is, by the most telling of its sources. */
-function runScore(evidence) {
+/** Kanji up to this many are scored as the sources say; each one more costs {@link LONG_PENALTY} points. */
+const LONG_RUN = 4;
+const LONG_PENALTY = 2;
+/** The lowest score still in the tier of `score`: a long run scores lower, but never as another kind of word. */
+const tierFloor = (score) => score > SCORE.tagged ? SCORE.tagged + 1 : score > SCORE.used ? SCORE.used + 1 : score > SCORE.listed ? SCORE.listed + 1 : score;
+/** How common a run's reading is, by the most telling of its sources, less for each kanji past {@link LONG_RUN}: a long word is rarer than its parts. */
+function runScore(evidence, size) {
+	const score = sourceScore(evidence);
+	return Math.max(tierFloor(score), score - Math.max(0, size - LONG_RUN) * LONG_PENALTY);
+}
+function sourceScore(evidence) {
 	const uses = evidence.uses ?? 0;
 	return Math.max(evidence.rank ? scoreOf(1 / evidence.rank) : 0, uses >= MIN_USES ? SCORE.used + Math.min(uses, SCORE.tagged - SCORE.used) : 0, evidence.sources & MANUAL_BITS ? 15 : 0, evidence.sources & sourceBit("place") ? 10 : 0, evidence.order === void 0 ? 0 : SCORE.listed);
 }
@@ -471,14 +480,14 @@ const tier = (score) => [
 * kana are one, under the alignment that splits them most: 倉本 くら・もと
 * rather than くらもと.
 */
-function rankReadings(readings) {
+function rankReadings(readings, size) {
 	const byKana = /* @__PURE__ */ new Map();
 	for (const [key, evidence] of readings) {
 		const spans = parseFurigana(key);
 		const reading = {
 			key,
 			spans,
-			score: runScore(evidence),
+			score: runScore(evidence, size),
 			sources: sourcesOf(evidence),
 			order: evidence.order ?? Infinity
 		};
@@ -563,7 +572,7 @@ function fuseDictionary(sources) {
 	for (const entry of sources.entries) for (const run of hanRuns(entry.form, parseFurigana(entry.furigana))) if ([...run.text].length > 1) addRun(runs, run, entry);
 	else addKanji(kanji, run, entry);
 	for (const [run, name] of listedRuns(sources)) evidenceOf(runs, run.text, formatFurigana(run.spans)).sources |= sourceBit(name);
-	const ranked = new Map([...runs].map(([text, readings]) => [text, new Map(rankReadings(readings))]));
+	const ranked = new Map([...runs].map(([text, readings]) => [text, new Map(rankReadings(readings, [...text].length))]));
 	const lone = kanjiReadings(kanji);
 	for (const run of sources.defaults.flatMap(notationRuns$1)) {
 		const [table, key] = [...run.text].length > 1 ? [ranked, formatFurigana(run.spans)] : [lone, run.spans[0].ruby];
@@ -918,6 +927,42 @@ function emitFea(input) {
 	return out.join("\n");
 }
 //#endregion
+//#region src/suffixes.ts
+/** 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;
+/**
+* The kanji that read one way ending the runs, given each run with the spans
+* of its JMdict readings: 的 てき, 化 か; not 人, にん or じん.
+*/
+function pickSuffixes(runs) {
+	const suffixes = {
+		readings: /* @__PURE__ */ new Map(),
+		final: /* @__PURE__ */ new Set()
+	};
+	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 runs) {
+		const chars = [...text];
+		count(starts, chars[0]);
+		count(ends, chars.at(-1));
+		for (const spans of readings) {
+			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) continue;
+		suffixes.readings.set(kanji, ruby);
+		if ((starts.get(kanji) ?? 0) > ends.get(kanji)) suffixes.final.add(kanji);
+	}
+	return suffixes;
+}
+//#endregion
 //#region src/planner.ts
 /** VS225: shows the kanji before it without ruby. */
 const SELECTOR_SUPPRESS = 917984;
@@ -927,9 +972,6 @@ const SELECTOR_FIRST_READING = 917985;
 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;
 const length = (text) => [...text].length;
 function spanKey(spans) {
 	return spans.map((s) => `${s.start}-${s.end}:${s.ruby}`).join(";");
@@ -939,17 +981,17 @@ function rank(a, b) {
 	return (b.pinned ?? 0) - (a.pinned ?? 0) || Number(a.place ?? false) - Number(b.place ?? false) || a.order - b.order;
 }
 const isJmdict = (reading) => !!(reading.sources & sourceBit("jmdict"));
-const PIN = sourceBit("default");
+const PIN$1 = sourceBit("default");
 function indexRuns(index, runs) {
 	for (const [text, readings] of Object.entries(runs)) {
 		const ranked = [];
 		for (const [furigana, [score, sources]] of Object.entries(readings)) {
 			const spans = parseFurigana(furigana);
-			if (sources & PIN) index.defaults.push({
+			if (sources & PIN$1) index.defaults.push({
 				text,
 				spans
 			});
-			if (sources & ~PIN) ranked.push({
+			if (sources & ~PIN$1) ranked.push({
 				spans,
 				weight: weightOf(score),
 				score,
@@ -969,7 +1011,7 @@ function indexKanji(index, kanji) {
 			sources
 		});
 		if (sources & sourceBit("inflecting")) getOrCreate(index.inflecting, text, () => /* @__PURE__ */ new Set()).add(ruby);
-		if (sources & PIN) index.defaults.push({
+		if (sources & PIN$1) index.defaults.push({
 			text,
 			spans: [{
 				start: 0,
@@ -996,9 +1038,9 @@ 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(""));
+		if (options.furiganaScript === "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);
+		if (options.furiganaScript === "katakanaOn" && kanji.length === 1 && isOnyomi(span.ruby, dictionary.onyomi[kanji[0]] ?? [])) return toKatakana(span.ruby);
 		return span.ruby;
 	};
 	const known = options.skipJlpt ? JLPT_LEVELS.slice(0, JLPT_LEVELS.indexOf(options.skipJlpt) + 1).reduce((mask, level) => mask | sourceBit(level), 0) : 0;
@@ -1058,10 +1100,15 @@ function selectWords(index, ctx) {
 	const skipped = /* @__PURE__ */ new Set();
 	const skippedKanji = /* @__PURE__ */ new Set();
 	const words = [];
+	const known = [];
 	for (const [text, readings] of index.runs) {
 		if (ctx.removed.has(text)) continue;
 		if (readings.some((r) => ctx.known(r.sources))) {
 			skipped.add(text);
+			known.push({
+				text,
+				score: Math.max(...readings.map((r) => r.score))
+			});
 			continue;
 		}
 		const chosen = wordReadings(text, readings, wanted, ctx);
@@ -1079,7 +1126,16 @@ function selectWords(index, ctx) {
 		word: false
 	}))].sort((a, b) => b.score - a.score);
 	for (const { text, word } of byScore.slice(0, ctx.options.skip)) (word ? skipped : skippedKanji).add(text);
-	const taken = new Set(byScore.slice(ctx.options.skip).filter((item) => item.word).slice(0, ctx.options.take).map((item) => item.text));
+	const buckets = {
+		skip: [...known, ...byScore.slice(0, ctx.options.skip).filter((item) => item.word)].sort((a, b) => b.score - a.score).map((item) => item.text),
+		take: [],
+		rest: []
+	};
+	const after = byScore.slice(ctx.options.skip).filter((item) => item.word).map((item) => item.text);
+	const take = ctx.options.take ?? after.length;
+	buckets.take = after.slice(0, take);
+	buckets.rest = after.slice(take);
+	const taken = new Set(buckets.take);
 	const patterns = new Map(words.filter(([text]) => taken.has(text)));
 	const lonePins = /* @__PURE__ */ new Map();
 	addCustomRuns(patterns, lonePins, ctx.options.words.add.flatMap(notationRuns), 0, ctx);
@@ -1090,7 +1146,8 @@ function selectWords(index, ctx) {
 		patterns,
 		lonePins,
 		skipped,
-		skippedKanji
+		skippedKanji,
+		buckets
 	};
 }
 /** Readings of a lone kanji the font can draw, heaviest first, with their share of the evidence. */
@@ -1171,39 +1228,24 @@ function chooseLoneKanji(index, { patterns, lonePins, skippedKanji }, ctx) {
 * clearly dominates there: 的 てき, 化 か; not 人, にん or じん.
 */
 function chooseSuffixes(index, ctx) {
-	const suffixes = {
+	if (!ctx.options.isolated) return {
 		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.jmdict) {
-		const chars = [...text];
-		count(starts, chars[0]);
-		count(ends, chars.at(-1));
-		for (const { spans } of readings) {
-			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;
+	const { readings, final } = pickSuffixes([...index.jmdict].map(([text, rs]) => [text, rs.map((r) => r.spans)]));
+	const usable = ([kanji, ruby]) => !ctx.removed.has(kanji) && ctx.renderable({
+		text: kanji,
+		spans: [{
+			start: 0,
+			end: 1,
+			ruby
+		}]
+	});
+	const kept = new Map([...readings].filter(usable));
+	return {
+		readings: kept,
+		final: new Set([...final].filter((kanji) => kept.has(kanji)))
+	};
 }
 /** Per character, the span reading it; keys are relative so they compare at any offset. */
 function assignment(spans, size) {
@@ -1212,7 +1254,7 @@ function assignment(spans, size) {
 	return out;
 }
 /** The suffix reading of the kanji at `p` of a run when no word claimed it. */
-function suffixAt(chars, p, suffixes) {
+function suffixAt$1(chars, p, suffixes) {
 	const kanji = chars[p];
 	return p > 0 && (p === chars.length - 1 || !suffixes.final.has(kanji)) ? suffixes.readings.get(kanji) : void 0;
 }
@@ -1227,7 +1269,7 @@ function misreads(chars, expected, known, longest, suffixes) {
 				break;
 			}
 		}
-		const suffix = size < 2 ? suffixAt(chars, p, suffixes) : void 0;
+		const suffix = size < 2 ? suffixAt$1(chars, p, suffixes) : void 0;
 		if (suffix !== void 0 && expected[p] !== `0:1:${suffix}`) return true;
 		p += Math.max(size, 1);
 	}
@@ -1443,6 +1485,7 @@ function createFontPlanner(dictionary) {
 		}));
 		return {
 			patterns,
+			buckets: selection.buckets,
 			isolated,
 			kanjiReadings,
 			protectedRuns,
@@ -1470,8 +1513,8 @@ function createFontPlanner(dictionary) {
 		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);
+	function planFont(options, coverage, previewText) {
+		const { patterns, buckets, 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));
@@ -1546,6 +1589,7 @@ function createFontPlanner(dictionary) {
 			},
 			report: {
 				stats: {
+					candidates: buckets.skip.length + buckets.take.length + buckets.rest.length,
 					patterns: patterns.size,
 					places: [...patterns.values()].filter((r) => r[0].place).length,
 					ambiguous: Object.keys(ivsWords).length,
@@ -1564,7 +1608,171 @@ function createFontPlanner(dictionary) {
 				}
 			}
 		};
+	}
+	/** The words of the dictionary by what the font does with them, for the options. */
+	function wordBuckets(options, coverage) {
+		return analysisFor(options, coverage).buckets;
+	}
+	return Object.assign(planFont, { wordBuckets });
+}
+//#endregion
+//#region src/prune.ts
+const maskOf = (sources) => sources.reduce((mask, source) => mask | sourceBit(source), 0);
+const PIN = sourceBit("default");
+const JMDICT = sourceBit("jmdict");
+/** What marks a word as common, which the parts of a dropped run take over. */
+const TAG_MASK = maskOf([
+	"ichi",
+	"news",
+	"spec",
+	"gai",
+	"nf",
+	"tatoeba"
+]);
+/** What a plan reads a word by besides its sources, so that a word with any of these stays: the JLPT levels a reader skips, the curated default. */
+const KEEP_MASK = maskOf([...JLPT_LEVELS, "default"]);
+/** `parseFurigana` of the readings each pass looks at again. */
+const spansCache = /* @__PURE__ */ new Map();
+function spansOf(key) {
+	let spans = spansCache.get(key);
+	if (!spans) spansCache.set(key, spans = parseFurigana(key));
+	return spans;
+}
+function knownOf(dictionary, text) {
+	const entries = Object.entries(dictionary.runs[text]);
+	const [key, [score, sources]] = entries.find(([, [, sources]]) => sources & PIN) ?? entries[0];
+	return {
+		known: {
+			key,
+			kana: spansOf(key).map((s) => s.ruby).join(""),
+			score,
+			sources
+		},
+		droppable: entries.length === 1 && !(sources & KEEP_MASK) && !dictionary.bare.includes(text)
+	};
+}
+/** The suffix reading of the kanji at `p` of a run when no word claimed it, as the font applies 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;
+}
+/** The words of `known`, and the suffixes, that the longest-match rules choose over `text`, when together they write `run`'s reading. */
+function partsOf(text, run, known, suffixes) {
+	const chars = [...text];
+	const parts = {
+		words: [],
+		suffixes: []
+	};
+	let kana = "";
+	for (let p = 0; p < chars.length;) {
+		let size = p === 0 ? chars.length - 1 : chars.length - p;
+		for (; size >= 2; size--) {
+			const word = chars.slice(p, p + size).join("");
+			const part = known.get(word);
+			if (part) {
+				parts.words.push({
+					text: word,
+					part
+				});
+				kana += part.kana;
+				break;
+			}
+		}
+		if (size < 2) {
+			const suffix = suffixAt(chars, p, suffixes);
+			if (suffix === void 0) return void 0;
+			parts.suffixes.push(chars[p]);
+			kana += suffix;
+			size = 1;
+		}
+		p += size;
+	}
+	return kana === run.kana ? parts : void 0;
+}
+function prunePass(dictionary, suffixes) {
+	const byLength = /* @__PURE__ */ new Map();
+	for (const text of Object.keys(dictionary.runs)) {
+		const length = [...text].length;
+		getOrCreate(byLength, length, () => []).push(text);
+	}
+	const known = /* @__PURE__ */ new Map();
+	/** The runs dropped, with the suffixes each one counts on. */
+	const pruned = /* @__PURE__ */ new Map();
+	/** What each part gains: the best score of the runs it stands in for, and their tags. */
+	const gains = /* @__PURE__ */ new Map();
+	for (const length of [...byLength.keys()].sort((a, b) => a - b)) {
+		const kept = [];
+		for (const text of byLength.get(length)) {
+			const { known: run, droppable } = knownOf(dictionary, text);
+			const parts = droppable ? partsOf(text, run, known, suffixes) : void 0;
+			if (!parts) {
+				kept.push([text, run]);
+				continue;
+			}
+			pruned.set(text, parts.suffixes);
+			for (const { text: partText } of parts.words) {
+				const [score, tags] = gains.get(partText) ?? [0, 0];
+				gains.set(partText, [Math.max(score, run.score), tags | run.sources & TAG_MASK]);
+			}
+		}
+		for (const [text, run] of kept) known.set(text, run);
+	}
+	const runs = Object.fromEntries(Object.entries(dictionary.runs).filter(([text]) => !pruned.has(text)).map(([text, readings]) => {
+		const gain = gains.get(text);
+		const key = known.get(text)?.key;
+		return [text, gain ? Object.fromEntries(Object.entries(readings).map(([k, [score, sources]]) => k === key ? [k, [Math.max(score, gain[0]), sources | gain[1]]] : [k, [score, sources]])) : readings];
+	}));
+	return {
+		dictionary: {
+			...dictionary,
+			runs
+		},
+		pruned
+	};
+}
+/** The suffixes of the dictionary's JMdict words, as the planner picks them. */
+function suffixesOf(dictionary) {
+	return pickSuffixes(Object.entries(dictionary.runs).flatMap(([text, readings]) => {
+		const jmdict = Object.entries(readings).filter(([, [, sources]]) => sources & JMDICT).map(([key]) => spansOf(key));
+		return jmdict.length ? [[text, jmdict]] : [];
+	}));
+}
+/**
+* Drops the runs the font reads right without them: a run of one reading that
+* the longest-match rules split into other words, which together write the
+* run's reading, as 公認会計士 is 公認 and 会計士. Such a run only adds rules.
+*
+* The runs are judged shortest first, each against the words kept, as the
+* font would choose them, so that a dropped run never takes away a part
+* another run needs. A run stays when any plan could read it differently:
+* with another reading, a JLPT level or a curated default.
+*
+* The parts take over what made the run common: its score, so that any `take`
+* or `skip` that reaches the run reaches them, and its tags. A plan that
+* narrows `sources` to where the run comes from but not the parts (a place
+* name of `place`, whose parts are JMdict's words) reads the parts alone.
+*/
+function pruneRuns(dictionary) {
+	const banned = /* @__PURE__ */ new Set();
+	const usable = (suffixes) => ({
+		readings: new Map([...suffixes.readings].filter(([k]) => !banned.has(k))),
+		final: suffixes.final
+	});
+	let suffixes = usable(suffixesOf(dictionary));
+	let result = prunePass(dictionary, suffixes);
+	for (let pass = 0; pass < 20; pass++) {
+		const next = suffixesOf(result.dictionary);
+		const holds = (kanji) => next.readings.get(kanji) === suffixes.readings.get(kanji) && next.final.has(kanji) === suffixes.final.has(kanji);
+		const stale = new Set([...result.pruned.values()].flat().filter((kanji) => !holds(kanji)));
+		if (!stale.size) break;
+		for (const kanji of stale) banned.add(kanji);
+		suffixes = usable(next);
+		result = prunePass(dictionary, suffixes);
+	}
+	return {
+		dictionary: result.dictionary,
+		pruned: [...result.pruned.keys()]
 	};
 }
 //#endregion
-export { DEFAULTS, DictionarySchema, JLPT_LEVELS, MANUAL_SOURCES, MAX_READINGS, PREBUILT, PlanOptionsSchema, PlanSchema, RUBY_SCRIPTS, SCORE, SELECTOR_FIRST_READING, SELECTOR_SUPPRESS, SOURCES, VERSION_PROBE, WORD_SOURCES, createFontPlanner, formatDictionary, formatFurigana, formatNotation, fuseDictionary, glyphName, hanRuns, isHan, isOnyomi, parseFurigana, parseNotation, resolveOptions, scoreOf, sourceBit, sourcesIn, toHepburn, toHiragana, toKatakana, weightOf };
+export { DEFAULTS, DictionarySchema, FURIGANA_SCRIPTS, JLPT_LEVELS, MANUAL_SOURCES, MAX_READINGS, PREBUILT, PlanOptionsSchema, PlanSchema, SCORE, SELECTOR_FIRST_READING, SELECTOR_SUPPRESS, SOURCES, VERSION_PROBE, WORD_SOURCES, createFontPlanner, formatDictionary, formatFurigana, formatNotation, fuseDictionary, glyphName, hanRuns, isHan, isOnyomi, parseFurigana, parseNotation, pruneRuns, resolveOptions, scoreOf, sourceBit, sourcesIn, toHepburn, toHiragana, toKatakana, weightOf };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@furifont/core",
   "type": "module",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Plan furigana glyphs and OpenType rules from a Japanese dictionary",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",