chaffjs 0.19.0 → 0.21.0

package/src/detectors/list-parallel.ts

@@ -0,0 +1,155 @@
+// Whether the items of one bulleted list share a form: all phrases or all sentences, all opening with a verb or all with
+// a noun. Pure; reads the item sentences' tokens. Which form is right is the writer's choice, so only the minority within
+// one list is reported. です/ます against plain endings inside a list is no-mixed-desumasu's, not this.
+import { minorityWithin } from "../orthography.ts";
+import { isQuotedAt } from "./bold-label.ts";
+import type { BulletList, Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
+
+/** What an item is made of: a phrase or a sentence (ending), and the word it opens with (head, English only). */
+export type Axis = "ending" | "head";
+
+/** For each axis, the two forms. The first is the side minorityWithin calls true. */
+export const FORMS: Readonly<Record<Axis, readonly [string, string]>> = { ending: ["phrase", "sentence"], head: ["verb", "noun"] };
+
+const SKIPPED_AT_END = new Set(["PUNCT", "SYM", "X"]);
+const NOMINAL = new Set(["NOUN", "PROPN", "NUM", "PRON"]);
+const PREDICATE = new Set(["VERB", "AUX", "ADJ"]);
+const NOUN_HEAD = new Set(["NOUN", "ADJ", "DET", "NUM", "PRON", "PROPN"]);
+const SENTENCE_END = /[.!?。．！？]["'”’)）」』]*$/u;
+const OPENING_BRACKETS = new Set(["(", "（", "[", "［", "【"]);
+const CLOSING_BRACKETS = new Set([")", "）", "]", "］", "】"]);
+
+/** A word the tagger only guessed at, or one that is also a verb (Design, Document): its form is not known. */
+const isUnsure = (token: Token | undefined): boolean => token?.features?.["Guess"] === "Yes" || token?.features?.["AlsoVerb"] === "Yes";
+
+/** A finite verb or auxiliary: an English item with one says something. A gerund or participle (Running, nested) does not. */
+const isFiniteVerb = (token: Token): boolean => (token.pos === "VERB" || token.pos === "AUX") && !["Ger", "Part"].includes(token.features?.["VerbForm"] ?? "");
+
+/** The tokens before a closing aside: 「健康診断書（3か月以内のもの）」 ends, for its form, at 健康診断書. */
+const withoutClosingAside = (tokens: readonly Token[]): readonly Token[] => {
+  const last = tokens.findLastIndex((token) => !SKIPPED_AT_END.has(token.pos) || CLOSING_BRACKETS.has(token.surface));
+  if (last === -1 || !CLOSING_BRACKETS.has(tokens[last]?.surface ?? "")) return tokens;
+  const open = tokens.findLastIndex((token, index) => index < last && OPENING_BRACKETS.has(token.surface));
+  return open <= 0 ? tokens : tokens.slice(0, open);
+};
+
+/** Japanese: a predicate at the end (出します, 済ませる, 早い) is a sentence; a noun (月末, 確認すること) is a phrase. */
+const japaneseEnding = (sentences: readonly Sentence[]): string | undefined => {
+  if (sentences.length > 1) return "sentence";
+  const last = withoutClosingAside(sentences[0]?.tokens ?? []).findLast((token) => !SKIPPED_AT_END.has(token.pos));
+  if (last === undefined) return undefined;
+  if (NOMINAL.has(last.pos)) return "phrase";
+  return PREDICATE.has(last.pos) ? "sentence" : undefined;
+};
+
+/** English: a sentence closes with a full stop and has a finite verb; a phrase has neither, nor any verb at all. Anything between is not judged. */
+const englishEnding = (sentences: readonly Sentence[]): string | undefined => {
+  const tokens = sentences.flatMap((sentence) => sentence.tokens ?? []);
+  if (tokens.length === 0) return undefined;
+  const closed = SENTENCE_END.test(sentences.at(-1)?.text.trim() ?? "");
+  if (sentences.length > 1 || (closed && tokens.some(isFiniteVerb))) return "sentence";
+  const verbless = !tokens.some((token) => token.pos === "VERB" || token.pos === "AUX");
+  return !closed && verbless && !isUnsure(tokens[0]) ? "phrase" : undefined;
+};
+
+/** English: the word an item opens with. Install and Running open with a verb; The, Fast and Docker with a noun phrase. */
+/** Small words a title leaves in lower case (Terms of Service). */
+const TITLE_SMALL_WORDS = new Set(["of", "and", "or", "the", "a", "an", "to", "for", "in", "on"]);
+
+/** Every word capitalised (Cover Letter, Terms of Service): a name or a title, whose first word is not a verb whatever its tag. */
+const isTitleCase = (text: string): boolean =>
+  text
+    .trim()
+    .split(/\s+/u)
+    .every((word) => TITLE_SMALL_WORDS.has(word) || /^\p{Lu}/u.test(word));
+
+const englishHead = (sentences: readonly Sentence[]): string | undefined => {
+  const first = (sentences[0]?.tokens ?? []).find((token) => !SKIPPED_AT_END.has(token.pos));
+  if (first === undefined || isUnsure(first) || isTitleCase(sentences[0]?.text ?? "")) return undefined;
+  // A participle (Generated files, Nested lists) modifies the noun after it; the item is a noun phrase, but the tag does not say so.
+  if (first.pos === "VERB") return first.features?.["VerbForm"] === "Part" ? undefined : "verb";
+  return NOUN_HEAD.has(first.pos) ? "noun" : undefined;
+};
+
+/** An item's form on an axis, or undefined when its words do not tell. Japanese items have no head axis (the verb comes last). */
+export const formOf = (axis: Axis, sentences: readonly Sentence[], language: string): string | undefined => {
+  if (language === "ja") return axis === "ending" ? japaneseEnding(sentences) : undefined;
+  return axis === "ending" ? englishEnding(sentences) : englishHead(sentences);
+};
+
+const within = (inner: Span, outer: Span): boolean => inner.start >= outer.start && inner.end <= outer.end;
+
+/** The item's own sentences: those in its span, less those of a list nested inside it. */
+export const itemSentences = (doc: ProseDocument, item: Span): Sentence[] => {
+  const nested = doc.lists.map((list) => list.span).filter((span) => span.start > item.start && within(span, item));
+  return doc.sentences.filter((sentence) => within(sentence.span, item) && !nested.some((span) => within(sentence.span, span)));
+};
+
+type Item = { readonly sentences: readonly Sentence[]; readonly form: string };
+
+const findingOf = (axis: Axis, item: Item, count: number, of: number, limit: number): Finding => {
+  const first = item.sentences[0];
+  return {
+    rule: "list-item-form-mix",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: first?.text.trim() ?? "",
+    values: { written: first?.text.trim() ?? "", count, of, limit, offset: first?.span.start ?? 0 },
+    variant: `${axis}-${item.form}`,
+  };
+};
+
+const AXES: readonly Axis[] = ["ending", "head"];
+
+/** An item that opens with a label and a colon (大倉さんの肌感：…, Last modified: …): a field and its value, not judged. */
+const LABELLED = /^[^:：。.]{1,40}\s*[:：]\s*\S/u;
+
+/** Code or a link in the item as written: chaff masks it out of the sentence, so the item's words are not all there. */
+const CODE_OR_LINK = /`|\]\(|\]\[|https?:\/\//u;
+
+/** An item ending like a clause of one running sentence (…conduct;, …、, …and): the list is one sentence split up. */
+const RUNNING_ON = /(?:[;,、，]|\b(?:and|or))$/iu;
+
+/** An item of one word (Resume, 例) is a name: either form would read it the same. */
+const MIN_WORDS = 2;
+
+const wordCount = (sentences: readonly Sentence[]): number =>
+  sentences.flatMap((sentence) => sentence.tokens ?? []).filter((token) => !SKIPPED_AT_END.has(token.pos)).length;
+
+const isJudged = (written: string, sentences: readonly Sentence[]): boolean => {
+  const text = sentences.map((sentence) => sentence.text).join(" ");
+  return wordCount(sentences) >= MIN_WORDS && !LABELLED.test(text.trim()) && !CODE_OR_LINK.test(written);
+};
+
+const runsOn = (sentences: readonly Sentence[]): boolean => RUNNING_ON.test(sentences.at(-1)?.text.trim() ?? "");
+
+const listFindings = (doc: ProseDocument, list: BulletList, limit: number): Finding[] => {
+  const sentencesOf = list.itemSpans.map((span) => itemSentences(doc, span));
+  if (sentencesOf.some(runsOn)) return [];
+  const judged = sentencesOf.filter((sentences, index) => {
+    const span = list.itemSpans[index];
+    return span !== undefined && isJudged(doc.source.slice(span.start, sentences.at(-1)?.span.end ?? span.end), sentences);
+  });
+  return AXES.flatMap((axis) => {
+    const items = judged.flatMap((sentences) => {
+      const form = formOf(axis, sentences, doc.language);
+      return form === undefined ? [] : [{ sentences, form }];
+    });
+    const odd = minorityWithin(items, (item) => item.form === FORMS[axis][0], limit);
+    return odd.map((item) => findingOf(axis, item, odd.length, items.length, limit));
+  });
+};
+
+/** Each list item whose form is the minority in its list, on each axis. A quoted list is someone else's words. */
+export const listItemFormMix: Detector = (doc, options): Finding[] => {
+  const findings = doc.lists.filter((list) => !isQuotedAt(doc.source, list.span.start)).flatMap((list) => listFindings(doc, list, options.limit));
+  // The same item can be read in two lists (its own and one the parser nests it in); report it once.
+  const seen = new Set<string>();
+  return findings.filter((finding) => {
+    const key = `${String(finding.values["offset"])} ${finding.variant ?? ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};

package/src/detectors/long-vowel.ts

@@ -10,17 +10,17 @@ const wordsOf = (value: OptionValue | undefined): readonly string[] =>
   Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string") : [];
 
 /** The minimum when no setting gives one: two morae before the final ー, which leaves カー alone. */
-const DEFAULT_MIN_MORAE = 2;
+export const DEFAULT_MIN_MORAE = 2;
 
 /** A listed word is exempt written either way: listing コンピューター exempts コンピュータ too. */
-const exemptStems = (except: readonly string[]): ReadonlySet<string> => new Set(except.map((word) => stemOf(word.trim())));
+export const exemptStems = (except: readonly string[]): ReadonlySet<string> => new Set(except.map((word) => stemOf(word.trim())));
 
 /**
  * Words that become another word with a final ー (フリ, as in 振り, and フリー, free): the language's long-vowel-distinct word list.
  * Both are nouns to the tagger, so only the list tells them apart; they are left out as if listed under except.
  * The list is optional: without it the rule still runs and compares every word.
  */
-const distinctWordsOf = (doc: ProseDocument): string[] => (doc.lexicons["long-vowel-distinct"] ?? []).map((entry) => entry.pattern);
+export const distinctWordsOf = (doc: ProseDocument): string[] => (doc.lexicons["long-vowel-distinct"] ?? []).map((entry) => entry.pattern);
 
 /**
  * The kana a final ー follows where drop drops it: the language's long-vowel-drop-after list (ア段, the -er, -or, -ar of
@@ -35,7 +35,7 @@ const dropAfterOf = (doc: ProseDocument): ReadonlySet<string> | undefined => {
  * The katakana nouns of a sentence, as the language adapter split them: ユーザー inside ユーザーインターフェース is its own word.
  * Proper nouns (PROPN) and the team's names keep their own spelling (ディズニー).
  */
-const kanaWordsOf = (sentence: Sentence, names: readonly string[], exempt: ReadonlySet<string>): KanaWord[] => {
+export const kanaWordsOf = (sentence: Sentence, names: readonly string[], exempt: ReadonlySet<string>): KanaWord[] => {
   const named = nameSpans(sentence.text, names);
   return (sentence.tokens ?? [])
     .filter((token) => token.pos === "NOUN" && isKatakanaWord(token.surface) && !exempt.has(stemOf(token.surface)))

package/src/detectors/mark-shape.ts

@@ -0,0 +1,202 @@
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { minorityReport } from "../spacing-minority.ts";
+import { isWithinAny, quotedSpans } from "../quoted-span.ts";
+
+/** The letters a mark must touch to count as part of the document's text, by language. */
+const SCRIPT: Readonly<Record<string, RegExp>> = {
+  ja: /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー々]/u,
+  en: /\p{Script=Latin}/u,
+};
+
+/** One way of writing a mark: its kind, which of the two ways it is (side), and how the other way writes it. */
+type Form = { readonly kind: string; readonly side: boolean; readonly other: string };
+
+/**
+ * The two ways of writing each kind of mark, from the lexicon: pattern is one way, instead_of the other, group the kind.
+ * Two patterns may share one instead_of (“ and ” both against "), so the other way of a shared mark is both patterns.
+ */
+export const formsOf = (lexicon: Lexicon): ReadonlyMap<string, Form> => {
+  const forms = new Map<string, Form>();
+  lexicon.forEach((entry) => {
+    const kind = entry.group ?? entry.pattern;
+    const shared = entry.instead_of ?? "";
+    forms.set(entry.pattern, { kind, side: true, other: shared });
+    const known = forms.get(shared);
+    forms.set(shared, { kind, side: false, other: `${known?.side === false ? known.other : ""}${entry.pattern}` });
+  });
+  return forms;
+};
+
+export type Mark = { readonly sentence: Sentence; readonly char: string; readonly form: Form; readonly offset: number; readonly spaced: boolean };
+
+/** Punctuation that may stand between a closing or opening mark and the word it belongs to ("draft." and “draft”.). */
+const BETWEEN = /[.,;:!?。、]/u;
+
+/** The letter beside a mark on one side (step -1 or 1), past one punctuation mark. */
+const besideLetter = (text: string, at: number, step: number, script: RegExp): boolean => {
+  const next = text.charAt(at + step);
+  return script.test(next) || (BETWEEN.test(next) && script.test(text.charAt(at + step * 2)));
+};
+
+const touchesScript = (text: string, at: number, script: RegExp): boolean => besideLetter(text, at, -1, script) || besideLetter(text, at, 1, script);
+
+/** The marks in a sentence that touch a letter of the document's script, outside 「」『』 quotations. spaced is the lexicon's pattern side. */
+export const marksIn = (sentence: Sentence, forms: ReadonlyMap<string, Form>, script: RegExp): Mark[] => {
+  const quoted = quotedSpans(sentence.text);
+  return sentence.text.split("").flatMap((char, at) => {
+    const form = forms.get(char);
+    if (form === undefined || !touchesScript(sentence.text, at, script)) return [];
+    if (isWithinAny(quoted, { start: at, end: at })) return [];
+    return [{ sentence, char, form, offset: sentence.span.start + at, spaced: form.side }];
+  });
+};
+
+/** Something written one of two ways (spaced is which), at a place in a sentence. */
+type Sided = { readonly sentence: Sentence; readonly offset: number; readonly spaced: boolean };
+
+const sidedFinding = (item: Sided, values: Finding["values"], variant?: string): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: item.sentence.text.trim(),
+  ...(variant === undefined ? {} : { variant }),
+  values: { ...values, offset: item.offset },
+});
+
+/** The less common way, one finding each, or one finding for a document written both ways (spacing-minority.ts). */
+const minorityFindings = <T extends Sided>(items: readonly T[], limit: number, valuesOf: (item: T) => Finding["values"]): Finding[] => {
+  const report = minorityReport(items, limit);
+  if (report === undefined) return [];
+  if (report.mode === "mixed") {
+    const { first, odd, spaced, touching } = report;
+    return [sidedFinding(first, { ...valuesOf(first), spaced, touching, count: odd, of: items.length, limit }, "mixed")];
+  }
+  return report.odd.map((item) => sidedFinding(item, { ...valuesOf(item), count: report.odd.length, of: items.length, limit }));
+};
+
+/** Sentences written in the document's own language; a quoted sentence in another language follows its own marks. */
+const ownSentences = (doc: ProseDocument): readonly Sentence[] => doc.sentences.filter((sentence) => sentence.embeddedLanguage === undefined);
+
+/**
+ * A mark written two ways in one document (（ and (, “ and "), the less common way reported. The two ways come from the
+ * lexicon; neither is called right. Only marks next to a letter of the document's script count, so a bracket in code-like
+ * text (f(x)) or an English aside in a Japanese document does not.
+ */
+export const markConsistency: Detector = (doc, options): Finding[] => {
+  const script = SCRIPT[doc.language];
+  if (script === undefined) return [];
+  const forms = formsOf(options.lexicon ?? []);
+  const marks = ownSentences(doc).flatMap((sentence) => marksIn(sentence, forms, script));
+  const kinds = [...new Set(marks.map((mark) => mark.form.kind))];
+  return kinds.flatMap((kind) =>
+    minorityFindings(
+      marks.filter((mark) => mark.form.kind === kind),
+      options.limit,
+      (mark) => ({ mark: mark.char, usual: mark.form.other }),
+    ),
+  );
+};
+
+/**
+ * A sentence that surely ends: a lower-case word of two letters or more, then the mark. A number ("11.1."), an abbreviation
+ * ("Req.", "e.g.") or a capital ("U.S.") may be a split the adapter made inside a sentence, where one space is usual.
+ */
+const SENTENCE_END = /(?<![\p{L}\d.])\p{Ll}{2,}[.!?]["'”’)\]]?$/u;
+/** The next sentence starts with a capital, past an opening quote: not a citation ("[ISO99]") or an aside in brackets. */
+const SENTENCE_START = /^["'“‘]?\p{Lu}/u;
+const ONE_SPACE = " ";
+const TWO_SPACES = "  ";
+
+/** The space between two sentences on one line, when the first ends with a period, question or exclamation mark. spaced is two spaces. */
+export const sentenceGaps = (doc: ProseDocument): Sided[] =>
+  ownSentences(doc).flatMap((sentence, at, sentences) => {
+    const next = sentences[at + 1];
+    if (next === undefined || !SENTENCE_END.test(sentence.text) || !SENTENCE_START.test(next.text)) return [];
+    const gap = doc.source.slice(sentence.span.end, next.span.start);
+    if (gap !== ONE_SPACE && gap !== TWO_SPACES) return [];
+    return [{ sentence: next, spaced: gap === TWO_SPACES, offset: sentence.span.end }];
+  });
+
+/** One space between sentences and two, mixed in one document: the less common is reported. */
+export const sentenceSpacing: Detector = (doc, options): Finding[] =>
+  minorityFindings(sentenceGaps(doc), options.limit, (gap) => ({
+    spaces: gap.spaced ? TWO_SPACES.length : ONE_SPACE.length,
+    usual: gap.spaced ? ONE_SPACE.length : TWO_SPACES.length,
+  }));
+
+type Hit = { readonly sentence: Sentence; readonly matched: string; readonly offset: number };
+
+const hitFinding = (hit: Hit, count: number, limit: number): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: hit.sentence.text.trim(),
+  values: { matched: hit.matched, count, limit, offset: hit.offset },
+});
+
+const hitsOf = (sentences: readonly Sentence[], pattern: RegExp): Hit[] =>
+  sentences.flatMap((sentence) =>
+    [...sentence.text.matchAll(pattern)].map((match) => ({ sentence, matched: match[0].trim(), offset: sentence.span.start + match.index })),
+  );
+
+const reportFrom = (hits: readonly Hit[], limit: number): Finding[] => (hits.length < limit ? [] : hits.map((hit) => hitFinding(hit, hits.length, limit)));
+
+/** A spaced hyphen or a double hyphen between words, standing for a dash ("late - very late", "late--very late"). */
+const HYPHEN_DASH = /(?<=[\p{L},;)]) -{1,2} (?=[\p{L}(])|(?<=\p{L})--(?=\p{L})/gu;
+
+export const hyphenDash: Detector = (doc, options): Finding[] => reportFrom(hitsOf(ownSentences(doc), HYPHEN_DASH), options.limit);
+
+/** Every way of writing an abbreviation with some of its periods dropped but not all (e.g. → e.g, eg.). */
+export const partialForms = (abbreviation: string): string[] => {
+  const dots = [...abbreviation].flatMap((char, at) => (char === "." ? [at] : []));
+  const subsets = Array.from({ length: 2 ** dots.length }, (_unused, mask) => dots.filter((_dot, bit) => (mask >> bit) % 2 === 1));
+  return subsets
+    .filter((dropped) => dropped.length > 0 && dropped.length < dots.length)
+    .map((dropped) => [...abbreviation].filter((_char, at) => !dropped.includes(at)).join(""));
+};
+
+/** One partial form as a pattern: its first letter in either case, not inside a word, not followed by a period or letter. */
+const partialPattern = (form: string): string =>
+  `(?<![\\p{L}.])[${form.charAt(0).toLowerCase()}${form.charAt(0).toUpperCase()}]${escapeRegExp(form.slice(1))}(?![\\p{L}.])`;
+
+/** Latin abbreviations from the lexicon (e.g., i.e.) written with only some of their periods (e.g, eg.). */
+export const latinAbbreviation: Detector = (doc, options): Finding[] => {
+  const forms = (options.lexicon ?? []).flatMap((entry) => partialForms(entry.pattern));
+  if (forms.length === 0) return [];
+  const pattern = new RegExp(forms.map(partialPattern).join("|"), "gu");
+  return reportFrom(hitsOf(ownSentences(doc), pattern), options.limit);
+};
+
+/** How many all-capital words in a row read as shouting rather than a run of acronyms. */
+const SHOUT_WORDS = 3;
+const CAPS_RUN = new RegExp(`\\b[A-Z][A-Z']*(?:,? [A-Z][A-Z']*){${String(SHOUT_WORDS - 1)},}\\b`, "gu");
+/** One-letter words (I, A) may sit in a run, but a run of them alone ("A B C") is a list of labels. */
+const MIN_LONG_WORDS = 2;
+
+const LATIN_WORD = /[A-Za-z][A-Za-z']*/gu;
+
+/** The words a source writes at least once not wholly in capitals (do, Do), in lower case: words, not acronyms. */
+export const lowerCaseWords = (source: string): ReadonlySet<string> =>
+  new Set((source.match(LATIN_WORD) ?? []).filter((word) => word !== word.toUpperCase()).map((word) => word.toLowerCase()));
+
+/**
+ * Whether more than half the words of a capital run are also written elsewhere in lower case. Words the lexicon lists as
+ * written in capitals by convention (MUST NOT in a specification) count like acronyms.
+ */
+export const isShouting = (run: string, known: ReadonlySet<string>, conventional: ReadonlySet<string>): boolean => {
+  const words = run.split(/,? /u);
+  const ordinary = words.filter((word) => !conventional.has(word) && known.has(word.toLowerCase()));
+  const long = words.filter((word) => word.length > 1);
+  return long.length >= MIN_LONG_WORDS && ordinary.length * 2 > words.length;
+};
+
+/** Runs of three or more all-capital words that are ordinary words, not acronyms ("DO NOT DELETE THIS"). */
+export const capsShouting: Detector = (doc, options): Finding[] => {
+  const known = lowerCaseWords(doc.prose ?? doc.source);
+  const conventional = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
+  const hits = hitsOf(ownSentences(doc), CAPS_RUN).filter((hit) => isShouting(hit.matched, known, conventional));
+  return reportFrom(hits, options.limit);
+};

package/src/detectors/misuse-match.ts

@@ -0,0 +1,28 @@
+import type { Detector, Finding, Lexicon, LexiconEntry, Sentence } from "../plugin.ts";
+import { entryIn } from "./lexicon-match.ts";
+
+type Misuse = { readonly sentence: Sentence; readonly entry: LexiconEntry };
+
+const misuseIn = (sentence: Sentence, lexicon: Lexicon): Misuse | undefined => {
+  const entry = lexicon.find((candidate) => entryIn(sentence, candidate));
+  return entry === undefined ? undefined : { sentence, entry };
+};
+
+const findingOf = (misuse: Misuse, limit: number): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: misuse.sentence.text.trim(),
+  values: { matched: misuse.entry.pattern, correct: misuse.entry.rewrite ?? "", limit, offset: misuse.sentence.span.start },
+});
+
+/**
+ * A phrase from a lexicon of established misuses, each entry carrying its correct form in `rewrite`. The message names
+ * both, so the writer does not have to look the right form up. One finding per sentence, for its first listed misuse.
+ */
+export const misuseMatch: Detector = (doc, options): Finding[] => {
+  const lexicon = options.lexicon ?? [];
+  const misuses = doc.sentences.flatMap((sentence) => misuseIn(sentence, lexicon) ?? []);
+  return misuses.length < options.limit ? [] : misuses.map((misuse) => findingOf(misuse, options.limit));
+};

package/src/detectors/modal-conflict.ts

@@ -4,7 +4,7 @@ import { modalConflicts, modalStatements, type Obligation } from "../structure/m
 import { linesOf, lineNumberAt } from "../structure/lines.ts";
 import { quoteAt } from "./structure-tree.ts";
 
-const obligationsOf = (tree: StructureNode): Obligation[] =>
+export const obligationsOf = (tree: StructureNode): Obligation[] =>
   inDocumentOrder(tree).flatMap((node) =>
     node.kind === "obligation"
       ? [{ start: node.span.start, end: node.span.end, type: String(node.attrs["type"] ?? ""), marker: String(node.attrs["marker"] ?? "") }]

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