chaffjs 0.18.0 → 0.20.0

package/src/detectors/name-variant.ts

@@ -0,0 +1,15 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { mentionsIn, nameVariants } from "../name-variants.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** 同じ名前を、文書の中で少しだけ違う形に書いた所（GitHub と Github、山田太郎 と 山田太朗）。少ないほうを指す。 */
+export const nameVariant: Detector = (doc): Finding[] =>
+  nameVariants(doc.sentences.flatMap((sentence) => mentionsIn(sentence.tokens ?? [], doc.source))).map(({ mention, usual, kind }) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, mention.offset),
+    values: { name: mention.surface, usual, offset: mention.offset },
+    variant: kind,
+  }));

package/src/detectors/next-word.ts

@@ -0,0 +1,156 @@
+import type { Detector, Finding, Lexicon, Sentence, Token } from "../plugin.ts";
+import { densityFindings } from "./ai-phrasing.ts";
+
+/**
+ * The word kinds an article can stand before. A conjunction, a preposition or a verb after "a" is the letter a ("option A
+ * or B", "a is the length").
+ */
+const CONTENT = new Set(["NOUN", "PROPN", "ADJ", "ADV", "NUM"]);
+
+const LETTER_START = /^\p{L}/u;
+const HAS_LOWER = /\p{Ll}/u;
+/** A lower-case letter before capitals (mRNA, pH is not): the first letter is said by its name. */
+const LETTER_BEFORE_CAPITALS = /^\p{Ll}\p{Lu}{2}/u;
+
+/** Two tokens with nothing but whitespace between them in the source. Code and markup are hidden from the tokens. */
+const adjacent = (source: string, left: Token, right: Token): boolean => source.slice(left.span.end, right.span.start).trim() === "";
+
+/** The sound knowledge of lexicon article-sound, by group. */
+export type ArticleSounds = {
+  readonly vowelLetters: ReadonlySet<string>;
+  readonly vowelLetterNames: ReadonlySet<string>;
+  readonly eitherLetterNames: ReadonlySet<string>;
+  readonly consonant: readonly string[];
+  readonly vowel: readonly string[];
+  readonly word: ReadonlySet<string>;
+  readonly either: readonly string[];
+};
+
+const ofGroup = (lexicon: Lexicon, group: string): string[] => lexicon.filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+export const articleSoundsOf = (lexicon: Lexicon): ArticleSounds => ({
+  vowelLetters: new Set(ofGroup(lexicon, "vowel-letter")),
+  vowelLetterNames: new Set(ofGroup(lexicon, "letter-name-vowel")),
+  eitherLetterNames: new Set(ofGroup(lexicon, "letter-name-either")),
+  consonant: ofGroup(lexicon, "consonant"),
+  vowel: ofGroup(lexicon, "vowel"),
+  word: new Set(ofGroup(lexicon, "word")),
+  either: ofGroup(lexicon, "either"),
+});
+
+const startsWithAny = (word: string, starts: readonly string[]): boolean => starts.some((start) => word.startsWith(start));
+
+/** Whether a word in lower or mixed case starts with a vowel sound; undefined when it is said both ways. */
+const wordSound = (word: string, sounds: ArticleSounds): boolean | undefined => {
+  const lower = word.toLowerCase();
+  if (startsWithAny(lower, sounds.either)) return undefined;
+  if (startsWithAny(lower, sounds.vowel)) return true;
+  if (startsWithAny(lower, sounds.consonant)) return false;
+  return sounds.vowelLetters.has(lower.charAt(0));
+};
+
+/** Capitals longer than this that hold a vowel may be said as a word (SALT, GIF), so only the lexicon decides them. */
+const SPELLED_OUT_LENGTH = 3;
+
+/** Whether capitals not in the lexicon are surely said letter by letter: short (MBA), or with no vowel to say (HTTP). */
+const isSpelledOut = (word: string, sounds: ArticleSounds): boolean =>
+  word.length <= SPELLED_OUT_LENGTH || ![...word.toLowerCase()].some((letter) => sounds.vowelLetters.has(letter));
+
+/**
+ * Whether a word starts with a vowel sound. Capitals are read as the lexicon says (a NASA probe), else letter by letter when
+ * surely spelled out (an MBA). undefined when the word may be said both ways (a SQL, an SQL; a or an HTTP) or nothing says how.
+ */
+export const startsWithVowelSound = (word: string, sounds: ArticleSounds): boolean | undefined => {
+  if (LETTER_BEFORE_CAPITALS.test(word)) return sounds.vowelLetterNames.has(word.charAt(0).toUpperCase());
+  if (HAS_LOWER.test(word)) return wordSound(word, sounds);
+  if (sounds.either.includes(word) || sounds.eitherLetterNames.has(word.charAt(0))) return undefined;
+  if (sounds.word.has(word)) return wordSound(word, sounds);
+  return isSpelledOut(word, sounds) ? sounds.vowelLetterNames.has(word.charAt(0)) : undefined;
+};
+
+const ARTICLES: Readonly<Record<string, boolean>> = { a: false, an: true };
+
+/** The article the next word takes, written in the case of the one written ("A apple" → "An"). */
+const fitting = (written: string, vowel: boolean): string => {
+  const article = vowel ? "an" : "a";
+  return written.charAt(0) === written.charAt(0).toUpperCase() ? `${article.charAt(0).toUpperCase()}${article.slice(1)}` : article;
+};
+
+type Slip = { readonly article: Token; readonly next: Token; readonly fits: string };
+
+/** An article that does not fit the sound of the word after it. */
+const WORD = /\p{L}/u;
+
+/**
+ * Whether a token is the article "a" or "an": lower case, or capitalised as the first word of the sentence. A capital A
+ * inside a sentence is a letter ("grade A eggs", "vitamin A intake").
+ */
+const isArticle = (token: Token, at: number, tokens: readonly Token[]): boolean => {
+  const first = tokens.findIndex((candidate) => WORD.test(candidate.surface));
+  return token.surface === token.surface.toLowerCase() || at === first;
+};
+
+const slipAt = (source: string, tokens: readonly Token[], at: number, sounds: ArticleSounds): Slip | undefined => {
+  const article = tokens[at];
+  const next = tokens[at + 1];
+  const takesAn = ARTICLES[article?.surface.toLowerCase() ?? ""];
+  if (article === undefined || next === undefined || takesAn === undefined || !isArticle(article, at, tokens)) return undefined;
+  if (!CONTENT.has(next.pos) || !LETTER_START.test(next.surface)) return undefined;
+  if (!adjacent(source, article, next)) return undefined;
+  const vowel = startsWithVowelSound(next.surface, sounds);
+  return vowel === undefined || vowel === takesAn ? undefined : { article, next, fits: fitting(article.surface, vowel) };
+};
+
+const slipFinding = (sentence: Sentence, slip: Slip): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: sentence.text.trim(),
+  values: { matched: `${slip.article.surface} ${slip.next.surface}`, article: slip.fits, offset: slip.article.span.start },
+});
+
+/** "a" before a vowel sound or "an" before a consonant sound (a apple, an user), by the sound knowledge in the lexicon. */
+export const articleSound: Detector = (doc, options): Finding[] => {
+  const sounds = articleSoundsOf(options.lexicon ?? []);
+  const findings = doc.sentences.flatMap((sentence) => {
+    const tokens = sentence.tokens ?? [];
+    return tokens.flatMap((_token, at) => {
+      const slip = slipAt(doc.source, tokens, at, sounds);
+      return slip === undefined ? [] : [slipFinding(sentence, slip)];
+    });
+  });
+  return findings.length < options.limit ? [] : findings;
+};
+
+const ADJECTIVE = "ADJ";
+
+type Intensified = { readonly sentence: Sentence; readonly matched: string; readonly offset: number };
+
+type IntensifierWords = { readonly intensifiers: ReadonlySet<string>; readonly exceptions: ReadonlySet<string> };
+
+/** The lexicon's intensifier right before an adjective ("very important"), not before an excepted word ("the very first"). */
+const intensifiedIn = (source: string, sentence: Sentence, words: IntensifierWords): Intensified[] => {
+  const tokens = sentence.tokens ?? [];
+  return tokens.flatMap((token, at) => {
+    const next = tokens[at + 1];
+    if (next === undefined || !words.intensifiers.has(token.surface.toLowerCase()) || next.pos !== ADJECTIVE) return [];
+    if (!adjacent(source, token, next)) return [];
+    return words.exceptions.has(next.surface.toLowerCase()) ? [] : [{ sentence, matched: `${token.surface} ${next.surface}`, offset: token.span.start }];
+  });
+};
+
+const EXCEPTIONS = "very-exception";
+
+/** "very" + adjective, dense for the document's length: each one leans on "very" instead of a stronger word. */
+export const intensifiedAdjective: Detector = (doc, options): Finding[] => {
+  const words = {
+    intensifiers: new Set((options.lexicon ?? []).map((entry) => entry.pattern)),
+    exceptions: new Set((doc.lexicons[EXCEPTIONS] ?? []).map((entry) => entry.pattern)),
+  };
+  return densityFindings(
+    doc,
+    doc.sentences.flatMap((sentence) => intensifiedIn(doc.source, sentence, words)),
+    options.limit,
+  );
+};

