chaffjs 0.19.0 → 0.21.0

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 },
+  }));

package/src/detectors/orthographic-variant.ts

@@ -0,0 +1,152 @@
+import type { Detector, Finding, ProseDocument, Sentence, Token } from "../plugin.ts";
+import { groupBy, oddSpellings, type KeyedWord, type OddSpelling } from "../spelling-variants.ts";
+import { kanjiSkeleton, katakanaKey, lemmaReading } from "../kana-spelling.ts";
+import { isKatakanaWord, stemOf } from "../long-vowel.ts";
+import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
+import { nameSpans, touchesAny } from "../team-names.ts";
+
+/** A word found in the document: where it is, which sentence it is in, its key and spelling, and how it is written when that differs. */
+type Placed = KeyedWord & { readonly sentence: Sentence; readonly offset: number; readonly shown?: string };
+
+type IsOpen = (start: number, end: number) => boolean;
+
+/** Parts of speech that carry a word of their own. Particles and endings are written one way by the grammar. */
+const CONTENT = new Set(["NOUN", "VERB", "ADJ", "ADV", "PRON", "CCONJ", "DET"]);
+const JAPANESE_WORD = /^[\p{Script=Han}々ぁ-ゖァ-ヺー]+$/u;
+/** A one-mora reading (木 and き, 気) is too short to say two spellings are one word. */
+const MIN_READING = 2;
+/** A katakana key shorter than this meets other words (ビル and ビール). */
+const MIN_KATAKANA_KEY = 4;
+const MIN_LATIN_KEY = 3;
+
+/** Lexicons: readings and spellings whose kanji and kana forms mean different things (成る and なる, 者 and もの), and adverbs hiragana-fukushi reads. */
+const DISTINCT = "orthographic-variant-distinct";
+const FUKUSHI = "hiragana-fukushi";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+/** Whether a stretch of the sentence is outside a quotation and outside the team's names, both of which keep their own spelling. */
+const isOpenIn = (sentence: Sentence, names: readonly string[]): IsOpen => {
+  const quoted = quotedSpans(sentence.text, QUOTATION_MARKS);
+  const named = nameSpans(sentence.text, names);
+  return (start, end) => !isWithinAny(quoted, { start, end }) && !touchesAny(named, start, end);
+};
+
+const isHelper = (token: Token, previous: Token | undefined): boolean =>
+  token.features?.["Bound"] === "Yes" || (previous?.pos === "SCONJ" && (previous.surface === "て" || previous.surface === "で"));
+
+/**
+ * A helper verb or a dependent noun (見て下さい, その事) is written kana by many guides while the full word keeps its kanji (資料を下さい).
+ * The two uses are compared apart, so a document that follows that convention is consistent. A suffix (業務用) is a third use:
+ * it is not the dependent noun of the same reading (このように).
+ */
+const useOf = (token: Token, previous: Token | undefined): string => {
+  if (!isHelper(token, previous)) return "free";
+  return token.pos === "NOUN" && token.features?.["NounType"] !== "Dependent" ? "suffix" : "bound";
+};
+
+const readingKeyOf = (token: Token, previous: Token | undefined, skip: ReadonlySet<string>): string | undefined => {
+  const lemma = token.lemma;
+  if (!CONTENT.has(token.pos) || token.reading === undefined || lemma === undefined || !JAPANESE_WORD.test(lemma) || skip.has(lemma)) return undefined;
+  const reading = lemmaReading(token.surface, lemma, token.reading);
+  if (reading === undefined || [...reading].length < MIN_READING || skip.has(reading)) return undefined;
+  return `${token.pos}|${useOf(token, previous)}|${reading}`;
+};
+
+/** Japanese words keyed by part of speech, use and the reading of the dictionary form, spelled as the dictionary form. */
+const readingWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] => {
+  const tokens = sentence.tokens ?? [];
+  return tokens.flatMap((token, at): Placed[] => {
+    const key = readingKeyOf(token, tokens[at - 1], skip);
+    const local = token.span.start - sentence.span.start;
+    if (key === undefined || token.lemma === undefined || !isOpen(local, local + token.surface.length)) return [];
+    return [{ key, spelling: token.lemma, sentence, offset: token.span.start }];
+  });
+};
+
+/**
+ * Same reading is not yet same word: 書く and 描く are both カク. Spellings meet only when they keep the same kanji (引っ越し, 引越し)
+ * or one is all kana. A kana spelling joins the kanji one only when the reading has a single kanji spelling in the document;
+ * with two (橋 and 箸 beside はし) it cannot say which, and is left out.
+ */
+const byKanji = (words: readonly Placed[]): Placed[] =>
+  [...groupBy(words, (word) => word.key).values()].flatMap((group) => {
+    const skeletons = [...new Set(group.map((word) => kanjiSkeleton(word.spelling)).filter((skeleton) => skeleton !== ""))];
+    return group.flatMap((word): Placed[] => {
+      const own = kanjiSkeleton(word.spelling);
+      if (own === "" && skeletons.length > 1) return [];
+      return [{ ...word, key: `${word.key}|${own === "" ? (skeletons[0] ?? "") : own}` }];
+    });
+  });
+
+/** Katakana nouns keyed with small kana and ー evened out, spelled without the final ー that katakana-long-vowel reads. */
+const katakanaWords = (sentence: Sentence, isOpen: IsOpen): Placed[] =>
+  (sentence.tokens ?? []).flatMap((token): Placed[] => {
+    const local = token.span.start - sentence.span.start;
+    if (token.pos !== "NOUN" || !isKatakanaWord(token.surface) || !isOpen(local, local + token.surface.length)) return [];
+    const key = katakanaKey(token.surface);
+    return [...key].length < MIN_KATAKANA_KEY ? [] : [{ key: `kana|${key}`, spelling: stemOf(token.surface), sentence, offset: token.span.start }];
+  });
+
+const LATIN_WORD = /[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*/gu;
+const LOWER = /\p{Ll}/u;
+
+/**
+ * The case of the first letter of each part is left out of the spelling: a sentence, a title or a name gives it (Email and email,
+ * Long-Term and long-term), the writer does not. Capitals after it are the spelling (GitHub and Github).
+ */
+const latinSpelling = (word: string): string =>
+  word
+    .split("-")
+    .map((part) => part.charAt(0).toLowerCase() + part.slice(1))
+    .join("-");
+
+/** A word joined to a dot, an at sign or a slash is part of an address or a file name (github.com, user@example), spelled as it must be. */
+const ADDRESS_NEIGHBOUR = /[.@/\\_]/u;
+
+const isPartOfAddress = (text: string, start: number, end: number): boolean =>
+  ADDRESS_NEIGHBOUR.test(text.charAt(start - 1)) || (ADDRESS_NEIGHBOUR.test(text.charAt(end)) && /\w/u.test(text.charAt(end + 1)));
+
+/**
+ * Latin words keyed without hyphens and case (e-mail and email, GitHub and Github). A word in capitals only (TEAMS, MAY) is
+ * emphasis or an acronym, not a spelling of the word, and is left out.
+ */
+const latinWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] =>
+  [...sentence.text.matchAll(LATIN_WORD)].flatMap((match): Placed[] => {
+    const word = match[0];
+    const plain = word.toLowerCase().replaceAll("-", "");
+    const end = match.index + word.length;
+    if (plain.length < MIN_LATIN_KEY || !LOWER.test(word) || skip.has(word.toLowerCase())) return [];
+    if (isPartOfAddress(sentence.text, match.index, end) || !isOpen(match.index, end)) return [];
+    return [{ key: `latin|${plain}`, spelling: latinSpelling(word), shown: word, sentence, offset: sentence.span.start + match.index }];
+  });
+
+/** How the usual spelling is written where it first appears (gitHub is shown GitHub). */
+const shownUsual = (words: readonly Placed[], { word, usual }: OddSpelling<Placed>): string =>
+  words.find((other) => other.key === word.key && other.spelling === usual)?.shown ?? usual;
+
+const findingOf = (words: readonly Placed[], odd: OddSpelling<Placed>): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: odd.word.sentence.text.trim(),
+  values: { written: odd.word.shown ?? odd.word.spelling, other: shownUsual(words, odd), count: odd.count, of: odd.of, offset: odd.word.offset },
+});
+
+/**
+ * One word written two ways in one document (出来る and できる, 引っ越し and 引越し, ウィンドウ and ウインドウ, e-mail and email),
+ * found without a list of words: the document's own words are grouped by reading or by an evened-out spelling, and the way the
+ * document writes less is pointed at. No way is called right; limit is the largest share, in percent, the minority may have.
+ */
+export const orthographicVariant: Detector = (doc, options): Finding[] => {
+  const skip = new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]);
+  const placed = doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, doc.names ?? []) }));
+  const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skip)));
+  const katakana = placed.flatMap(({ sentence, isOpen }) => katakanaWords(sentence, isOpen));
+  const latin = placed.flatMap(({ sentence, isOpen }) => latinWords(sentence, isOpen, skip));
+  const odd = [reading, katakana, latin].flatMap((words) => oddSpellings(words, options.limit));
+  const all = [...reading, ...katakana, ...latin];
+  // A word can be odd by its reading and by its katakana key at once; one place is said once.
+  return [...new Map(odd.map((entry) => [entry.word.offset, entry])).values()].map((entry) => findingOf(all, entry));
+};

