@furifont/core 0.1.2 → 0.2.0

package/dist/index.d.mts

@@ -15,6 +15,8 @@ export declare const DEFAULTS: {
     readonly nfMax: 48;
     /** JMdict priority tags that select a word whatever its bucket: the first tier of each list, which JMdict marks as common. */
     readonly selectTags: readonly ["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. */
+    readonly minTatoeba: 3;
     readonly places: true;
     readonly isolated: true;
     readonly isolatedMinShare: 0.8;
@@ -23,7 +25,7 @@ export declare const DEFAULTS: {
       readonly rubyScale: 0.5;
       readonly rubyGap: 0.05;
       readonly compressionFloor: 0.8;
-      readonly maxRubyWidth: 1.6;
+      readonly maxRubyWidth: 1.5;
     };
   };
   /** What the CLI adds to a plan: where the glyphs are drawn, and what is written. */
@@ -99,6 +101,8 @@ interface DictionaryEntry {
   conjugatesReading?: boolean;
   /** The JLPT level whose word list has this pair: 5 for N5 down to 1 for N1. */
   jlpt?: number;
+  /** How many times Tatoeba's example sentences use the pair, spelled this way. */
+  tatoeba?: number;
 }
 interface Dictionary {
   entries: DictionaryEntry[];
@@ -161,7 +165,7 @@ declare const RubyMetricsSchema: v.ObjectSchema<{
   /** Ruby is squeezed horizontally down to this scale before it may overhang. */
   readonly compressionFloor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0.3, undefined>, v.MaxValueAction<number, 1, undefined>]>, 0.8>;
   /** Widest a ruby may get, overhanging its base symmetrically. */
-  readonly maxRubyWidth: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 3, undefined>]>, 1.6>;
+  readonly maxRubyWidth: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 3, undefined>]>, 1.5>;
 }, undefined>;
 type RubyMetrics = v.InferOutput<typeof RubyMetricsSchema>;
 /** `schema`, checking that its frequency window `nfMin..nfMax` holds a bucket; for schemas that extend the options too. */
@@ -184,11 +188,19 @@ export declare const PlanOptionsSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
    * `spec1` catches words like 日本 that the newspaper ranking misses.
    */
   readonly selectTags: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["ichi1", "ichi2", "news1", "news2", "spec1", "spec2", "gai1", "gai2"], undefined>, undefined>, () => ("ichi1" | "news1" | "spec1" | "gai1")[]>;
+  /**
+   * 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.
+   */
+  readonly minTatoeba: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, 3>;
   /** Words on the JLPT lists of this level and every easier one stay bare. */
   readonly skipJlpt: v.OptionalSchema<v.PicklistSchema<readonly ["N5", "N4", "N3", "N2", "N1"], undefined>, undefined>;
   /** Annotate place names from the dictionary where no common word claims the run. */
   readonly places: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
-  /** Annotate a kanji alone in its run; when off, only selectors give it ruby. */
+  /** Annotate a kanji alone in its run, or one no word claims after another kanji (a suffix); when off, only selectors give them ruby. */
   readonly isolated: v.OptionalSchema<v.BooleanSchema<undefined>, true>;
   /** A kanji alone in its run is annotated only when one reading has this share of the evidence. */
   readonly isolatedMinShare: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0.5, undefined>, v.MaxValueAction<number, 1, undefined>]>, 0.8>;
@@ -208,7 +220,7 @@ export declare const PlanOptionsSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
     /** Ruby is squeezed horizontally down to this scale before it may overhang. */
     readonly compressionFloor: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0.3, undefined>, v.MaxValueAction<number, 1, undefined>]>, 0.8>;
     /** Widest a ruby may get, overhanging its base symmetrically. */
-    readonly maxRubyWidth: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 3, undefined>]>, 1.6>;
+    readonly maxRubyWidth: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 3, undefined>]>, 1.5>;
   }, undefined>, {}>;
 }, undefined>, v.CheckAction<{
   family: string;
@@ -216,6 +228,7 @@ export declare const PlanOptionsSchema: v.SchemaWithPipe<readonly [v.ObjectSchem
   nfMin: number;
   nfMax: number;
   selectTags: ("ichi1" | "news1" | "spec1" | "gai1" | "ichi2" | "news2" | "spec2" | "gai2")[];
+  minTatoeba: number;
   skipJlpt?: "N5" | "N4" | "N3" | "N2" | "N1" | undefined;
   places: boolean;
   isolated: boolean;
@@ -318,6 +331,7 @@ interface PlanReport {
     places: number;
     ambiguous: number;
     isolated: number;
+    suffixes: number;
     protectedAnnotated: number;
     protectedBare: number;
     glyphs: number;

package/dist/index.mjs

@@ -20,6 +20,8 @@ const DEFAULTS = {
 			"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,
@@ -28,7 +30,7 @@ const DEFAULTS = {
 			rubyScale: .5,
 			rubyGap: .05,
 			compressionFloor: .8,
-			maxRubyWidth: 1.6
+			maxRubyWidth: 1.5
 		}
 	},
 	/** What the CLI adds to a plan: where the glyphs are drawn, and what is written. */
@@ -439,21 +441,30 @@ 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(" ")};`;
 }
-/** The chain rules, longest first, then the lone-kanji class rules. */
+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)]);
-	if (!input.isolated.length) return words;
-	const kanji = `[${input.isolated.map((i) => i.input).join(" ")}]`;
+	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 ? ["subtable;"] : [],
-		`ignore sub @han ${kanji}';`,
-		`ignore sub ${kanji}' @han;`,
-		`sub ${kanji}' lookup isolated;`
+		...words.length && classes.length ? ["subtable;"] : [],
+		...classes
 	];
 }
 /**
@@ -468,7 +479,7 @@ function emitFea(input) {
 	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};`)));
-	if (input.isolated.length) out.push(block("lookup", "isolated", input.isolated.map((i) => `sub ${i.input} by ${i.output};`)));
+	out.push(...singleLookup("isolated", input.isolated), ...singleLookup("suffixes", input.suffixes));
 	const salt = {
 		lookup: [],
 		feature: []
@@ -485,8 +496,7 @@ function emitFea(input) {
 	out.push(...salt.lookup);
 	const main = mainRules(input);
 	if (main.length) out.push(block("lookup", "furigana", main));
-	if (input.variantReadings.length) out.push(block("lookup", "variant_readings", input.variantReadings.map((v) => `sub ${v.input} by ${v.output};`)));
-	if (input.variantsOff.length) out.push(block("lookup", "variants_off", input.variantsOff.map((v) => `sub ${v.input} by ${v.output};`)));
+	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 = [];
@@ -515,6 +525,11 @@ 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;
+/** 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;
@@ -554,7 +569,8 @@ function indexRun(index, run, entry) {
 		order,
 		nf: entry.priority ? entry.nf : 0,
 		jlpt: entry.jlpt ?? 0,
-		tags: priorityTags(entry)
+		tags: priorityTags(entry),
+		tatoeba: entry.tatoeba ?? 0
 	};
 	const readings = getOrCreate(index.runs, run.text, () => /* @__PURE__ */ new Map());
 	const current = readings.get(spanKey(run.spans));
