chaffjs 0.18.0 → 0.20.0

package/src/detectors/known-correction.ts

@@ -0,0 +1,89 @@
+import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
+import { entryRanges } from "./lexicon-match.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { correctionIn, editBetween, type Correction, type Edit } from "../correction-edit.ts";
+
+/** 語彙表の一組。pattern が誤った形、instead_of が正しい形。 */
+type Pair = { readonly entry: LexiconEntry; readonly wrong: string; readonly edit: Edit };
+
+/** 見つけた誤り 1 つ。offset は文書の上の位置。 */
+type Hit = { readonly sentence: Sentence; readonly offset: number; readonly correction: Correction };
+
+const pairsOf = (entries: readonly LexiconEntry[]): Pair[] =>
+  entries.flatMap((entry) =>
+    entry.instead_of === undefined || entry.pattern === "" ? [] : [{ entry, wrong: entry.pattern, edit: editBetween(entry.pattern, entry.instead_of) }],
+  );
+
+const LATIN_EDGE = /[A-Za-z0-9]/u;
+
+/** 英字の語は語の途中に当てない（"teh" は "Tehran" の中に無い）。かなと漢字は字で語の切れ目を決められないので、品詞が無ければ字の並びで照らす。 */
+const wordPattern = (wrong: string): RegExp => {
+  const before = LATIN_EDGE.test(wrong.charAt(0)) ? "(?<![\\p{L}\\p{N}])" : "";
+  const after = LATIN_EDGE.test(wrong.charAt(wrong.length - 1)) ? "(?![\\p{L}\\p{N}])" : "";
+  return new RegExp(`${before}${escapeRegExp(wrong)}${after}`, "giu");
+};
+
+const hitAt = (sentence: Sentence, start: number, correction: Correction | undefined): Hit[] =>
+  correction === undefined ? [] : [{ sentence, offset: start, correction }];
+
+/** 品詞が無い文。字の並びで、英字の語の切れ目を守って照らす。指すのは当たった字全体。 */
+const textHits = (sentence: Sentence, pair: Pair): Hit[] =>
+  [...sentence.text.matchAll(wordPattern(pair.wrong))].flatMap((match) =>
+    hitAt(sentence, sentence.span.start + match.index, correctionIn(match[0], pair.wrong, pair.edit, [match[0].length])),
+  );
+
+/** 品詞のある文。語の並びで照らすので、語の途中には当たらない（「ですすべて」の「ですす」）。指すのは違う所を含む語まで。 */
+const tokenHits = (sentence: Sentence, pair: Pair, source: string): Hit[] => {
+  const tokens = sentence.tokens ?? [];
+  return entryRanges(sentence, pair.entry).flatMap((range) => {
+    const words = tokens.slice(range.start, range.end);
+    const start = words[0]?.span.start ?? 0;
+    const written = source.slice(start, words.at(-1)?.span.end ?? start);
+    const boundaries = words.map((word) => word.span.end - start);
+    return written === "" ? [] : hitAt(sentence, start, correctionIn(written, pair.wrong, pair.edit, boundaries));
+  });
+};
+
+/** 字の並びで当たった所のうち、両端が文の語の切れ目にあるもの。語彙表の語を解析器が文の中と違う切り方にした（「ますす」）ときの拾い直し。 */
+const alignedTextHits = (sentence: Sentence, pair: Pair): Hit[] => {
+  const tokens = sentence.tokens ?? [];
+  const starts = new Set(tokens.map((token) => token.span.start));
+  const ends = new Set(tokens.map((token) => token.span.end));
+  return textHits(sentence, pair).filter((hit) => starts.has(hit.offset) && ends.has(hit.offset + pair.wrong.length));
+};
+
+const hitsIn = (sentence: Sentence, pair: Pair, source: string): Hit[] => {
+  if (sentence.tokens === undefined || (pair.entry.tokens?.length ?? 0) === 0) return textHits(sentence, pair);
+  return [...tokenHits(sentence, pair, source), ...alignedTextHits(sentence, pair)];
+};
+
+/** チームが names に並べた名前の中の字（「黒ひげ危機一発」の「危機一発」）は、その字のまま正しい。 */
+const isInTeamName = (doc: ProseDocument, hit: Hit): boolean =>
+  (doc.names ?? []).some((name) =>
+    [...hit.sentence.text.matchAll(new RegExp(escapeRegExp(name), "giu"))].some((match) => {
+      const start = hit.sentence.span.start + match.index;
+      return start <= hit.offset && hit.offset + hit.correction.matched.length <= start + match[0].length;
+    }),
+  );
+
+/** 一つの所に二つの組が当たったら、語彙表で先に書いた組だけ。 */
+const firstAtEachOffset = (hits: readonly Hit[]): Hit[] => hits.filter((hit, at) => hits.findIndex((other) => other.offset === hit.offset) === at);
+
+/**
+ * 誤りと正しい形の組の語彙表（pattern が誤り、instead_of が正しい形）。文書の中で誤った形を見つけ、正しい形を添えて言う。
+ * どの組を誤りとするかは語彙表が決め、detector は語の切れ目と大文字と、組のどこが違うかだけを扱う。
+ */
+export const knownCorrection: Detector = (doc, options): Finding[] => {
+  const pairs = pairsOf(options.lexicon ?? []);
+  const hits = doc.sentences.flatMap((sentence) => pairs.flatMap((pair) => hitsIn(sentence, pair, doc.source)));
+  return firstAtEachOffset(hits.toSorted((left, right) => left.offset - right.offset))
+    .filter((hit) => !isInTeamName(doc, hit))
+    .map((hit) => ({
+      rule: "",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: hit.sentence.text.trim(),
+      values: { matched: hit.correction.matched, suggestion: hit.correction.suggestion, offset: hit.offset },
+    }));
+};