package/src/detectors/nominalization.ts

@@ -0,0 +1,73 @@
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Token } from "../plugin.ts";
+import { entryRanges, type TokenRange } from "./lexicon-match.ts";
+import { rateOver } from "./lexicon.ts";
+
+// A verb written as a noun and carried by another verb: 調査を実施した for 調査した, "make a decision" for "decide"
+// (the やさしい日本語 guideline; the Federal Plain Language Guidelines' hidden verbs; GOV.UK). Two shapes, each from a
+// lexicon the language may or may not have: a whole phrase with its verb (nominalization-phrase), or a verbal noun
+// (the adapter's VerbForm=Vnoun) followed by a carrying verb (nominalization-light-verb). Counted as a density.
+
+export type Hidden = { readonly sentence: Sentence; readonly offset: number; readonly matched: string; readonly preferred: string };
+
+const PHRASES = "nominalization-phrase";
+const LIGHT_VERBS = "nominalization-light-verb";
+/** Verbal nouns whose carrying verb means "hold" (研修を実施する is not 研修する): not hidden verbs. */
+const EVENT_NOUNS = "nominalization-event-noun";
+
+const isVerbalNoun = (token: Token | undefined): token is Token => token?.features?.["VerbForm"] === "Vnoun";
+
+const writtenBetween = (source: string, tokens: readonly Token[], range: TokenRange): string => {
+  const [first, last] = [tokens[range.start], tokens[range.end - 1]];
+  return first === undefined || last === undefined ? "" : source.slice(first.span.start, last.span.end);
+};
+
+/** A phrase of the lexicon, with the verb it hides (instead_of). */
+const phrasesIn = (sentence: Sentence, source: string, phrases: Lexicon): Hidden[] =>
+  phrases.flatMap((entry) =>
+    entryRanges(sentence, entry).map((range) => ({
+      sentence,
+      offset: sentence.tokens?.[range.start]?.span.start ?? sentence.span.start,
+      matched: writtenBetween(source, sentence.tokens ?? [], range),
+      preferred: entry.instead_of ?? "",
+    })),
+  );
+
+/**
+ * A carrying verb right after a verbal noun: 調査 + を実施した. Both sides are named in the dictionary form, the noun and the
+ * entry (調査を実施する), and the verb to write is the noun and the entry's instead_of (調査 + する).
+ */
+const lightVerbsIn = (sentence: Sentence, lightVerbs: Lexicon, eventNouns: ReadonlySet<string>): Hidden[] => {
+  const tokens = sentence.tokens ?? [];
+  return lightVerbs.flatMap((entry) =>
+    entryRanges(sentence, entry).flatMap((range): Hidden[] => {
+      const noun = tokens[range.start - 1];
+      if (!isVerbalNoun(noun) || eventNouns.has(noun.surface)) return [];
+      return [{ sentence, offset: noun.span.start, matched: `${noun.surface}${entry.pattern}`, preferred: `${noun.surface}${entry.instead_of ?? ""}` }];
+    }),
+  );
+};
+
+/** Pure: every hidden verb in the document, in the order they are written. */
+export const hiddenVerbs = (doc: Pick<ProseDocument, "sentences" | "source" | "lexicons">): Hidden[] => {
+  const eventNouns = new Set((doc.lexicons[EVENT_NOUNS] ?? []).map((entry) => entry.pattern));
+  return doc.sentences
+    .flatMap((sentence) => [
+      ...phrasesIn(sentence, doc.source, doc.lexicons[PHRASES] ?? []),
+      ...lightVerbsIn(sentence, doc.lexicons[LIGHT_VERBS] ?? [], eventNouns),
+    ])
+    .toSorted((left, right) => left.offset - right.offset);
+};
+
+export const nominalization: Detector = (doc, options): Finding[] => {
+  const hidden = hiddenVerbs(doc);
+  const rate = rateOver(doc, hidden.length, options.limit);
+  if (rate === undefined) return [];
+  return hidden.map((found) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: found.sentence.text.trim(),
+    values: { matched: found.matched, preferred: found.preferred, count: hidden.length, density: rate, limit: options.limit, offset: found.offset },
+  }));
+};