package/src/detectors/paragraph-restatement.ts

@@ -0,0 +1,68 @@
+// A paragraph that announces a restatement (つまり, このように, In other words) and then mostly repeats the paragraph
+// before it. Pure; measured in content morphemes by base form, the way heading-echo measures a heading. The announcing
+// words come from the language's restating-opener lexicon.
+import { newContentMorphemes } from "./content-morphemes.ts";
+import type { Detector, Finding, Paragraph, ProseDocument, Token } from "../plugin.ts";
+
+/** A paragraph with fewer content words than this says too little to measure. */
+const MIN_CONTENT_WORDS = 4;
+
+const PERCENT = 100;
+
+/** What may follow the opener: a comma, a space or the end; in Japanese also the next word straight away (つまり実行時に). */
+const AFTER_OPENER = /^(?:$|[\s、，,:：]|[^\p{Script=Latin}])/u;
+
+/** The opener a paragraph starts with, as written, or undefined. Case is folded; the longest opener wins. */
+export const openerOf = (text: string, openers: readonly string[]): string | undefined => {
+  const trimmed = text.trimStart();
+  const folded = trimmed.toLowerCase();
+  const found = openers
+    .filter((opener) => folded.startsWith(opener.toLowerCase()) && AFTER_OPENER.test(trimmed.slice(opener.length)))
+    .toSorted((left, right) => right.length - left.length)[0];
+  return found === undefined ? undefined : trimmed.slice(0, found.length);
+};
+
+/** The share of the later tokens' content words, in percent, that the earlier tokens already hold (by base form). */
+export const repeatedShare = (earlier: readonly Token[], later: readonly Token[]): { readonly share: number; readonly words: number } => {
+  const words = newContentMorphemes([], later);
+  if (words === 0) return { share: 0, words };
+  return { share: Math.round(((words - newContentMorphemes(earlier, later)) / words) * PERCENT), words };
+};
+
+const tokensOf = (paragraph: Paragraph): Token[] => paragraph.sentences.flatMap((sentence) => sentence.tokens ?? []);
+
+/** The paragraph's tokens past its opener: the opener itself is not what the paragraph says. */
+const tokensAfterOpener = (paragraph: Paragraph, opener: string): Token[] => {
+  const [first, ...rest] = paragraph.sentences;
+  if (first === undefined) return [];
+  const openerEnd = first.text.length - first.text.trimStart().length + opener.length;
+  return [...(first.tokens ?? []).filter((token) => token.span.end > openerEnd), ...rest.flatMap((sentence) => sentence.tokens ?? [])];
+};
+
+/** Two paragraphs with only blank lines between: no heading, list, table or code separates them. */
+const isNextTo = (doc: ProseDocument, earlier: Paragraph, later: Paragraph): boolean => doc.source.slice(earlier.span.end, later.span.start).trim() === "";
+
+const findingOf = (paragraph: Paragraph, opener: string, share: number, limit: number): Finding => {
+  const first = paragraph.sentences[0];
+  const lead = first === undefined ? 0 : first.text.length - first.text.trimStart().length;
+  return {
+    rule: "paragraph-restatement",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: first?.text.trim() ?? "",
+    values: { opener, share, limit, offset: (first?.span.start ?? paragraph.span.start) + lead },
+  };
+};
+
+/** Each paragraph that opens with a restating word and repeats at least limit percent of the previous paragraph's words. */
+export const paragraphRestatement: Detector = (doc, options): Finding[] => {
+  const openers = (doc.lexicons["restating-opener"] ?? []).map((entry) => entry.pattern);
+  return doc.paragraphs.flatMap((later, index): Finding[] => {
+    const earlier = doc.paragraphs[index - 1];
+    const opener = openerOf(later.sentences[0]?.text ?? "", openers);
+    if (earlier === undefined || opener === undefined || !isNextTo(doc, earlier, later)) return [];
+    const { share, words } = repeatedShare(tokensOf(earlier), tokensAfterOpener(later, opener));
+    return words >= MIN_CONTENT_WORDS && share >= options.limit ? [findingOf(later, opener, share, options.limit)] : [];
+  });
+};

