chaffjs 0.17.0 → 0.19.0

package/src/detectors/list-sentence.ts

@@ -0,0 +1,198 @@
+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）、
+ * region は地名のあとに読点を挟んで添える州や国の名（New London, Wisconsin）。
+ */
+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"]);
+
+export const isListConjunction = (token: Token | undefined): boolean => LIST_CONJUNCTION.has(token?.surface.toLowerCase() ?? "");
+
+/** 並列はこれをまたがない。セミコロンの前後は別の節。 */
+const CLAUSE_BREAK = new Set([";", ":", "—"]);
+
+/** 各 token の前で閉じていない括弧の数。括弧の中の読点（external users (e.g., guests), and ...）は外の並列を切らない。 */
+const PAREN_STEP: ReadonlyMap<string, number> = new Map([
+  ["(", 1],
+  [")", -1],
+]);
+
+export const depthsOf = (tokens: readonly Token[]): number[] => {
+  let open = 0;
+  return tokens.map((token) => {
+    const before = open;
+    open = Math.max(0, open + (PAREN_STEP.get(token.surface) ?? 0));
+    return before;
+  });
+};
+
+/** 冠詞や引用符を飛ばした、項目の頭の品詞。the parser と an exporter と samples を同じ形と見る。 */
+export const NOMINAL = new Set(["NOUN", "PRON", "PROPN", "NUM", "ADJ"]);
+export const VERBAL = new Set(["VERB", "AUX"]);
+const NOUN_PHRASE_TAIL = new Set(["ADJ", "NOUN", "PROPN"]);
+export const APPOSITIVE_ANCHOR = new Set(["NOUN", "PROPN"]);
+
+export const isContent = (token: Token): boolean => token.pos !== "DET" && token.pos !== "PUNCT" && token.pos !== "X";
+
+const isOpen = (token: Token): boolean => token.pos !== "PUNCT" && token.pos !== "X";
+
+/** -ing 形（VerbForm=Ger）と過去分詞（Part）。filling the gaps と sentenced to prison は並べても並列にならない。 */
+const VERB_FORMS = new Set(["Ger", "Part"]);
+
+export const verbFormOf = (token: Token): string | undefined => {
+  const form = token.features?.["VerbForm"];
+  return form !== undefined && VERB_FORMS.has(form) ? form : undefined;
+};
+
+/** 同じ深さにある語の位置を、深さごとに左から。 */
+const byDepth = (depths: readonly number[], test: (index: number) => boolean): ReadonlyMap<number, readonly number[]> =>
+  depths.reduce((found, depth, index) => {
+    if (!test(index)) return found;
+    const list = found.get(depth);
+    if (list === undefined) found.set(depth, [index]);
+    else list.push(index);
+    return found;
+  }, new Map<number, number[]>());
+
+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);
+  const of = (test: (token: Token) => boolean): Column => columnOf(tokens, test, commaDepth);
+  return {
+    content: of(isContent),
+    open: of(isOpen),
+    verbal: of((token) => VERBAL.has(token.pos)),
+    adposition: of((token) => token.pos === "ADP"),
+    determiner: of((token) => token.pos === "DET"),
+    conjunction: of((token) => LIST_CONJUNCTION.has(token.surface.toLowerCase())),
+    gerund: of((token) => verbFormOf(token) === "Ger"),
+    participle: of((token) => verbFormOf(token) === "Part"),
+    nounPhraseTail: of((token) => NOUN_PHRASE_TAIL.has(token.pos)),
+    noun: of((token) => APPOSITIVE_ANCHOR.has(token.pos)),
+    contentNotAdverb: of((token) => isContent(token) && token.pos !== "ADV"),
+    notPunctuationOrAdverb: of((token) => token.pos !== "PUNCT" && token.pos !== "ADV"),
+    notComma: columnOf(tokens, (token) => !isComma(token)),
+    itemEnd: columnOf(tokens, (token) => isComma(token) || CLAUSE_BREAK.has(token.surface)),
+    clauseBreak: columnOf(tokens, (token) => CLAUSE_BREAK.has(token.surface)),
+  };
+};
+
+export type Columns = ReturnType<typeof columnsOf>;
+
+/** 文を一度だけ読んで作る、項目の問いに答えるための表。 */
+export type ListSentence = {
+  readonly tokens: readonly Token[];
+  readonly depths: readonly number[];
+  readonly words: ListWords;
+  readonly column: Columns;
+  /** 各位置から始まる例の句の、最後の語の位置。語彙表の順に。 */
+  readonly exampleEnds: readonly (readonly number[])[];
+  /** 例の句の始まる位置。深さごとに。 */
+  readonly exampleStarts: ReadonlyMap<number, readonly number[]>;
+  /** 2 つだけを結ぶ語の位置。組む接続詞ごと、深さごとに。 */
+  readonly pairOpeners: ReadonlyMap<string, ReadonlyMap<number, readonly number[]>>;
+  /** 読点の位置。深さごとに。 */
+  readonly commas: ReadonlyMap<number, readonly number[]>;
+  readonly inCitedTitle: (at: number) => boolean;
+};
+
+/**
+ * start から例の句の語を読んだときの、最後の語の位置。無ければ -1。項目は同じ深さの読点を持たないので、start と同じ深さの読点は
+ * 飛ばす。続いた読点は同じ深さなので、まとめて飛ぶ。
+ */
+const phraseEnd = (tokens: readonly Token[], depths: readonly number[], notComma: Column, start: number, words: readonly Token[]): number =>
+  words.reduce((at, word, offset) => {
+    if (at === -1) return -1;
+    const next = offset === 0 ? start : at + 1;
+    const kept = tokens[next]?.surface === "," && depths[next] === depths[start] ? (notComma.next[next] ?? tokens.length) : next;
+    return tokens[kept]?.surface === word.surface ? kept : -1;
+  }, start);
+
+const exampleEndsOf = (tokens: readonly Token[], depths: readonly number[], column: Columns, example: Lexicon): number[][] =>
+  tokens.map((token, start) =>
+    token.surface === ","
+      ? []
+      : example.flatMap(({ tokens: words = [] }) => {
+          const end = words.length > 0 ? phraseEnd(tokens, depths, column.notComma, start, words) : -1;
+          return end === -1 ? [] : [end];
+        }),
+  );
+
+const pairOpenersOf = (tokens: readonly Token[], depths: readonly number[], pair: ReadonlySet<string>): Map<string, ReadonlyMap<number, readonly number[]>> =>
+  new Map(
+    [...LIST_CONJUNCTION].map((conjunction) => [
+      conjunction,
+      byDepth(depths, (index) => tokens[index]?.surface !== "," && pair.has(`${tokens[index]?.surface.toLowerCase() ?? ""} ${conjunction}`)),
+    ]),
+  );
+
+/**
+ * 1 つの and / or の深さから見た文。その深さの読点は項目の区切りで、項目の中には無い。ほかの深さの読点（括弧の中）は項目の語。
+ */
+export type ItemScope = { readonly sentence: ListSentence; readonly level: number };
+
+export const scopeOf = (sentence: ListSentence, level: number): ItemScope => ({ sentence, level });
+
+export const listSentenceOf = (tokens: readonly Token[], words: ListWords, source: string): ListSentence => {
+  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,
+    words,
+    column,
+    exampleEnds,
+    exampleStarts: byDepth(depths, (index) => (exampleEnds[index]?.length ?? 0) > 0),
+    pairOpeners: pairOpenersOf(tokens, depths, words.pair),
+    commas: byDepth(depths, (index) => tokens[index]?.surface === "," && !regionCommas.has(index)),
+    inCitedTitle: citedTitles(tokens, source),
+  };
+};