package/src/detectors/number-style.ts

@@ -0,0 +1,230 @@
+// How a document writes its numbers: 3件 or 三件, 1,000 or 1000, 10% or 10％ or 10パーセント, three files or 3 files.
+// Each kind is compared within the document and the less common style is reported; neither is called right. Pure; the
+// words (counters, kanji numerals, percent units, number words) come from the language's lexicons.
+import { escapeRegExp } from "../orthography.ts";
+import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
+import { isCitation } from "./kutoten-consistency.ts";
+import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
+
+export type NumberKind = "count" | "grouping" | "percent" | "count-small" | "count-large";
+
+/** One number as written: its kind, the style it is written in, the text, and where it starts in the document. */
+export type NumberMark = { readonly kind: NumberKind; readonly style: string; readonly written: string; readonly offset: number };
+
+/** The language's words for numbers. countWords is in order from one (the position is the value). */
+export type NumberWords = {
+  readonly counters: readonly string[];
+  readonly kanji: readonly string[];
+  readonly percentUnits: readonly string[];
+  readonly countWords: readonly string[];
+  /** Plural nouns of measure (days, miles) that take figures in every style: a number before one is not a count. */
+  readonly figureNouns: readonly string[];
+};
+
+const alternation = (words: readonly string[]): string =>
+  words
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+const DIGIT_RUN = "[0-9０-９]+(?:[,，.．][0-9０-９]+)*";
+
+// ───────── counts in Japanese: 3件 or 三件 ─────────
+
+/**
+ * A number right before a counter. Not after a kanji, a kana prolonged mark or 第 (統一, 唯一, 第三回 are words or ordinals),
+ * nor after a letter or digit (part of a code).
+ */
+const countPattern = (words: NumberWords): RegExp | undefined => {
+  if (words.counters.length === 0 || words.kanji.length === 0) return undefined;
+  const kanji = `[${words.kanji.map(escapeRegExp).join("")}]+`;
+  return new RegExp(`(?<![\\p{Script=Han}A-Za-z0-9０-９.．])(?:(${DIGIT_RUN}[万億]?)|(${kanji}))\\s?(?:${alternation(words.counters)})`, "gu");
+};
+
+/**
+ * 一 alone is the idiom (一つ, 一人, 一回) a document writes in kanji whatever its style for counts. A run of magnitudes only
+ * (万人, 百人一首, 千人) is as often a word as a number.
+ */
+const MAGNITUDES = /^[一百千万億]+$/u;
+
+const isIdiomNumeral = (numeral: string): boolean => MAGNITUDES.test(numeral);
+
+const countMarks = (text: string, base: number, words: NumberWords): NumberMark[] => {
+  const pattern = countPattern(words);
+  if (pattern === undefined) return [];
+  return [...text.matchAll(pattern)].flatMap((match): NumberMark[] => {
+    const [written, digits, kanji] = match;
+    if (kanji !== undefined && isIdiomNumeral(kanji)) return [];
+    return [{ kind: "count", style: digits === undefined ? "kanji" : "digits", written, offset: base + match.index }];
+  });
+};
+
+// ───────── digit grouping: 1,000 or 1000 ─────────
+
+const GROUPED = /^[0-9０-９]{1,3}(?:[,，][0-9０-９]{3})+$/u;
+
+const DIGITS_AND_COMMAS = /[0-9０-９]+(?:[,，][0-9０-９]+)*/gu;
+const PLAIN_BIG = /^[1-9１-９][0-9０-９]{3,}$/u;
+
+/** Next to one of these, a run of digits is part of a code, a version, a date, a time, a phone number or a decimal. */
+const NOT_BEFORE = /[\p{L}\p{N}.,，．#＃/:：\-－_]/u;
+const NOT_AFTER = /[\p{N}.,，．:：\-－/]/u;
+
+type DigitRun = { readonly written: string; readonly index: number };
+
+/** Each number of four digits or more standing alone, grouped (1,000) or not (1000). */
+const bigNumbers = (text: string): DigitRun[] =>
+  [...text.matchAll(DIGITS_AND_COMMAS)].flatMap((match): DigitRun[] => {
+    const written = match[0];
+    const standsAlone = !NOT_BEFORE.test(text.charAt(match.index - 1)) && !NOT_AFTER.test(text.charAt(match.index + written.length));
+    return standsAlone && (GROUPED.test(written) || PLAIN_BIG.test(written)) ? [{ written, index: match.index }] : [];
+  });
+
+const CURRENCY_BEFORE = /[$¥￥€£]\s?$/u;
+
+/** A capitalised word or abbreviation right before (H.R. 5376, Form 1040, No. 12345): the number is a label, never grouped. */
+const isLabelBefore = (before: string): boolean => /\s$/u.test(before) && /^\p{Lu}/u.test(before.trimEnd().split(/\s/u).at(-1) ?? "");
+
+/** A four-digit number in this range is most often a year (2019 annual report), which is never grouped. */
+const YEAR_LIKE = { from: 1000, to: 2199 };
+
+const FOUR_DIGITS = 4;
+
+const isYearLike = (digits: string): boolean => {
+  const value = Number(digits.normalize("NFKC"));
+  return digits.length === FOUR_DIGITS && value >= YEAR_LIKE.from && value <= YEAR_LIKE.to;
+};
+
+/** What follows a quantity: a counter or 円 / 万 (Japanese), or a word in lower case (10000 users). */
+/** A counter or 円 / 万 / 億 right after (with at most one space): the number counts something in Japanese. */
+const countedAfter = (after: string, words: NumberWords): boolean => {
+  const next = after.replace(/^\s/u, "");
+  return /^[万億円]/u.test(next) || words.counters.some((counter) => next.startsWith(counter));
+};
+
+/** What follows a quantity: a Japanese counter, or a word in lower case (10000 users). */
+const quantityAfter = (after: string, words: NumberWords): boolean => /^\s?[a-z]/u.test(after) || countedAfter(after, words);
+
+/** How far back to look for a currency sign or a label word. The sentence may start right after one (H.R. ends a sentence). */
+const BEFORE_REACH = 16;
+
+const groupingMarks = (text: string, base: number, words: NumberWords, source: string): NumberMark[] =>
+  bigNumbers(text).flatMap(({ written, index }): NumberMark[] => {
+    const grouped = GROUPED.test(written);
+    const before = source.slice(Math.max(0, base + index - BEFORE_REACH), base + index);
+    const after = text.slice(index + written.length);
+    const currency = CURRENCY_BEFORE.test(before);
+    if (!currency && !quantityAfter(after, words)) return [];
+    if (!grouped && isLabelBefore(before)) return [];
+    if (!grouped && !currency && isYearLike(written) && !countedAfter(after, words)) return [];
+    return [{ kind: "grouping", style: grouped ? "grouped" : "plain", written, offset: base + index }];
+  });
+
+// ───────── percent: 10% or 10％ or 10パーセント, 10% or 10 percent ─────────
+
+const percentMarks = (text: string, base: number, words: NumberWords): NumberMark[] => {
+  if (words.percentUnits.length === 0) return [];
+  const pattern = new RegExp(`(?<![\\p{L}\\p{N}.．,，])(${DIGIT_RUN})\\s?(${alternation(words.percentUnits)})(?![A-Za-z])`, "gu");
+  return [...text.matchAll(pattern)].map((match) => ({
+    kind: "percent",
+    style: (match[2] ?? "").toLowerCase(),
+    written: match[0],
+    offset: base + match.index,
+  }));
+};
+
+// ───────── counts in English: three files or 3 files ─────────
+
+const SMALL_FROM = 2;
+const LARGE_FROM = 10;
+
+const valueOf = (surface: string, words: readonly string[]): number | undefined => {
+  if (/^\d+$/u.test(surface)) return Number(surface);
+  const at = words.indexOf(surface.toLowerCase());
+  return at === -1 ? undefined : at + 1;
+};
+
+const isCountedNoun = (token: Token | undefined, figureNouns: readonly string[]): boolean =>
+  token?.pos === "NOUN" && token.features?.["Number"] === "Plur" && !figureNouns.includes(token.surface.toLowerCase());
+
+/**
+ * A number before a plural noun (three files, 3 files), from two to the last number word the language lists. One is a
+ * pronoun as often as a count. A number word that opens the sentence is spelt out by every style, so it is not counted.
+ */
+const englishCountMarks = (sentence: Sentence, words: NumberWords): NumberMark[] => {
+  const tokens = sentence.tokens ?? [];
+  return tokens.flatMap((token, index): NumberMark[] => {
+    const value = valueOf(token.surface, words.countWords);
+    if (value === undefined || value < SMALL_FROM || value > words.countWords.length || index === 0 || !isCountedNoun(tokens[index + 1], words.figureNouns))
+      return [];
+    const style = /^\d+$/u.test(token.surface) ? "digits" : "words";
+    return [{ kind: value < LARGE_FROM ? "count-small" : "count-large", style, written: token.surface, offset: sentence.span.start + token.span.start }];
+  });
+};
+
+// ───────── the document ─────────
+
+/** Every number mark in a sentence, less those inside a quotation. */
+export const numberMarksIn = (sentence: Sentence, words: NumberWords, language: string, source: string): NumberMark[] => {
+  const base = sentence.span.start;
+  const marks = [
+    ...countMarks(sentence.text, base, words),
+    ...groupingMarks(sentence.text, base, words, source),
+    ...percentMarks(sentence.text, base, words),
+    ...(language === "ja" ? [] : englishCountMarks(sentence, words)),
+  ];
+  const quoted: readonly Span[] = quotedSpans(sentence.text, QUOTATION_MARKS);
+  return marks.filter((mark) => !isWithinAny(quoted, { start: mark.offset - base, end: mark.offset - base + mark.written.length }));
+};
+
+const PERCENT = 100;
+
+/**
+ * The marks not in the document's usual style, when they are few enough to be slips: at most limitPercent of the kind.
+ * The usual style is the most common one; on a tie, the one the document used first.
+ */
+export const minorityStyles = (marks: readonly NumberMark[], limitPercent: number): { readonly odd: NumberMark[]; readonly usual: NumberMark | undefined } => {
+  const counts = new Map<string, number>();
+  marks.forEach((mark) => counts.set(mark.style, (counts.get(mark.style) ?? 0) + 1));
+  if (counts.size < 2) return { odd: [], usual: undefined };
+  const most = Math.max(...counts.values());
+  const usual = marks.find((mark) => counts.get(mark.style) === most);
+  const odd = marks.filter((mark) => mark.style !== usual?.style);
+  return odd.length * PERCENT > limitPercent * marks.length ? { odd: [], usual } : { odd, usual };
+};
+
+const wordsOf = (doc: ProseDocument): NumberWords => {
+  const patterns = (id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+  return {
+    counters: patterns("numeral-counter"),
+    kanji: patterns("numeral-kanji"),
+    percentUnits: patterns("percent-unit"),
+    countWords: patterns("count-number"),
+    figureNouns: patterns("figure-noun"),
+  };
+};
+
+const KINDS: readonly NumberKind[] = ["count", "grouping", "percent", "count-small", "count-large"];
+
+const findingOf = (mark: NumberMark, usual: NumberMark, count: number, of: number, limit: number): Finding => ({
+  rule: "number-style-consistency",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: mark.written,
+  values: { written: mark.written, usual: usual.written, count, of, limit, offset: mark.offset },
+  variant: mark.kind,
+});
+
+/** For each kind of number, the marks written in the document's less common style. */
+export const numberStyleConsistency: Detector = (doc, options): Finding[] => {
+  const words = wordsOf(doc);
+  const marks = doc.sentences
+    .filter((sentence) => sentence.embeddedLanguage === undefined && !isCitation(sentence, doc.source))
+    .flatMap((sentence) => numberMarksIn(sentence, words, doc.language, doc.source));
+  return KINDS.flatMap((kind) => {
+    const ofKind = marks.filter((mark) => mark.kind === kind);
+    const { odd, usual } = minorityStyles(ofKind, options.limit);
+    return usual === undefined ? [] : odd.map((mark) => findingOf(mark, usual, odd.length, ofKind.length, options.limit));
+  });
+};

package/src/detectors/number-unit.ts

@@ -0,0 +1,146 @@
+// A number written bare where the same document gives that kind of value a unit: one cell of a table column, or one
+// "label: value" line, where the column's or label's other values all carry the same unit (300円, 200円, 150).
+// Pure; reads the Markdown tables and the label lines of the prose. Which words are units comes from the language's lexicons.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { readMarkdown } from "../markdown-read.ts";
+import { spanOf, type MarkdownNode } from "../markdown-node.ts";
+import { eachPreOrder } from "../tree-walk.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** One value of a kind: where its number starts, as written, and its unit ("" when bare). */
+export type Measured = { readonly kind: string; readonly name: string; readonly offset: number; readonly written: string; readonly unit: string };
+
+export type UnitGap = { readonly value: Measured; readonly unit: string };
+
+/** The lexicons that name units. */
+export const UNIT_LEXICONS = ["value-unit", "measure-unit", "percent-unit", "currency-code"] as const;
+
+const CURRENCY = new Set(["$", "¥", "€", "£"]);
+const SIGN = new Set(["-", "−"]);
+const MULTIPLIER = new Set(["万", "億", "千"]);
+const NUMBER = /^\d[\d,]*(?:\.\d+)?/u;
+/** What may follow a number as its unit: a short run with no digit, space or separator ("1.2.3" and "2026-10-14" are not values). */
+const UNIT_SHAPE = /^[^\d\s.,:|()[\]-]{1,8}$/u;
+
+/** A label names something in words: 10:30 is a time, not the label "10". */
+const HAS_LETTER = /\p{L}/u;
+const LIST_MARKER = /^\s*(?:[-*+]|\d+[.)])\s+/u;
+const COLON = /[:：]/u;
+const MAX_LABEL = 20;
+
+const isUnit = (word: string, units: ReadonlySet<string>): boolean => units.has(word) || units.has(word.toLowerCase());
+
+const withoutFirst = (text: string, marks: ReadonlySet<string>): string => (marks.has(text.charAt(0)) ? text.slice(1).trimStart() : text);
+
+/**
+ * The unit of a lone number, signed or not, with a currency mark before it or a unit after it (¥300, 1,200円, -3kg, 45%,
+ * 3 kg): the mark or the unit, "" when the number is bare, undefined when the text is not one number. Read after NFKC, so
+ * full-width digits count. A word after the number is a unit only if a unit lexicon lists it: "3 fixed" is not a value.
+ */
+export const unitOf = (text: string, units: ReadonlySet<string>): string | undefined => {
+  const value = text.normalize("NFKC").trim();
+  const currency = CURRENCY.has(value.charAt(0)) ? value.charAt(0) : "";
+  const unsigned = withoutFirst(value.slice(currency.length).trimStart(), SIGN);
+  const number = NUMBER.exec(unsigned)?.[0];
+  if (number === undefined) return undefined;
+  const suffix = withoutFirst(unsigned.slice(number.length).trimStart(), MULTIPLIER);
+  if (suffix === "") return currency;
+  return currency === "" && UNIT_SHAPE.test(suffix) && isUnit(suffix, units) ? suffix : undefined;
+};
+
+const measured = (kind: string, name: string, text: string, offset: number, units: ReadonlySet<string>): Measured[] => {
+  const written = text.trim();
+  const unit = unitOf(written, units);
+  return unit === undefined ? [] : [{ kind, name, offset: offset + Math.max(0, text.indexOf(written)), written, unit }];
+};
+
+type LabelLine = { readonly label: string; readonly value: string; readonly at: number };
+
+/** A line that names a field and gives its value (「予算：300万円」 "**Budget:** $300"), list marker and bold allowed. */
+export const labelLine = (line: string, start: number): LabelLine | undefined => {
+  const marker = LIST_MARKER.exec(line)?.[0].length ?? 0;
+  const body = line.slice(marker);
+  const colon = body.search(COLON);
+  if (colon <= 0) return undefined;
+  const label = body.slice(0, colon).replaceAll("**", "").trim();
+  const rest = body.slice(colon + 1).replace(/^\*\*/u, "");
+  const value = rest.trim();
+  if (label.length > MAX_LABEL || label.includes("|") || !HAS_LETTER.test(label) || value === "") return undefined;
+  return { label, value, at: start + marker + (body.length - rest.length) + rest.indexOf(value) };
+};
+
+const cellText = (source: string, cell: MarkdownNode | undefined): { readonly text: string; readonly start: number } | undefined => {
+  const span = cell === undefined ? undefined : spanOf(cell);
+  if (span === undefined) return undefined;
+  const raw = source.slice(span.start, span.end);
+  const lead = raw.search(/[^|\s]/u);
+  return lead === -1 ? undefined : { text: raw.slice(lead).replace(/\|\s*$/u, ""), start: span.start + lead };
+};
+
+const tableValues = (source: string, table: MarkdownNode, index: number, units: ReadonlySet<string>): Measured[] => {
+  const [header, ...body] = table.children ?? [];
+  return (header?.children ?? []).flatMap((headCell, column) => {
+    const name = cellText(source, headCell)?.text.trim() ?? "";
+    return body.flatMap((row) => {
+      const cell = cellText(source, row.children?.[column]);
+      return cell === undefined || name === "" ? [] : measured(`table ${String(index)}: ${name}`, name, cell.text, cell.start, units);
+    });
+  });
+};
+
+const tablesOf = (source: string): MarkdownNode[] => {
+  const found: MarkdownNode[] = [];
+  eachPreOrder(readMarkdown(source).root, (node) => {
+    if (node.type === "table") found.push(node);
+  });
+  return found;
+};
+
+/** The lines of a text with where each starts. */
+const linesWithStarts = (text: string): { readonly line: string; readonly start: number }[] =>
+  text.split("\n").reduce<{ readonly line: string; readonly start: number }[]>((lines, line) => {
+    const last = lines.at(-1);
+    return [...lines, { line, start: last === undefined ? 0 : last.start + last.line.length + 1 }];
+  }, []);
+
+/** The label lines of the prose (code masked), keyed by the label as written, so one label is one kind across the document. */
+const labelValues = (prose: string, units: ReadonlySet<string>): Measured[] =>
+  linesWithStarts(prose).flatMap(({ line, start }) => {
+    const found = labelLine(line, start);
+    return found === undefined ? [] : measured(`label: ${found.label}`, found.label, found.value, found.at, units);
+  });
+
+/** Every number a table cell or label line gives, by kind. */
+export const measuredValues = (source: string, prose: string, units: ReadonlySet<string>): Measured[] => [
+  ...tablesOf(source).flatMap((table, index) => tableValues(source, table, index, units)),
+  ...labelValues(prose, units),
+];
+
+/** Bare values must be fewer than those with the unit, so at least two carry it before a bare one reads as missing it. */
+const gapsOfKind = (values: readonly Measured[]): UnitGap[] => {
+  const withUnit = values.filter((value) => value.unit !== "");
+  const bare = values.filter((value) => value.unit === "");
+  const units = new Set(withUnit.map((value) => value.unit));
+  const unit = [...units][0];
+  if (unit === undefined || units.size !== 1 || bare.length >= withUnit.length) return [];
+  return bare.map((value) => ({ value, unit }));
+};
+
+/** Bare numbers among values of one kind that otherwise all carry one unit, in document order. */
+export const unitGaps = (values: readonly Measured[]): UnitGap[] => {
+  const kinds = values.reduce((groups, value) => groups.set(value.kind, [...(groups.get(value.kind) ?? []), value]), new Map<string, Measured[]>());
+  return [...kinds.values()].flatMap(gapsOfKind).toSorted((left, right) => left.value.offset - right.value.offset);
+};
+
+const unitsOf = (doc: ProseDocument): Set<string> =>
+  new Set(UNIT_LEXICONS.flatMap((name) => (doc.lexicons[name] ?? []).flatMap((entry) => [entry.pattern, entry.pattern.toLowerCase()])));
+
+export const numberWithoutUnit: Detector = (doc: ProseDocument): Finding[] =>
+  unitGaps(measuredValues(doc.source, doc.prose ?? doc.source, unitsOf(doc))).map((gap) => ({
+    rule: "number-without-unit",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, gap.value.offset),
+    values: { value: gap.value.written, name: gap.value.name, unit: gap.unit, offset: gap.value.offset },
+  }));