@@ -565,6 +581,7 @@ function indexRun(index, run, entry) {
 	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;
@@ -587,9 +604,18 @@ function indexSingle(index, run, entry) {
 }
 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);
-	else 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);
+	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));
@@ -605,7 +631,7 @@ function createContext(dictionary, options, coverage) {
 		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)),
+		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)))
@@ -703,6 +729,24 @@ function loneReadings(kanji, readings, ctx) {
 		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];
@@ -740,8 +784,9 @@ function chooseLoneKanji(index, patterns, lonePins, ctx) {
 		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 (top && top.share >= ctx.options.isolatedMinShare && ctx.options.isolated && !isolated.has(kanji)) isolated.set(kanji, top.ruby);
+		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);
@@ -757,14 +802,59 @@ function chooseLoneKanji(index, patterns, lonePins, ctx) {
 		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;
 }
-/** Runs the longest-match rules over `chars` and reports whether any kanji gets a reading other than `expected`. */
-function misreads(chars, expected, known, longest) {
+/** 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--) {
@@ -774,6 +864,8 @@ function misreads(chars, expected, known, longest) {
 				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;
@@ -784,7 +876,7 @@ function misreads(chars, expected, known, longest) {
 * takes readings the font already has, left bare otherwise. Skipped words are
 * always left bare.
 */
-function findMisreadRuns(index, patterns, kanjiReadings, skipped, ctx) {
+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)) {
@@ -795,7 +887,7 @@ function findMisreadRuns(index, patterns, kanjiReadings, skipped, ctx) {
 		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))) return false;
+		if (!expected.some((e) => misreads(chars, e, known, longest, suffixes))) return false;
 		const truth = [...readings.values()].sort(rank)[0];
 		const run = {
 			text,
@@ -973,7 +1065,8 @@ function createFontPlanner(dictionary) {
 	const index = {
 		runs: /* @__PURE__ */ new Map(),
 		singles: /* @__PURE__ */ new Map(),
-		inflecting: /* @__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(", ");
@@ -982,9 +1075,14 @@ function createFontPlanner(dictionary) {
 		const ctx = createContext(dictionary, options, coverage);
 		const { patterns, lonePins, skipped } = selectWords(index, dictionary, ctx);
 		const { isolated, kanjiReadings } = chooseLoneKanji(index, patterns, lonePins, ctx);
-		const protectedRuns = findMisreadRuns(index, patterns, kanjiReadings, skipped, 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,
@@ -998,10 +1096,9 @@ function createFontPlanner(dictionary) {
 			variantReadings,
 			alternates,
 			ivsWords,
-			lone: [...isolated].map(([kanji, ruby]) => ({
-				base: glyphName(kanji.codePointAt(0)),
-				glyph: glyphs.lone(kanji, ruby)
-			}))
+			lone: loneGlyphs(isolated),
+			suffixes: loneGlyphs(suffixes.readings),
+			finalSuffixes: new Set([...suffixes.final].map((k) => glyphName(k.codePointAt(0))))
 		};
 	}
 	let last;
@@ -1016,11 +1113,12 @@ function createFontPlanner(dictionary) {
 	}
 	/** 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 } = analysisFor(options, coverage);
+		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;
@@ -1031,6 +1129,7 @@ function createFontPlanner(dictionary) {
 			...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));
@@ -1047,6 +1146,11 @@ function createFontPlanner(dictionary) {
 				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,
@@ -1072,7 +1176,7 @@ function createFontPlanner(dictionary) {
 				version: 1,
 				names: {
 					family: options.family,
-					description: `Furigana rules compiled from ${sources} (CC BY-SA 4.0: EDRDG, JmdictFurigana, stephenmk after Jonathan Waller).`
+					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),
@@ -1088,6 +1192,7 @@ function createFontPlanner(dictionary) {
 					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,
@@ -1159,11 +1264,19 @@ const PlanOptionsSchema = withNfWindow(v.object({
 	* `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; when off, only selectors give it ruby. */
+	/** 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),

package/package.json

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