package/src/detectors/list-view.ts

@@ -0,0 +1,157 @@
+import { hasContent, shapeOf } from "./list-item.ts";
+import { FLAG_TESTS, type Flag, type ItemList } from "./list-items.ts";
+import { lowerBound, type TokenRange } from "./token-column.ts";
+
+// 並びを切り直したもの。並びの頭を外す、途中の項目のあとから読む、中身の無い項目を除く、の 3 つだけで作れるので、
+// 「先頭に置いた項目（pre）+ 並びの from 番目から後ろ（contentOnly なら中身のある項目だけ）」で表す。項目の配列は作らない。
+
+export type View = { readonly list: ItemList; readonly pre: TokenRange | undefined; readonly from: number; readonly contentOnly: boolean };
+
+/** 並びの中の項目。j は並びの中の位置で、pre は -1。 */
+export type Member = { readonly item: TokenRange; readonly j: number };
+
+export const wholeList = (list: ItemList): View => ({ list, pre: undefined, from: 0, contentOnly: false });
+
+const frozenCount = (list: ItemList): number => list.frozen.items.length;
+
+const listCount = (list: ItemList): number => frozenCount(list) + list.tail.length;
+
+const itemAt = (list: ItemList, j: number): TokenRange | undefined => (j < frozenCount(list) ? list.frozen.items[j] : list.tail[j - frozenCount(list)]);
+
+const contentAt = (list: ItemList, j: number): boolean => {
+  const item = itemAt(list, j);
+  if (j < frozenCount(list)) return list.frozen.content[j] ?? false;
+  return item !== undefined && hasContent(list.scope, item);
+};
+
+const kept = (view: View, j: number): boolean => !view.contentOnly || contentAt(view.list, j);
+
+const flagAt = (list: ItemList, j: number, flag: Flag): boolean => {
+  const item = itemAt(list, j);
+  if (j < frozenCount(list)) return list.frozen.flags[flag][j] ?? false;
+  return item !== undefined && FLAG_TESTS[flag](list.scope, item);
+};
+
+const tailPositions = (list: ItemList, from: number): number[] => list.tail.map((__item, offset) => frozenCount(list) + offset).filter((j) => j >= from);
+
+const member = (list: ItemList, j: number): Member | undefined => {
+  const item = j === -1 ? undefined : itemAt(list, j);
+  return item === undefined ? undefined : { item, j };
+};
+
+/** from 以後の、閉じた項目の最初の位置。無ければ -1。 */
+const firstFrozenFrom = (view: View, from: number): number => {
+  const { frozen } = view.list;
+  if (view.contentOnly) return frozen.contentAt[lowerBound(frozen.contentAt, from)] ?? -1;
+  return from < frozen.items.length ? from : -1;
+};
+
+/** from 以後の最初の項目の位置。無ければ -1。 */
+const firstFrom = (view: View, from: number): number => {
+  const frozen = firstFrozenFrom(view, from);
+  if (frozen !== -1) return frozen;
+  return tailPositions(view.list, from).find((j) => kept(view, j)) ?? -1;
+};
+
+/** before より前の、view.from 以後の最後の項目の位置。無ければ -1。 */
+const lastBefore = (view: View, before: number): number => {
+  const { list } = view;
+  const fromTail = tailPositions(list, view.from)
+    .filter((j) => j < before && kept(view, j))
+    .at(-1);
+  if (fromTail !== undefined) return fromTail;
+  const end = Math.min(before, frozenCount(list));
+  const frozen = view.contentOnly ? (list.frozen.contentAt[lowerBound(list.frozen.contentAt, end) - 1] ?? -1) : end - 1;
+  return frozen >= view.from ? frozen : -1;
+};
+
+const preMember = (view: View): Member | undefined => (view.pre === undefined ? undefined : { item: view.pre, j: -1 });
+
+export const firstOf = (view: View): Member | undefined => preMember(view) ?? member(view.list, firstFrom(view, view.from));
+
+export const secondOf = (view: View): Member | undefined => {
+  const first = view.pre === undefined ? firstFrom(view, view.from) : view.from - 1;
+  return first === -1 ? undefined : member(view.list, firstFrom(view, first + 1));
+};
+
+export const lastOf = (view: View): Member | undefined => member(view.list, lastBefore(view, listCount(view.list))) ?? preMember(view);
+
+export const secondLastOf = (view: View): Member | undefined => {
+  const last = lastBefore(view, listCount(view.list));
+  if (last === -1) return undefined;
+  return member(view.list, lastBefore(view, last)) ?? preMember(view);
+};
+
+export const sizeOf = (view: View): number => {
+  const { list } = view;
+  const frozen = view.contentOnly ? list.frozen.contentAt.length - lowerBound(list.frozen.contentAt, view.from) : Math.max(0, frozenCount(list) - view.from);
+  const tail = tailPositions(list, view.from).filter((j) => kept(view, j)).length;
+  return (view.pre === undefined ? 0 : 1) + frozen + tail;
+};
+
+/** 先頭の項目を外す。 */
+export const withoutFirst = (view: View): View => {
+  if (view.pre !== undefined) return { ...view, pre: undefined };
+  const first = firstFrom(view, view.from);
+  return { ...view, from: first === -1 ? listCount(view.list) : first + 1 };
+};
+
+/** その項目より後ろ。 */
+export const after = (view: View, at: Member): View => ({ ...view, pre: undefined, from: at.j === -1 ? view.from : at.j + 1 });
+
+/** 先頭に項目を置いた、中身のある項目だけの並び。 */
+export const contentOnlyWith = (view: View, pre: TokenRange | undefined): View => ({
+  ...view,
+  pre: pre !== undefined && hasContent(view.list.scope, pre) ? pre : undefined,
+  contentOnly: true,
+});
+
+const holdsFor = (view: View, flag: Flag, item: TokenRange): boolean => FLAG_TESTS[flag](view.list.scope, item);
+
+/** 問いが真になる最後の項目。 */
+export const findLast = (view: View, flag: Flag): Member | undefined => {
+  const { list } = view;
+  const fromTail = tailPositions(list, view.from)
+    .filter((j) => kept(view, j) && flagAt(list, j, flag))
+    .at(-1);
+  if (fromTail !== undefined) return member(list, fromTail);
+  const frozen = (view.contentOnly ? list.frozen.trueWithContentAt : list.frozen.trueAt)[flag].at(-1) ?? -1;
+  if (frozen >= view.from) return member(list, frozen);
+  return view.pre !== undefined && holdsFor(view, flag, view.pre) ? preMember(view) : undefined;
+};
+
+/** 2 番目以後で、問いが真になる最初の項目。 */
+export const findAfterFirst = (view: View, flag: Flag): Member | undefined => {
+  const { list } = view;
+  const first = view.pre === undefined ? firstFrom(view, view.from) : view.from - 1;
+  if (first === -1) return undefined;
+  const found = view.contentOnly ? list.frozen.trueWithContentAt[flag] : list.frozen.trueAt[flag];
+  const frozen = found[lowerBound(found, first + 1)];
+  if (frozen !== undefined) return member(list, frozen);
+  return member(list, tailPositions(list, first + 1).find((j) => kept(view, j) && flagAt(list, j, flag)) ?? -1);
+};
+
+export const some = (view: View, flag: Flag): boolean => findLast(view, flag) !== undefined;
+
+export const every = (view: View, flag: Flag): boolean => {
+  const { list } = view;
+  if (view.pre !== undefined && !holdsFor(view, flag, view.pre)) return false;
+  if ((view.contentOnly ? list.frozen.lastFalseWithContent : list.frozen.lastFalse)[flag] >= view.from) return false;
+  return tailPositions(list, view.from).every((j) => !kept(view, j) || flagAt(list, j, flag));
+};
+
+/** 中身のある項目の頭の形が、1 種類以下か。 */
+export const sameShapes = (view: View): boolean => {
+  const { list } = view;
+  const { frozen } = list;
+  const lastFrozen = frozen.contentAt.at(-1) ?? -1;
+  if (lastFrozen >= view.from && frozen.lastShapeChange >= view.from) return false;
+  const shapes = new Set([
+    ...(view.pre === undefined || !hasContent(list.scope, view.pre) ? [] : [shapeOf(list.scope, view.pre)]),
+    ...(lastFrozen >= view.from ? [frozen.shapes[lastFrozen]] : []),
+    ...tailPositions(list, view.from)
+      .filter((j) => contentAt(list, j))
+      .map((j) => shapeOf(list.scope, itemAt(list, j) ?? { start: 0, end: 0 })),
+  ]);
+  return shapes.size <= 1;
+};