package/src/detectors/kutoten-consistency.ts

@@ -1,5 +1,5 @@
 import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
-import { minorityStyle } from "../orthography.ts";
+import { minorityOf } from "../orthography.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 
 /** 日本語の読点と句点の、二つの書き方。「、。」と、横書きの論文や公用文に多い「，．」。どちらが正しいかは決めない。 */
@@ -86,7 +86,7 @@ export const kutotenConsistency: Detector = (doc, options): Finding[] => {
     .flatMap((sentence) => marksIn(sentence).map((entry) => ({ sentence, entry })));
   return KINDS.flatMap((kind) => {
     const ofKind = located.filter(({ entry }) => entry.kind === kind.id);
-    const minority = minorityStyle(ofKind.map(({ entry }) => ({ spaced: entry.western })));
+    const minority = minorityOf(ofKind.map(({ entry }) => entry.western));
     if (minority === undefined) return [];
     const odd = ofKind.filter(({ entry }) => entry.western === minority);
     if (odd.length < options.limit) return [];

package/src/detectors/lexicon-match.ts

@@ -1,6 +1,6 @@
 import type { LexiconEntry, Sentence, Token } from "../plugin.ts";
 import { proseText } from "../measure.ts";
-import { straightApostrophes } from "../orthography.ts";
+import { escapeRegExp, straightApostrophes } from "../orthography.ts";
 
 /** 活用する品詞。"best" を "good" と同じ語にはしない。 */
 const INFLECTING = new Set(["VERB", "AUX"]);
@@ -49,6 +49,26 @@ export const entryRanges = (sentence: Sentence, entry: LexiconEntry): TokenRange
   return tokens.flatMap((_token, start) => (runsAt(tokens, words, start) ? [{ start, end: start + words.length }] : []));
 };
 
+const endsInText = (text: string, word: string): number[] =>
+  word === "" ? [] : [...text.matchAll(new RegExp(escapeRegExp(word), "gu"))].map((match) => match.index + word.length);
+
+/**
+ * 語彙の語が文の中で終わる位置（文の中の字の位置）。出現ごとに一つ。終わりの位置で数えると、重なる二つの語
+ * （「させていただく」と「せていただく」）が同じ一回の出現を二度数えない。品詞が無ければ、空白をまとめた文字列の上の位置。
+ */
+export const entryEnds = (sentence: Sentence, entry: LexiconEntry): number[] => {
+  const tokens = sentence.tokens;
+  const words = entry.tokens;
+  if (tokens === undefined || words === undefined || words.length === 0) return endsInText(comparableText(sentence), comparableWords(entry.pattern));
+  return entryRanges(sentence, entry).map((range) => tokens[range.end - 1]?.span.end ?? range.end);
+};
+
+/** 語彙の語が、文の end 番目の語のちょうど手前で終わるか（「SES との最大」の「との」）。品詞が無ければ位置を言えないので当たらない。 */
+export const entryEndsAt = (tokens: readonly Token[], entry: LexiconEntry, end: number): boolean => {
+  const words = entry.tokens;
+  return words !== undefined && words.length > 0 && end >= words.length && runsAt(tokens, words, end - words.length);
+};
+
 const LEADING_MARK = new Set(["PUNCT", "SYM"]);
 
 /** 語彙の語で文が始まるか。文頭の記号は飛ばす。品詞が無ければ文字列の前方一致。 */
@@ -59,3 +79,15 @@ export const entryOpens = (sentence: Sentence, entry: LexiconEntry): boolean =>
   const first = tokens.findIndex((token) => !LEADING_MARK.has(token.pos));
   return runsAt(tokens, words, first);
 };
+
+/** Marks and closing brackets that may follow the last word of a sentence (こと。」, must.). */
+const TRAILING_MARKS = new Set(" \t\n。．.!！?？」』)）\"'”’");
+
+const withoutTrailingMarks = (text: string): string => {
+  const chars = [...text];
+  return chars.slice(0, chars.findLastIndex((char) => !TRAILING_MARKS.has(char)) + 1).join("");
+};
+
+/** Whether the sentence ends with the lexicon's word, past its closing marks (「…できること。」 ends with こと). */
+export const entryCloses = (sentence: Sentence, entry: LexiconEntry): boolean =>
+  withoutTrailingMarks(comparableText(sentence)).endsWith(comparableWords(entry.pattern));

package/src/detectors/lexicon.ts

@@ -8,6 +8,7 @@ import { namesQuantity } from "./superlative-name.ts";
 import { namesAmount } from "./superlative-amount.ts";
 import { restricted, type Restrictors } from "./superlative-clause.ts";
 import { stackedHedges, type StackedHedge } from "./stacked-hedge.ts";
+import { comparisonMarkersOf, counterpartBefore, onlyQuoted, quotedRange, type ComparisonMarkers } from "./superlative-comparison.ts";
 
 const PER = 1000;
 
@@ -19,30 +20,55 @@ type Hit = { readonly sentence: Sentence; readonly matched: string };
 const hitsFor = (doc: ProseDocument, lexicon: Lexicon): Hit[] =>
   doc.sentences.flatMap((sentence) => lexicon.filter((entry) => entryIn(sentence, entry)).map((entry) => ({ sentence, matched: entry.pattern })));
 
+/**
+ * 床より短い文書の扱い。skip は測らない。at-floor は SHORT_LENGTH の長さの文書として測り、一つだけなら言わない（一つは礼儀）。
+ * クッション言葉はメールや手紙のような短い文書に重なるので at-floor。逃げの表現は短い文書でも一文に重ねた形で見つかるので skip。
+ */
+type ShortDocuments = "skip" | "at-floor";
+
+/** 短い文書を測るときの長さ。どちらの言語でも、既定の水準で三つ目から言う長さ（二つは「お忙しいところ恐れ入りますが」のように普通に重なる）。 */
+const SHORT_LENGTH = { word: 400, char: 500 };
+
+/** 短い文書でも、これより少なければ言わない。 */
+const SHORT_MINIMUM_HITS = 2;
+
+const perThousand = (count: number, length: number): number => (length === 0 ? 0 : Math.round((count / length) * PER));
+
 /**
  * 単位長あたりの出現率。件数で数えると長い文書ほど当たる（bold-density と同じ）。
- * rule の id は呼び出し側が持つ。detector は「密度が閾値を超えたか」しか知らない。
+ * 短すぎて測らない文書、1 つも無いとき、閾値に収まるときは undefined。
  */
+export const rateOver = (doc: ProseDocument, count: number, limit: number): number | undefined => {
+  const length = wordsOf(doc);
+  const rate = perThousand(count, length);
+  return length < FLOOR[doc.lengthUnit] || count === 0 || rate <= limit ? undefined : rate;
+};
+
+/** rule の id は呼び出し側が持つ。detector は「密度が閾値を超えたか」しか知らない。指摘が言う密度は、短い文書でも文書の実際の長さでの値。 */
 const densityRule =
-  (rule: string): Detector =>
+  (rule: string, short: ShortDocuments = "skip"): Detector =>
   (doc, options): Finding[] => {
     const hits = hitsFor(doc, options.lexicon ?? []);
     const length = wordsOf(doc);
-    const rate = length === 0 ? 0 : Math.round((hits.length / length) * PER);
-    const first = hits[0];
-    if (length < FLOOR[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
+    const isShort = length < FLOOR[doc.lengthUnit];
+    if (hits.length === 0 || (isShort && (short === "skip" || hits.length < SHORT_MINIMUM_HITS))) return [];
+    if (perThousand(hits.length, isShort ? SHORT_LENGTH[doc.lengthUnit] : length) <= options.limit) return [];
+    const density = perThousand(hits.length, length);
     return hits.map((hit) => ({
       rule,
       severity: "warning",
       line: 0,
       column: 0,
       quote: hit.sentence.text.trim(),
-      values: { matched: hit.matched, count: hits.length, density: rate, limit: options.limit, offset: hit.sentence.span.start },
+      values: { matched: hit.matched, count: hits.length, density, limit: options.limit, offset: hit.sentence.span.start },
     }));
   };
 
 const hedgingDensity = densityRule("excessive-hedging");
-export const cushionDensity = densityRule("cushion-phrase-density");
+export const cushionDensity = densityRule("cushion-phrase-density", "at-floor");
+/** 語彙表の語の密度だけを見る rule が共通で使う。rule の id は実行側が入れる。 */
+export const phraseDensity = densityRule("");
+export const vagueDensity = densityRule("vague-word-density");
 
 /** 書いたとおりの字。行の折り返しをまたいでいたら空白 1 つに。 */
 const writtenAt = (source: string, span: Span): string => source.slice(span.start, span.end).replace(/\s+/gu, " ").trim();
@@ -83,7 +109,7 @@ export const hedging: Detector = (doc, options): Finding[] => {
 const DIGIT = /\d/u;
 
 type Qualifiers = {
-  readonly comparison: Lexicon;
+  readonly comparison: ComparisonMarkers;
   readonly scope: ScopeMarkers;
   readonly quantityNouns: Lexicon;
   readonly amounts: Lexicon;
@@ -91,7 +117,7 @@ type Qualifiers = {
 };
 
 const qualifiersOf = (doc: ProseDocument): Qualifiers => ({
-  comparison: doc.lexicons["comparison-marker"] ?? [],
+  comparison: comparisonMarkersOf(doc.lexicons["comparison-marker"] ?? []),
   scope: scopeMarkersOf(doc.lexicons["superlative-scope"] ?? []),
   quantityNouns: doc.lexicons["quantity-noun"] ?? [],
   amounts: doc.lexicons["superlative-amount"] ?? [],
@@ -102,22 +128,26 @@ const qualifiersOf = (doc: ProseDocument): Qualifiers => ({
   },
 });
 
-/** 範囲・節・分詞・形容詞のどれかが最上級を限っているか、最上級が量か名前を言っているか。 */
+/** 範囲・節・分詞・形容詞・すぐ前の相手のどれかが最上級を限っているか、最上級が量か名前を言っているか。 */
 const qualifiedAt = (tokens: readonly Token[], range: TokenRange, qualifiers: Qualifiers): boolean =>
+  counterpartBefore(tokens, range, qualifiers.comparison.before) ||
   scoped(tokens, range, qualifiers.scope) ||
   restricted(tokens, range, qualifiers.restrictors) ||
   namesQuantity(tokens, range, qualifiers.quantityNouns) ||
   namesAmount(tokens, range, qualifiers.amounts);
 
-/** どの出現も限られているか量を言うときだけ。1 つでもそうでない出現があれば、その文には限定の無い最上級がある。 */
+/** どの出現も引いた言葉か、限られているか、量を言うときだけ。1 つでもそうでない出現があれば、その文には限定の無い最上級がある。 */
 const everyQualified = (sentence: Sentence, entry: LexiconEntry, qualifiers: Qualifiers): boolean => {
   const tokens = sentence.tokens ?? [];
   const ranges = entryRanges(sentence, entry);
-  return ranges.length > 0 && ranges.every((range) => qualifiedAt(tokens, range, qualifiers));
+  return ranges.length > 0 && ranges.every((range) => quotedRange(sentence, range) || qualifiedAt(tokens, range, qualifiers));
 };
 
 const qualified = (sentence: Sentence, entry: LexiconEntry, qualifiers: Qualifiers): boolean =>
-  DIGIT.test(sentence.text) || qualifiers.comparison.some((marker) => entryIn(sentence, marker)) || everyQualified(sentence, entry, qualifiers);
+  DIGIT.test(sentence.text) ||
+  onlyQuoted(sentence, entry) ||
+  qualifiers.comparison.anywhere.some((marker) => entryIn(sentence, marker)) ||
+  everyQualified(sentence, entry, qualifiers);
 
 const bareHits = (doc: ProseDocument, lexicon: Lexicon): Hit[] => {
   const qualifiers = qualifiersOf(doc);

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/list-sentence.ts

@@ -1,12 +1,18 @@
-import type { Lexicon, Token } from "../plugin.ts";
+import type { Lexicon, LexiconEntry, Token } from "../plugin.ts";
 import { citedTitles } from "./cited-title.ts";
 import { columnOf, type Column } from "./token-column.ts";
 
 /**
  * 並びを読むための語彙表。participle は解析器が分詞と読まないが読点のあとで分詞の句を始める語（meaning）、
- * example は例を挙げる句（such as, e.g.）、pair は 2 つだけを結ぶ語とその接続詞（between and / either or）。
+ * example は例を挙げる句（such as, e.g.）、pair は 2 つだけを結ぶ語とその接続詞（between and / either or）、
+ * region は地名のあとに読点を挟んで添える州や国の名（New London, Wisconsin）。
  */
-export type ListWords = { readonly participle: ReadonlySet<string>; readonly example: Lexicon; readonly pair: ReadonlySet<string> };
+export type ListWords = {
+  readonly participle: ReadonlySet<string>;
+  readonly example: Lexicon;
+  readonly pair: ReadonlySet<string>;
+  readonly region: Lexicon;
+};
 
 const LIST_CONJUNCTION: ReadonlySet<string> = new Set(["and", "or"]);
 
@@ -60,6 +66,40 @@ const byDepth = (depths: readonly number[], test: (index: number) => boolean): R
 
 const isComma = (token: Token): boolean => token.surface === ",";
 
+const surfacesOf = ({ pattern, tokens: words = [] }: LexiconEntry): string[] => (words.length > 0 ? words.map((word) => word.surface) : pattern.split(" "));
+
+const writtenAt = (tokens: readonly Token[], start: number, entry: LexiconEntry): boolean =>
+  surfacesOf(entry).every((surface, offset) => tokens[start + offset]?.surface === surface);
+
+/** start から書いてある州や国の名。語ごとに書いたとおりに照らす。 */
+const regionAt = (tokens: readonly Token[], start: number, regions: Lexicon): LexiconEntry | undefined =>
+  regions.find((entry) => writtenAt(tokens, start, entry));
+
+/** 名の後ろが文や句の切れ目（, . ; : ) か文の終わり）。New London, Wisconsin, and … の Wisconsin。 */
+const closesName = (token: Token | undefined): boolean => token === undefined || [",", ".", ";", ":", ")"].includes(token.surface);
+
+/** at の直前が州や国の名で終わる（Texas, Florida, … の Texas）。名の長さの分だけ前から照らす。 */
+const endsWithRegion = (tokens: readonly Token[], at: number, regions: Lexicon): boolean =>
+  regions.some((entry) => {
+    const start = at - surfacesOf(entry).length;
+    return start >= 0 && writtenAt(tokens, start, entry);
+  });
+
+/**
+ * 地名と、それに添えた州や国の名のあいだの読点（New London, Wisconsin, and a photo / Lyon, France, then）。並びの区切りではない。
+ * 前が固有名詞で、それ自身が州や国の名でなく（Texas, Florida, and Ohio は州の並び）、後ろの名が切れ目で閉じるときだけ。
+ * 地名の後ろにしか書かない名（position: after。Washington, D.C.）は、前が州の名でも地名に添えたもの。
+ */
+const regionCommasOf = (tokens: readonly Token[], regions: Lexicon): ReadonlySet<number> =>
+  new Set(
+    tokens.flatMap((token, at) => {
+      if (!isComma(token) || tokens[at - 1]?.pos !== "PROPN") return [];
+      const region = regionAt(tokens, at + 1, regions);
+      if (region === undefined || !closesName(tokens[at + 1 + surfacesOf(region).length])) return [];
+      return region.position === "after" || !endsWithRegion(tokens, at, regions) ? [at] : [];
+    }),
+  );
+
 /** 項目への問いの列。読点は項目に入ったり入らなかったりするので、脇に置いて問いごとに数える（token-column.ts）。 */
 const columnsOf = (tokens: readonly Token[], depths: readonly number[]) => {
   const commaDepth = (token: Token, index: number): number | undefined => (isComma(token) ? depths[index] : undefined);
@@ -143,6 +183,7 @@ export const listSentenceOf = (tokens: readonly Token[], words: ListWords, sourc
   const depths = depthsOf(tokens);
   const column = columnsOf(tokens, depths);
   const exampleEnds = exampleEndsOf(tokens, depths, column, words.example);
+  const regionCommas = regionCommasOf(tokens, words.region);
   return {
     tokens,
     depths,
@@ -151,7 +192,7 @@ export const listSentenceOf = (tokens: readonly Token[], words: ListWords, sourc
     exampleEnds,
     exampleStarts: byDepth(depths, (index) => (exampleEnds[index]?.length ?? 0) > 0),
     pairOpeners: pairOpenersOf(tokens, depths, words.pair),
-    commas: byDepth(depths, (index) => tokens[index]?.surface === ","),
+    commas: byDepth(depths, (index) => tokens[index]?.surface === "," && !regionCommas.has(index)),
     inCitedTitle: citedTitles(tokens, source),
   };
 };

package/src/detectors/long-vowel.ts

@@ -9,17 +9,33 @@ const endingOf = (value: OptionValue | undefined): Ending => ENDINGS.find((endin
 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: three morae, as the guidelines that drop the ー count it. */
-const DEFAULT_MIN_MORAE = 3;
+/** The minimum when no setting gives one: two morae before the final ー, which leaves カー alone. */
+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.
+ */
+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
+ * JIS Z 8301:2011 G.6.2.2). Without the list, drop reaches every final ー.
+ */
+const dropAfterOf = (doc: ProseDocument): ReadonlySet<string> | undefined => {
+  const kana = doc.lexicons["long-vowel-drop-after"];
+  return kana === undefined ? undefined : new Set(kana.map((entry) => entry.pattern));
+};
 
 /**
  * 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)))
@@ -42,9 +58,9 @@ const quoteAt = (doc: ProseDocument, offset: number): string =>
 export const katakanaLongVowel: Detector = (doc, options): Finding[] => {
   const settings = options.settings ?? {};
   const minMorae = typeof settings["min_morae"] === "number" ? settings["min_morae"] : DEFAULT_MIN_MORAE;
-  const exempt = exemptStems(wordsOf(settings["except"]));
+  const exempt = exemptStems([...wordsOf(settings["except"]), ...distinctWordsOf(doc)]);
   const words = doc.sentences.flatMap((sentence) => kanaWordsOf(sentence, doc.names ?? [], exempt));
-  const odd = oddLongVowels(words, endingOf(settings["ending"]), minMorae);
+  const odd = oddLongVowels(words, endingOf(settings["ending"]), minMorae, dropAfterOf(doc));
   if (odd.length === 0 || odd.length < options.limit) return [];
   return odd.map((entry) => ({
     rule: "",

package/src/detectors/markup-finding.ts

@@ -1,4 +1,5 @@
-import type { Finding, Markup, ProseDocument, Span } from "../plugin.ts";
+import type { Finding, Markup, MarkupHeading, ProseDocument, Span } from "../plugin.ts";
+import { hasTitle } from "../heading-title.ts";
 
 // 記法の rule（見出し・画像・リンク・URL）が指摘を作る形。
 
@@ -22,3 +23,17 @@ export const findingAt = (doc: ProseDocument, span: Span, values: Readonly<Recor
 
 /** Markdown の文書の記法。Markdown でなければ undefined。 */
 export const markupOf = (doc: ProseDocument): Markup | undefined => (doc.markup?.markdown === true ? doc.markup : undefined);
+
+/** 文の終わりの句点。下線で書く見出し（setext）の言葉がこれで終わるなら、区切り線の上の文。 */
+const SENTENCE_END = /[.。!?！？]$/u;
+
+/**
+ * 下線で書く見出し（setext）のうち、区切り線（メールの「-----」）の上の段落を Markdown が見出しと読んだもの。
+ * 二行以上にわたるか、句点で終わる。書き手は見出しを立てていない。
+ */
+const isUnderlinedParagraph = (source: string, heading: MarkupHeading): boolean =>
+  !source.startsWith("#", heading.start) && (heading.text.includes("\n") || SENTENCE_END.test(heading.text));
+
+/** 見出しとして書いた見出し。題の無い見出し（`## ---`）と、区切り線の上の段落は外す。 */
+export const writtenHeadings = (doc: ProseDocument): MarkupHeading[] =>
+  (markupOf(doc)?.headings ?? []).filter((heading) => hasTitle(heading.text) && !isUnderlinedParagraph(doc.source, heading));

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

@@ -0,0 +1,26 @@
+import type { Detector, Finding, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { modalConflicts, modalStatements, type Obligation } from "../structure/modal-conflict.ts";
+import { linesOf, lineNumberAt } from "../structure/lines.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+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"] ?? "") }]
+      : [],
+  );
+
+/** 同じ主語と行為に、前の文と逆の様相（しなければならない と してはならない、may と must not）を書いた文。 */
+export const modalConflict: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const lines = linesOf(doc.source);
+  return modalConflicts(modalStatements(obligationsOf(doc.structure), doc.sentences)).map(({ statement, earlier }) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, statement.offset),
+    values: { marker: statement.marker, other: earlier.marker, otherLine: lineNumberAt(lines, earlier.offset) ?? 0, offset: statement.offset },
+  }));
+};