chaffjs 0.27.0 → 0.28.0

package/src/detectors/change-rate.ts

@@ -1,9 +1,10 @@
 // change-rate-mismatch: the reading half. Builds the figures, the rates and the words of structure/change-rate.ts from the
-// tree's quantities, the numbers counted with a word ("1,200 companies"), and the lexicons change-direction, change-base,
-// percent-unit and amount-multiplier.
-import type { Detector, Finding, ProseDocument, Span, StructureNode } from "../plugin.ts";
+// tree's quantities, the numbers counted with a word ("1,200 companies"), the calendar years, and the lexicons change-direction,
+// change-base, change-target, change-break, percent-unit and amount-multiplier.
+import type { Detector, Finding, LexiconEntry, ProseDocument, Span, StructureNode, Token } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
-import { changeRateMismatches, type BaseMark, type Direction, type Figure, type Rate } from "../structure/change-rate.ts";
+import { startsOtherSubject } from "../structure/subject-change.ts";
+import { changeRateMismatches, type BaseMark, type Break, type Direction, type Figure, type Period, type Rate } from "../structure/change-rate.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAt } from "./structure-tree.ts";
 
@@ -82,13 +83,52 @@ const spansOf = (source: string, word: string): Span[] => {
 
 const SIGNS: Readonly<Record<string, 1 | -1>> = { rise: 1, fall: -1 };
 
-/** Phrases that hold a direction word but give no direction ("up to 25%" is a ceiling): lexicon change-direction-not. */
-const directionsOf = (doc: ProseDocument): Direction[] => {
-  const not = patternsOf(doc, "change-direction-not").flatMap((phrase) => spansOf(doc.source, phrase));
-  return (doc.lexicons["change-direction"] ?? []).flatMap((entry) => {
+/** Where the words of a lexicon stand, less those inside a phrase of its "-not" lexicon ("up to 25%" is a ceiling). */
+const spansWithout = (doc: ProseDocument, entries: readonly LexiconEntry[], notLexicon: string): (Span & { readonly entry: LexiconEntry })[] => {
+  const not = patternsOf(doc, notLexicon).flatMap((phrase) => spansOf(doc.source, phrase));
+  return entries.flatMap((entry) =>
+    spansOf(doc.source, entry.pattern)
+      .filter((span) => !not.some((phrase) => phrase.start <= span.start && span.end <= phrase.end))
+      .map((span) => ({ ...span, entry })),
+  );
+};
+
+/** Lexicon change-direction, less the phrases of change-direction-not. */
+const directionsOf = (doc: ProseDocument): Direction[] =>
+  spansWithout(doc, doc.lexicons["change-direction"] ?? [], "change-direction-not").flatMap(({ start, end, entry }) => {
     const sign = SIGNS[entry.group ?? ""];
-    const spans = spansOf(doc.source, entry.pattern).filter((span) => !not.some((phrase) => phrase.start <= span.start && span.end <= phrase.end));
-    return sign === undefined ? [] : spans.map((span) => ({ ...span, sign }));
+    return sign === undefined ? [] : [{ start, end, sign }];
+  });
+
+/** The sentence's tokens, and the index of the token that starts at offset (-1 when none does). */
+const tokenAt = (doc: ProseDocument, offset: number): { readonly tokens: readonly Token[]; readonly index: number } => {
+  const tokens = doc.sentences.find((sentence) => sentence.span.start <= offset && offset < sentence.span.end)?.tokens ?? [];
+  return { tokens, index: tokens.findIndex((token) => token.span.start === offset) };
+};
+
+/** A word that may join two values ("and") does not when another subject follows it ("and costs were"). */
+const joinsTwoValues = (doc: ProseDocument, start: number): boolean => {
+  const { tokens, index } = tokenAt(doc, start);
+  return index < 0 || !startsOtherSubject(tokens, index);
+};
+
+/** Lexicon change-break (「は」, "and"), less the phrases of change-break-not (「上がり」 holds が but starts no subject). */
+const breaksOf = (doc: ProseDocument): Break[] =>
+  spansWithout(doc, doc.lexicons["change-break"] ?? [], "change-break-not").map(({ start, end, entry }) => ({
+    start,
+    end,
+    beforeRateOnly: entry.group === "rate" && joinsTwoValues(doc, start),
+  }));
+
+/** A calendar year written alone or with a unit of calendar year (2025, 2025年, 2025年度), and not part of an amount ($2025). */
+const CALENDAR_YEAR = /(?<!\d|\d[.,])(?:1[89]|2[01])\d{2}(?!\d|[.,]\d)/gu;
+
+const periodsOf = (doc: ProseDocument, figures: readonly Figure[]): Period[] => {
+  const yearUnits = new Set(patternsOf(doc, "calendar-year-unit").map((unit) => `${unit}|`));
+  const amounts = figures.filter((figure) => !yearUnits.has(figure.unit));
+  return [...doc.source.matchAll(CALENDAR_YEAR)].flatMap((match) => {
+    const span = { start: match.index, end: match.index + match[0].length };
+    return amounts.some((figure) => figure.start < span.end && span.start < figure.end) ? [] : [{ ...span, year: Number(match[0]) }];
   });
 };
 
@@ -103,13 +143,17 @@ export const changeRate: Detector = (doc): Finding[] => {
   const units = patternsOf(doc, "percent-unit");
   const multipliers = patternsOf(doc, "amount-multiplier").map((word) => word.toLowerCase());
   const taken = nodes.map((node) => node.span);
+  const figures = [...treeFigures(doc, nodes, units, multipliers), ...countedFigures(doc, taken, multipliers)];
   const text = {
     sentences: doc.sentences.map((sentence) => sentence.span),
-    figures: [...treeFigures(doc, nodes, units, multipliers), ...countedFigures(doc, taken, multipliers)],
+    figures,
     rates: ratesOf(doc, nodes, units),
     directions: directionsOf(doc),
     marks: marksOf(doc, "change-base"),
     targets: marksOf(doc, "change-target"),
+    periods: periodsOf(doc, figures),
+    breaks: breaksOf(doc),
+    source: doc.source,
   };
   return changeRateMismatches(text).map((issue) => ({
     rule: "change-rate-mismatch",

package/src/detectors/currency-notation.ts

@@ -14,7 +14,7 @@ export type WrittenAmount = { readonly offset: number; readonly written: string;
 /** 少ないほうの書き方の金額と、多いほうの書き方の例、その通貨の金額の数。 */
 export type CurrencyMinority = { readonly odd: WrittenAmount; readonly usual: string; readonly count: number; readonly of: number };
 
-const AMOUNT = "[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?";
+export const AMOUNT = "[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?";
 
 const alternation = (words: readonly string[]): string => words.map(escapeRegExp).join("|");
 
@@ -71,7 +71,7 @@ export const currencyMinorities = (amounts: readonly WrittenAmount[], limit: num
     )
     .toSorted((left, right) => left.odd.offset - right.odd.offset);
 
-const formsOf = (doc: ProseDocument): CurrencyForm[] =>
+export const formsOf = (doc: ProseDocument): CurrencyForm[] =>
   (doc.lexicons["currency-notation"] ?? []).flatMap((entry) =>
     entry.position === undefined || entry.group === undefined ? [] : [{ pattern: entry.pattern, position: entry.position, currency: entry.group }],
   );

package/src/detectors/derived-numbers.ts

@@ -5,6 +5,7 @@ import { overlapsAny, spanIndex } from "../compare/spans.ts";
 import { yearOf, type DurationUnit } from "../derived/date-arithmetic.ts";
 import { durationMismatches, type DatedValue, type Duration } from "../derived/durations.ts";
 import { elapsedMismatches, type Elapsed, type OriginWord, type Year } from "../derived/elapsed.ts";
+import { numberWordCounts } from "../derived/number-word-counts.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 /** 期間の単位の語彙表。木の数量の単位がどれかに入れば、その単位の期間。 */
@@ -122,8 +123,14 @@ const isAge = (doc: ProseDocument, quantity: Quantity): boolean =>
   positioned(doc, "age-marker", "before").some((word) => textBefore(doc, quantity).endsWith(word)) ||
   positioned(doc, "age-marker", "after").some((word) => textAfter(doc, quantity).startsWith(word));
 
-const elapsedOf = (doc: ProseDocument, quantities: readonly Quantity[]): Elapsed[] =>
-  quantities.filter((quantity) => !isAge(doc, quantity) && patternsOf(doc, "elapsed-unit").some((unit) => unit.normalize("NFKC") === quantity.unit));
+/** 年数: 単位が年数の語の数量（10 years、創業10年）と、木が読まない語で書いた数（ten years）。 */
+const elapsedOf = (doc: ProseDocument, quantities: readonly Quantity[]): Elapsed[] => {
+  const units = patternsOf(doc, "elapsed-unit");
+  const counted = quantities.filter((quantity) => !isAge(doc, quantity) && units.some((unit) => unit.normalize("NFKC") === quantity.unit));
+  const taken = spanIndex(quantities);
+  const worded = numberWordCounts(doc.source, patternsOf(doc, "count-number"), units).filter((count) => !overlapsAny(taken, count));
+  return [...counted, ...worded].toSorted((left, right) => left.start - right.start);
+};
 
 /** 「aged 45」の 45: 英語の木は単位の無い数を読まないので、年齢の印のすぐ後ろの数を読む。 */
 const AGE_NUMBER = /^\s*(\d{1,3})(?!\d)/u;

package/src/detectors/fact-consistency.ts

@@ -1,4 +1,5 @@
 import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import { countedFacts, countedPhraseAt, type CountedPhrase } from "../facts/counted-facts.ts";
 import { nameSpans } from "../compare/proper-nouns.ts";
 import { factValues, type FactValue } from "../facts/fact-values.ts";
 import { labelledFacts, type AttributePhrase, type FactWords } from "../facts/labelled-facts.ts";
@@ -50,5 +51,20 @@ const findingOf =
 /** 同じ節で、同じ名前に二通りの値（締切：10月5日 と 締切：10月7日）。 */
 export const factConflict: Detector = (doc): Finding[] => scopeConflicts(factsOf(doc)).map(findingOf("fact-conflict", doc));
 
+const countedPhrasesOf = (doc: ProseDocument): CountedPhrase[] =>
+  doc.sentences.flatMap((sentence) => {
+    const tokens = sentence.tokens ?? [];
+    return tokens.flatMap((token, index) => (token.pos === "NUM" ? countedPhraseAt(tokens, index) : []));
+  });
+
+/** The values named by what they count, scoped like the labelled ones. Only the summary is compared with them. */
+const countedFactsOf = (doc: ProseDocument): ScopedFact[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const values = factValues(tree, doc.source, nameSpans(doc));
+  return scopedFacts(countedFacts(doc.source, values, countedPhrasesOf(doc)), tree, doc.source, patternsOf(doc, "summary-heading"));
+};
+
 /** 冒頭や要約の値が、本文の同じ名前の値と違う。 */
-export const summaryFactMismatch: Detector = (doc): Finding[] => summaryConflicts(factsOf(doc)).map(findingOf("summary-fact-mismatch", doc));
+export const summaryFactMismatch: Detector = (doc): Finding[] =>
+  summaryConflicts([...factsOf(doc), ...countedFactsOf(doc)]).map(findingOf("summary-fact-mismatch", doc));

package/src/detectors/name-variant.ts

@@ -1,10 +1,19 @@
-import type { Detector, Finding } from "../plugin.ts";
-import { mentionsIn, nameVariants } from "../name-variants.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { mentionsIn, nameVariants, suffixedNamesIn, type VariantChars } from "../name-variants.ts";
 import { quoteAt } from "./structure-tree.ts";
 
+// 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、字体の違う同じ字（斎・斉・齋）は name-variant-char が組（group）ごとに言う。
+
+const variantCharsOf = (doc: ProseDocument): VariantChars =>
+  new Map((doc.lexicons["name-variant-char"] ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])));
+
 /** 同じ名前を、文書の中で少しだけ違う形に書いた所（GitHub と Github、山田太郎 と 山田太朗）。少ないほうを指す。 */
-export const nameVariant: Detector = (doc): Finding[] =>
-  nameVariants(doc.sentences.flatMap((sentence) => mentionsIn(sentence.tokens ?? [], doc.source))).map(({ mention, usual, kind }) => ({
+export const nameVariant: Detector = (doc): Finding[] => {
+  const suffixes = (doc.lexicons["person-suffix"] ?? []).map((entry) => entry.pattern);
+  const chars = variantCharsOf(doc);
+  const tagged = doc.sentences.flatMap((sentence) => mentionsIn(sentence.tokens ?? [], doc.source, suffixes));
+  const mentions = [...tagged, ...suffixedNamesIn(doc.prose ?? doc.source, suffixes, chars, tagged)].toSorted((left, right) => left.offset - right.offset);
+  return nameVariants(mentions, chars).map(({ mention, usual, kind }) => ({
     rule: "",
     severity: "warning",
     line: 0,
@@ -13,3 +22,4 @@ export const nameVariant: Detector = (doc): Finding[] =>
     values: { name: mention.surface, usual, offset: mention.offset },
     variant: kind,
   }));
+};

package/src/detectors/registry/amount-scale.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { amountScale } from "../amount-scale.ts";
+
+export const detector: Detector = amountScale;

package/src/facts/counted-facts.ts

@@ -0,0 +1,59 @@
+import type { Span, Token } from "../plugin.ts";
+import type { FactValue } from "./fact-values.ts";
+import type { Fact } from "./labelled-facts.ts";
+
+// A value with no label, named by who counts, the verb that counts and what is counted ("We gained 52 new customers": we
+// + gain + new customer). A summary that states such a value is compared with the body's value for the same three. Pure:
+// reads the tagger's parts of speech and lemmas.
+
+/** The words right after a number that say what it counts, and the key of who counts it with which verb. */
+export type CountedPhrase = Span & { readonly label: string; readonly key: string };
+
+/** How many words after a number may name what it counts ("new enterprise customers"). */
+const MAX_COUNTED_WORDS = 3;
+const COUNTED_WORD: ReadonlySet<string> = new Set(["ADJ", "NOUN"]);
+const SUBJECT_WORD: ReadonlySet<string> = new Set(["NOUN", "PROPN", "PRON"]);
+/** A number right after a preposition is part of something larger: the pool in "1 of 3 proposals". */
+const NOT_A_COUNT_AFTER: ReadonlySet<string> = new Set(["ADP", "NUM"]);
+
+/** The number is the end of a range ("between 10 and 12 customers") or of a pair ("1 of 3"). */
+const isPartOfLarger = (tokens: readonly Token[], index: number): boolean => {
+  const [twoBefore, before] = [tokens[index - 2], tokens[index - 1]];
+  return NOT_A_COUNT_AFTER.has(before?.pos ?? "") || (before?.pos === "CCONJ" && twoBefore?.pos === "NUM");
+};
+
+const wordOf = (token: Token): string => (token.lemma ?? token.surface).toLowerCase();
+
+/** The adjectives and nouns right after the number at index, up to the last noun ("new customers"). */
+const countedWords = (tokens: readonly Token[], index: number): Token[] => {
+  const after = tokens.slice(index + 1, index + 1 + MAX_COUNTED_WORDS);
+  const stop = after.findIndex((token) => !COUNTED_WORD.has(token.pos));
+  const run = stop < 0 ? after : after.slice(0, stop);
+  return run.slice(0, run.findLastIndex((token) => token.pos === "NOUN") + 1);
+};
+
+/**
+ * What the number at index in a sentence's tokens counts: the words after it, the nearest verb before it, and the nearest
+ * noun or pronoun before that verb (who counts). None when one of the three is missing or the number is part of a larger one.
+ */
+export const countedPhraseAt = (tokens: readonly Token[], index: number): CountedPhrase[] => {
+  if (isPartOfLarger(tokens, index)) return [];
+  const words = countedWords(tokens, index);
+  const verbAt = tokens.slice(0, index).findLastIndex((token) => token.pos === "VERB");
+  const subject = tokens.slice(0, Math.max(0, verbAt)).findLast((token) => SUBJECT_WORD.has(token.pos));
+  const [first, last, verb] = [words[0], words.at(-1), tokens[verbAt]];
+  if (first === undefined || last === undefined || verb === undefined || subject === undefined) return [];
+  const key = ["counted", wordOf(subject), wordOf(verb), ...words.map(wordOf)].join("\u0000");
+  return [{ start: first.span.start, end: last.span.end, label: words.map((token) => token.surface).join(" "), key }];
+};
+
+/** A calendar year ("2026 revenue") is a point in time, not a count. */
+const YEAR = /^(?:1[89]|2[01])\d{2}$/u;
+
+/** The fact of each number with no unit that a counted phrase follows after one character (the space). */
+export const countedFacts = (source: string, values: readonly FactValue[], phrases: readonly CountedPhrase[]): Fact[] =>
+  values.flatMap((value) => {
+    if (value.kind !== "quantity" || value.unit !== "" || YEAR.test(source.slice(value.start, value.end))) return [];
+    const phrase = phrases.find((candidate) => candidate.start === value.end + 1);
+    return phrase === undefined ? [] : [{ label: phrase.label, key: phrase.key, value }];
+  });

package/src/name-variants.ts

@@ -1,13 +1,26 @@
 import type { Token } from "./plugin.ts";
+import { escapeRegExp } from "./orthography.ts";
 
 // 同じ名前（人・会社・製品）を、文書の中で少しだけ違う形に書いた所。どの形が正しいかは決めず、少ないほうを指す。
 // 三通りで同じ名前と見る。書き方の違いだけ（GitHub と Github、Mac OS と macOS）、読みが同じ（山田太郎 と 山田太朗）、
 // 英字の一字違い（Microsoft と Microsft）。一字違いは別の名前でもありうるので、多いほうが二度以上、少ないほうが一度だけのときに限る。
 
-/** words は名前の語（記号を除く）。読みが同じ二つの名前が、どの語で違うかを見るため。 */
-export type NameMention = { readonly surface: string; readonly offset: number; readonly reading: string | undefined; readonly words: readonly string[] };
+/**
+ * words は名前の語（記号を除く）。読みが同じ二つの名前が、どの語で違うかを見るため。person は人の名前と読めるもの（解析器が
+ * 人名と読むか、敬称が付く）。
+ */
+export type NameMention = {
+  readonly surface: string;
+  readonly offset: number;
+  readonly reading: string | undefined;
+  readonly words: readonly string[];
+  readonly person?: boolean;
+};
+
+export type NameVariant = { readonly mention: NameMention; readonly usual: string; readonly kind: "spelling" | "reading" | "near" | "character" };
 
-export type NameVariant = { readonly mention: NameMention; readonly usual: string; readonly kind: "spelling" | "reading" | "near" };
+/** 字体の違う同じ字（斎・斉・齋）。字から、その組の代表の字へ。 */
+export type VariantChars = ReadonlyMap<string, string>;
 
 const NAME = "PROPN";
 /**
@@ -58,11 +71,18 @@ const withoutEdgeQuotes = (text: string): string => {
  */
 const NOT_COMPARED = /@|(?:^|\s)\p{L}(?:\s|$)/u;
 
+/** 人名と読む解析器の印（UD の NameType: 姓 Sur、名 Giv、どちらとも言えない人名 Prs）。 */
+const PERSON_TYPES: ReadonlySet<string> = new Set(["Sur", "Giv", "Prs"]);
+
+/** 人の名前か。解析器が人名と読む語を含むか、すぐ後ろに敬称（様、さん、氏）が付く。 */
+const isPerson = (run: readonly Token[], next: Token | undefined, suffixes: readonly string[]): boolean =>
+  run.some((token) => PERSON_TYPES.has(token.features?.["NameType"] ?? "")) || (next !== undefined && suffixes.includes(next.surface));
+
 /**
  * 文の語から、名前の現れ。surface は source の上の書いたまま（折り返しの空白は一つにまとめる）。
  * 大文字だけの名前（ACME INC、NASA）は外す。契約書の署名欄や略語で、ふつうの書き方の別の形ではない。小文字の英字だけの語も外す。
  */
-export const mentionsIn = (tokens: readonly Token[], source: string): NameMention[] =>
+export const mentionsIn = (tokens: readonly Token[], source: string, personSuffixes: readonly string[] = []): NameMention[] =>
   runsOf(tokens).flatMap((run) => {
     const first = run[0];
     const last = run.at(-1);
@@ -73,9 +93,39 @@ export const mentionsIn = (tokens: readonly Token[], source: string): NameMentio
     const words = run.filter((token) => !JOINERS.has(token.surface));
     const readings = words.map((token) => token.reading);
     const reading = readings.every((value) => value !== undefined && value !== "") ? readings.join("") : undefined;
-    return [{ surface, offset: first.span.start, reading, words: words.map((token) => token.surface) }];
+    const person = isPerson(run, tokens[tokens.indexOf(last) + 1], personSuffixes);
+    return [{ surface, offset: first.span.start, reading, words: words.map((token) => token.surface), person }];
   });
 
+/** 敬称の前の名前の字数（髙橋、髙橋太郎）。長い漢字の連なり（株式会社髙橋）は名前だけを切り出せない。 */
+const MAX_SUFFIXED_NAME = 4;
+const MIN_SUFFIXED_NAME = 2;
+/** 敬称の前を読む範囲（UTF-16 の単位）。名前より長い漢字の連なりを、長いまま見るため。 */
+const SUFFIX_LOOKBACK = 20;
+const HAN = /^\p{Script=Han}$/u;
+
+/** 文字列の終わりの漢字の連なり。 */
+const trailingHan = (text: string): string => {
+  const letters = [...text];
+  return letters.slice(letters.findLastIndex((letter) => !HAN.test(letter)) + 1).join("");
+};
+
+/**
+ * 解析器が名前と読めなかった、字体の違う字を含む人の名前（髙橋様、𠮷田様、﨑山様）。敬称のすぐ前の漢字の連なりで、語彙表の字を
+ * 含み、ほかの名前の現れと重ならないもの。
+ */
+export const suffixedNamesIn = (source: string, suffixes: readonly string[], chars: VariantChars, taken: readonly NameMention[]): NameMention[] =>
+  suffixes.flatMap((suffix) =>
+    [...source.matchAll(new RegExp(escapeRegExp(suffix), "gu"))].flatMap((match) => {
+      const run = trailingHan(source.slice(Math.max(0, match.index - SUFFIX_LOOKBACK), match.index));
+      const length = [...run].length;
+      if (length < MIN_SUFFIXED_NAME || length > MAX_SUFFIXED_NAME || ![...run].some((letter) => chars.has(letter))) return [];
+      const offset = match.index - run.length;
+      if (taken.some((mention) => mention.offset < match.index && offset < mention.offset + mention.surface.length)) return [];
+      return [{ surface: run, offset, reading: undefined, words: [run], person: true }];
+    }),
+  );
+
 /** 比べる形。幅（ＡＷＳ と AWS）、大文字小文字、空白と記号は名前を変えない。 */
 export const nameKey = (surface: string): string =>
   surface
@@ -83,14 +133,19 @@ export const nameKey = (surface: string): string =>
     .toLowerCase()
     .replaceAll(/[\s\p{P}\p{S}]/gu, "");
 
-type Tally = { readonly surface: string; readonly first: NameMention; readonly count: number };
+/** person: どれかの現れが人の名前と読める。 */
+type Tally = { readonly surface: string; readonly first: NameMention; readonly count: number; readonly person: boolean };
 
 const talliesOf = (mentions: readonly NameMention[]): Tally[] => {
-  const tallies = new Map<string, { surface: string; first: NameMention; count: number }>();
+  const tallies = new Map<string, { surface: string; first: NameMention; count: number; person: boolean }>();
   mentions.forEach((mention) => {
     const tally = tallies.get(mention.surface);
-    if (tally === undefined) tallies.set(mention.surface, { surface: mention.surface, first: mention, count: 1 });
-    else tally.count += 1;
+    const person = mention.person === true;
+    if (tally === undefined) tallies.set(mention.surface, { surface: mention.surface, first: mention, count: 1, person });
+    else {
+      tally.count += 1;
+      tally.person ||= person;
+    }
   });
   return [...tallies.values()];
 };
@@ -191,8 +246,46 @@ const isSlipOf = (tally: Tally, other: Tally): boolean => {
 
 const nearVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(groupBy(tallies, maskedKeys), "near", isSlipOf);
 
-/** 同じ名前の、少ないほうの書き方。書き方ごとに最初の現れを一つ。同じ現れを二つの見方が言えば、先の見方だけ。 */
-export const nameVariants = (mentions: readonly NameMention[]): NameVariant[] => {
+/** 字体の違う字（斎と斉）を組の代表の字に寄せた形。 */
+const characterKey = (tally: Tally, chars: VariantChars): string => [...tally.surface].map((letter) => chars.get(letter) ?? letter).join("");
+
+/** 人の名前を、字体の違う同じ字（斎藤 と 斉藤、渡辺 と 渡邊）で書き分けた所。 */
+const characterVariants = (tallies: readonly Tally[], chars: VariantChars): NameVariant[] =>
+  variantsIn(
+    groupBy(
+      tallies.filter((tally) => tally.person),
+      (tally) => [characterKey(tally, chars)],
+    ),
+    "character",
+  );
+
+/** 字数が同じで、一字だけが違う（松本 と 松元）。 */
+const oneCharApart = (left: string, right: string): boolean => {
+  const [leftChars, rightChars] = [[...left], [...right]];
+  return leftChars.length === rightChars.length && leftChars.filter((char, index) => char !== rightChars[index]).length === 1;
+};
+
+/**
+ * 読みが同じ人の名前が、一字だけ違う（松本 と 松元）。読みの同じ別の姓（伊藤 と 伊東）もあるので、多いほうが二度以上、
+ * 少ないほうが一度だけのときに限る。
+ */
+const isPersonSlipOf = (tally: Tally, other: Tally): boolean => tally.count === 1 && other.count >= 2 && oneCharApart(tally.surface, other.surface);
+
+const personReadingVariants = (tallies: readonly Tally[]): NameVariant[] =>
+  variantsIn(
+    groupBy(
+      tallies.filter((tally) => tally.person),
+      (tally) => (tally.first.reading === undefined ? [] : [tally.first.reading]),
+    ),
+    "reading",
+    isPersonSlipOf,
+  );
+
+/**
+ * 同じ名前の、少ないほうの書き方。書き方ごとに最初の現れを一つ。同じ現れを二つの見方が言えば、先の見方だけ。chars は字体の
+ * 違う同じ字の組（語彙表 name-variant-char）。
+ */
+export const nameVariants = (mentions: readonly NameMention[], chars: VariantChars = new Map()): NameVariant[] => {
   const tallies = talliesOf(mentions);
   const found = [
     ...variantsIn(
@@ -205,6 +298,8 @@ export const nameVariants = (mentions: readonly NameMention[]): NameVariant[] =>
       oneWordApart,
     ),
     ...nearVariants(tallies),
+    ...characterVariants(tallies, chars),
+    ...personReadingVariants(tallies),
   ];
   const reported = new Set<string>();
   return found

package/src/structure/amount-scale.ts

@@ -0,0 +1,97 @@
+// An amount written in digits where the document writes amounts of that size with a word of scale, or the other way
+// round (250,000円 beside 30万円; $2,500,000 beside $1.5 million). Small amounts in digits and large ones with 万 or
+// million is one way of writing, not a mix, so only amounts of the same order of magnitude are compared. Pure.
+
+/**
+ * One amount: where it is, as written, its currency, its value, and the largest word of scale it was written with (unit:
+ * 10000 for 30万円, 1000000 for $1.5 million), undefined when it was written in digits only.
+ */
+export type ScaledAmount = {
+  readonly offset: number;
+  readonly written: string;
+  readonly currency: string;
+  readonly value: number;
+  readonly unit: number | undefined;
+};
+
+/** The amount written the other way, and the first one of its size written the usual way. */
+export type ScaleMix = { readonly odd: ScaledAmount; readonly usual: ScaledAmount };
+
+/** A digit amount with more significant digits than this (1,234,567円) is a precise figure no word of scale would write. */
+const MAX_SIGNIFICANT_DIGITS = 3;
+
+const significantDigits = (value: number): number => {
+  const digits = [...String(value).replace(".", "")];
+  const first = digits.findIndex((digit) => digit !== "0");
+  return first < 0 ? 0 : digits.findLastIndex((digit) => digit !== "0") - first + 1;
+};
+
+const isScaled = (amount: ScaledAmount): boolean => amount.unit !== undefined;
+
+/**
+ * Whether the amount could be written the other way. A digit one when it is round (250,000, not 250,500); a scaled one when
+ * it is at least one of its unit: "£0.2 million" is written to line up with larger amounts beside it, not to give a size.
+ */
+const comparable = (amount: ScaledAmount): boolean =>
+  amount.value > 0 && (amount.unit === undefined ? significantDigits(amount.value) <= MAX_SIGNIFICANT_DIGITS : amount.value >= amount.unit);
+
+/** The order of magnitude, from the digits of the whole part (Math.log10 is not exact at every power of ten). */
+const magnitudeOf = (value: number): number => String(Math.floor(value)).length - 1;
+
+const countScaled = (amounts: readonly ScaledAmount[]): number => amounts.filter(isScaled).length;
+
+/** Whether the scaled way is the odd one in a size: the fewer there, then the fewer at that size and above, then the later. */
+const oddIsScaled = (band: readonly ScaledAmount[], larger: readonly ScaledAmount[]): boolean => {
+  const scaledInBand = countScaled(band);
+  if (scaledInBand * 2 !== band.length) return scaledInBand * 2 < band.length;
+  const scaledLarger = countScaled(larger);
+  if (scaledLarger * 2 !== larger.length) return scaledLarger * 2 < larger.length;
+  const firstScaled = band.findIndex(isScaled);
+  const firstDigits = band.findIndex((amount) => !isScaled(amount));
+  return firstScaled > firstDigits;
+};
+
+const mixesOfCurrency = (amounts: readonly ScaledAmount[]): ScaleMix[] => {
+  const magnitudes = [...new Set(amounts.map((amount) => magnitudeOf(amount.value)))];
+  return magnitudes.flatMap((magnitude) => {
+    const band = amounts.filter((amount) => magnitudeOf(amount.value) === magnitude);
+    const scaledIsOdd = oddIsScaled(
+      band,
+      amounts.filter((amount) => magnitudeOf(amount.value) >= magnitude),
+    );
+    const usual = band.find((amount) => isScaled(amount) !== scaledIsOdd);
+    if (usual === undefined) return [];
+    return band.filter((amount) => isScaled(amount) === scaledIsOdd).map((amount) => ({ odd: amount, usual }));
+  });
+};
+
+/** For each currency, the amounts written the other way from the rest of their order of magnitude, in document order. */
+export const scaleMixes = (amounts: readonly ScaledAmount[]): ScaleMix[] => {
+  const ordered = amounts.filter(comparable).toSorted((left, right) => left.offset - right.offset);
+  return [...new Set(ordered.map((amount) => amount.currency))]
+    .flatMap((currency) => mixesOfCurrency(ordered.filter((amount) => amount.currency === currency)))
+    .toSorted((left, right) => left.odd.offset - right.odd.offset);
+};
+
+/** A word of scale and the value it multiplies by (万 10000, million 1000000). */
+export type ScaleWord = { readonly word: string; readonly value: number };
+
+const NUMBER_THEN_WORD = /(\d+(?:,\d{3})*(?:\.\d+)?)\s?([^\s\d.,]*)/gu;
+
+/**
+ * The value of an amount as written, without its currency: 1億2,000万 is 120000000, 1.5 million is 1500000. Undefined when a
+ * part is followed by a word that is not one of scale, or nothing is read.
+ */
+export const amountValue = (written: string, words: readonly ScaleWord[]): number | undefined => {
+  const parts = [...written.normalize("NFKC").matchAll(NUMBER_THEN_WORD)];
+  if (parts.length === 0) return undefined;
+  const values = parts.map((part) => {
+    const number = Number((part[1] ?? "").replaceAll(",", ""));
+    const word = (part[2] ?? "").toLowerCase();
+    if (word === "") return number;
+    const scale = words.find((entry) => entry.word.toLowerCase() === word);
+    return scale === undefined ? Number.NaN : number * scale.value;
+  });
+  const total = values.reduce((sum, value) => sum + value, 0);
+  return Number.isFinite(total) ? total : undefined;
+};