package/src/detectors/long-vowel.ts

@@ -0,0 +1,82 @@
+import type { Detector, Finding, OptionValue, ProseDocument, Sentence } from "../plugin.ts";
+import { isKatakanaWord, oddLongVowels, stemOf, type Ending, type KanaWord } from "../long-vowel.ts";
+import { nameSpans, touchesAny } from "../team-names.ts";
+
+const ENDINGS: readonly Ending[] = ["consistent", "drop", "keep"];
+
+const endingOf = (value: OptionValue | undefined): Ending => ENDINGS.find((ending) => ending === value) ?? "consistent";
+
+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;
+
+/** 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())));
+
+/**
+ * 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);
+
+/**
+ * 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[] => {
+  const named = nameSpans(sentence.text, names);
+  return (sentence.tokens ?? [])
+    .filter((token) => token.pos === "NOUN" && isKatakanaWord(token.surface) && !exempt.has(stemOf(token.surface)))
+    .filter((token) => !touchesAny(named, token.span.start - sentence.span.start, token.span.end - sentence.span.start))
+    .map((token) => ({
+      surface: token.surface,
+      offset: token.span.start,
+      long: token.surface.endsWith("ー"),
+      dropped: token.features?.["LongVowelEnding"] === "Dropped",
+    }));
+};
+
+const quoteAt = (doc: ProseDocument, offset: number): string =>
+  doc.sentences.find((sentence) => sentence.span.start <= offset && offset < sentence.span.end)?.text.trim() ?? "";
+
+/**
+ * The final ー of katakana loanwords (コンピューター / コンピュータ). With no setting, it takes no side: it points at a word written
+ * both ways, and at the way the document writes less. Set to drop or keep, it points at every word the other way.
+ */
+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"]), ...distinctWordsOf(doc)]);
+  const words = doc.sentences.flatMap((sentence) => kanaWordsOf(sentence, doc.names ?? [], exempt));
+  const odd = oddLongVowels(words, endingOf(settings["ending"]), minMorae, dropAfterOf(doc));
+  if (odd.length === 0 || odd.length < options.limit) return [];
+  return odd.map((entry) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc, entry.word.offset),
+    variant: entry.variant,
+    values: {
+      matched: entry.word.surface,
+      preferred: entry.preferred,
+      count: entry.count,
+      of: entry.of,
+      min_morae: minMorae,
+      limit: options.limit,
+      offset: entry.word.offset,
+    },
+  }));
+};