package/src/detectors/paragraph-run.ts

@@ -0,0 +1,27 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { oneSentenceRuns } from "../paragraph-runs.ts";
+
+/** How much of the run's first paragraph the finding quotes. */
+const QUOTE_LENGTH = 80;
+
+/**
+ * Runs of one-sentence paragraphs longer than the limit: every sentence set apart as its own paragraph, so nothing is grouped
+ * and the reader cannot see which points belong together. One finding per run, at its first paragraph.
+ */
+export const oneSentenceParagraphRun: Detector = (doc, options): Finding[] =>
+  oneSentenceRuns(doc.source, doc.paragraphs)
+    .filter((run) => run.length > options.limit)
+    .flatMap((run) => {
+      const first = run[0];
+      if (first === undefined) return [];
+      return [
+        {
+          rule: "",
+          severity: "info",
+          line: 0,
+          column: 0,
+          quote: doc.source.slice(first.span.start, first.span.start + QUOTE_LENGTH).trim(),
+          values: { count: run.length, limit: options.limit, offset: first.span.start },
+        },
+      ];
+    });

package/src/detectors/person-consistency.ts

@@ -0,0 +1,29 @@
+import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+import { personMentions, personMinorities, type PersonMention, type PersonWords } from "../person-forms.ts";
+
+const wordsOf = (doc: ProseDocument, words: PersonWords["words"]): PersonWords => ({
+  words,
+  forms: doc.lexicons["person-form"] ?? [],
+  notAfter: doc.lexicons["person-not-after"] ?? [],
+});
+
+/**
+ * One document naming itself (私たち / 弊社, 私 / 筆者) or its reader (you / one) two ways: the minority form of each slot.
+ * Sentences in another language than the document's are left out; quotations are left out by personMentions.
+ */
+export const personMix: Detector = (doc, options): Finding[] => {
+  const person = wordsOf(doc, options.lexicon ?? []);
+  const entries: { readonly sentence: Sentence; readonly mention: PersonMention }[] = doc.sentences
+    .filter((sentence) => sentence.embeddedLanguage === undefined)
+    .flatMap((sentence) => personMentions(sentence.text, person).map((mention) => ({ sentence, mention })));
+  return personMinorities(entries, options.limit).flatMap(({ odd, usual, of }) =>
+    odd.map(({ sentence, mention }) => ({
+      rule: "",
+      severity: "info" as const,
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { matched: mention.written, usual, count: odd.length, of, limit: options.limit, offset: sentence.span.start + mention.at },
+    })),
+  );
+};