package/src/detectors/markup-finding.ts

@@ -0,0 +1,39 @@
+import type { Finding, Markup, MarkupHeading, ProseDocument, Span } from "../plugin.ts";
+import { hasTitle } from "../heading-title.ts";
+
+// 記法の rule（見出し・画像・リンク・URL）が指摘を作る形。
+
+/** 引いて見せる記法の長さの上限。長い URL をまるごと見せても、どこが悪いかは伝わらない。 */
+const QUOTE_LIMIT = 80;
+
+export const quoteOf = (source: string, span: Span): string => {
+  const written = source.slice(span.start, span.end).replace(/\s+/gu, " ").trim();
+  return written.length > QUOTE_LIMIT ? `${written.slice(0, QUOTE_LIMIT)}…` : written;
+};
+
+export const findingAt = (doc: ProseDocument, span: Span, values: Readonly<Record<string, string | number>>, variant?: string): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: quoteOf(doc.source, span),
+  values: { ...values, offset: span.start },
+  ...(variant === undefined ? {} : { variant }),
+});
+
+/** 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/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";
+
+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 },
+  }));
+};

package/src/detectors/name-numeral.ts

@@ -1,14 +1,16 @@
+import { romanRangeOf } from "./roman-numeral.ts";
+
 /**
  * 大文字で始まる語のすぐ後ろの、I・V・X だけで書いたローマ数字（Engineer II、Leopold III、World War II）。名前に付く
  * 番号で、略語ではない。語の前に文字が無ければ（文の頭、箇条書きの番号の後ろ）、大文字は名前の印ではなく文頭の書き方なので
  * 外さない（Start IV fluids、1. Give IV fluids）。
- * CD、MD、DC、CI、MIX のように C・D・L・M を含む数字は略語であることが多いので、この位置でも略語のまま数える。
+ * 範囲（Reactions II-VI）も同じ。CD、MD、DC、CI、MIX のように C・D・L・M を含む数字は略語であることが多いので、この位置でも略語のまま数える。
  */
 
 type Span = { readonly start: number; readonly end: number };
 
 const SMALL_NUMERAL = "(?=[IVX])X{0,3}(?:IX|IV|V?I{0,3})";
-const NAMED_NUMERAL = new RegExp(String.raw`(?<![\p{L}\p{N}_])\p{Lu}\p{Ll}+\s+(?<numeral>${SMALL_NUMERAL})(?![\p{L}\p{N}_&])`, "gu");
+const NAMED_NUMERAL = new RegExp(String.raw`(?<![\p{L}\p{N}_])\p{Lu}\p{Ll}+\s+(?<numeral>${romanRangeOf(SMALL_NUMERAL)})(?![\p{L}\p{N}_&])`, "gu");
 const LETTER = /\p{L}/u;
 
 /** 文の中の、名前の後ろの番号の範囲（数字だけ）。 */

package/src/detectors/name-variant.ts

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

package/src/detectors/nominalization.ts

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