chaffjs 0.17.0 → 0.19.0

package/src/detectors/kutoten-consistency.ts

@@ -0,0 +1,96 @@
+import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+import { minorityOf } from "../orthography.ts";
+import { isWithinAny, quotedSpans } from "../quoted-span.ts";
+
+/** 日本語の読点と句点の、二つの書き方。「、。」と、横書きの論文や公用文に多い「，．」。どちらが正しいかは決めない。 */
+type Kind = { readonly id: "comma" | "period"; readonly usual: string; readonly western: string };
+
+const KINDS: readonly Kind[] = [
+  { id: "comma", usual: "、", western: "，" },
+  { id: "period", usual: "。", western: "．" },
+];
+
+const MARKS = /[、，。．]/gu;
+
+const DIGIT = /[\d０-９]/u;
+
+/** 番号の印（行の頭や読点・空白・括弧の後ろの「１．」「２．」）。文の中の数の後ろの点（締切は10．）は文の終わり。 */
+const LIST_NUMBER = /(?:^|[\s、，,（(])[\d０-９]{1,3}$/u;
+const LIST_NUMBER_REACH = 4;
+
+/** 一、二文字の英字だけの印（Ｑ．、No．）。「API．」のような語の後ろの点は文の終わり。 */
+const LATIN_LABEL = /(?:^|[^A-Za-zＡ-Ｚａ-ｚ])[A-Za-zＡ-Ｚａ-ｚ]{1,2}$/u;
+const LATIN_LABEL_REACH = 3;
+
+const isInsideNumber = (text: string, at: number): boolean => DIGIT.test(text.charAt(at - 1)) && DIGIT.test(text.charAt(at + 1));
+
+const isLabelPeriod = (text: string, at: number): boolean =>
+  LIST_NUMBER.test(text.slice(Math.max(0, at - LIST_NUMBER_REACH), at)) || LATIN_LABEL.test(text.slice(Math.max(0, at - LATIN_LABEL_REACH), at));
+
+/**
+ * 句読点として数えない「，」「．」。数の中の桁の区切りと小数点（１，０００、３．５）、番号の印の点（１．はじめに、、２．確認）、
+ * 一、二文字の英字の印の後ろの点（Ｑ．、No．）は、日本語の文の区切りではない。
+ */
+const isNotPunctuation = (text: string, at: number, mark: string): boolean => {
+  if (mark === "．") return isInsideNumber(text, at) || isLabelPeriod(text, at);
+  if (mark === "，") return isInsideNumber(text, at);
+  return false;
+};
+
+export type Mark = { readonly kind: Kind["id"]; readonly western: boolean; readonly mark: string; readonly offset: number };
+
+/** 文の中の句読点。鉤括弧で引いたものの中は、引いた元の書き方なので数えない。offset は文書の中の位置。 */
+export const marksIn = (sentence: Sentence): Mark[] => {
+  const quoted: readonly Span[] = quotedSpans(sentence.text);
+  return [...sentence.text.matchAll(MARKS)]
+    .filter((match) => !isNotPunctuation(sentence.text, match.index, match[0]))
+    .filter((match) => !isWithinAny(quoted, { start: match.index, end: match.index }))
+    .map((match) => {
+      const western = match[0] === "，" || match[0] === "．";
+      const kind = match[0] === "、" || match[0] === "，" ? "comma" : "period";
+      return { kind, western, mark: match[0], offset: sentence.span.start + match.index };
+    });
+};
+
+/**
+ * 注や文献の番号と空白で始まる行（白書の「2 亀田健司，「…」，2018年」、「[1] 山田太郎，…」「注1 …」「※1 …」）。
+ * 白書や論文の注と文献は、本文と違う区切り方で書く決まりがある。
+ */
+const NOTE_NUMBER = /^(?:[\d０-９]{1,3}|[[［][\d０-９]{1,3}[\]］]|注[\d０-９]{1,3}|※[\d０-９]{0,3})[\u3000 ]/u;
+
+const URL_SCHEME = /https?:\/\//u;
+
+/** 文献や出典を挙げた文。注の番号で始まるか、URL を含む。区切りは引いた元や文献の書き方に従う。 */
+export const isCitation = (sentence: Sentence, source: string): boolean =>
+  NOTE_NUMBER.test(sentence.text.trimStart()) || URL_SCHEME.test(source.slice(sentence.span.start, sentence.span.end));
+
+type Tally = { readonly count: number; readonly of: number; readonly limit: number };
+
+const findingOf = (sentence: Sentence, entry: Mark, kind: Kind, tally: Tally): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: sentence.text.trim(),
+  values: { mark: entry.mark, usual: entry.western ? kind.usual : kind.western, ...tally, offset: entry.offset },
+  variant: entry.kind,
+});
+
+/**
+ * 読点（、と，）と句点（。と．）を、それぞれ文書の中でどちらかにそろえているか。混ざっていれば少ないほうを指摘する。
+ * latin-spacing と同じく、同数なら文書が先に使った書き方をその文書の書き方とする。
+ */
+export const kutotenConsistency: Detector = (doc, options): Finding[] => {
+  const located = doc.sentences
+    .filter((sentence) => !isCitation(sentence, doc.source))
+    .flatMap((sentence) => marksIn(sentence).map((entry) => ({ sentence, entry })));
+  return KINDS.flatMap((kind) => {
+    const ofKind = located.filter(({ entry }) => entry.kind === kind.id);
+    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 [];
+    const tally = { count: odd.length, of: ofKind.length, limit: options.limit };
+    return odd.map(({ sentence, entry }) => findingOf(sentence, entry, kind, tally));
+  });
+};

package/src/detectors/lead-in.ts

@@ -1,13 +1,15 @@
 /** 文末のコロン。後ろに強調の印（**・_）や空白が残っていても見る。 */
 const ENDS_WITH_COLON = /[:：][\s*_]*$/u;
 
+export const endsWithColon = (sentence: string): boolean => ENDS_WITH_COLON.test(sentence.trim());
+
 /**
  * 後ろの箇条書きや表へ読者を渡す文（「次のとおりとする。」「The following expenses require receipts:」）。
  * 見出しの語を繰り返していても、中身は後ろにある。言い回しは言語パッケージの語彙表 lead-in が持つ。
  */
 export const isLeadIn = (sentence: string, phrases: readonly string[]): boolean => {
   const text = sentence.trim().toLowerCase();
-  return ENDS_WITH_COLON.test(text) || phrases.some((phrase) => phrase !== "" && text.includes(phrase.toLowerCase()));
+  return endsWithColon(text) || phrases.some((phrase) => phrase !== "" && text.includes(phrase.toLowerCase()));
 };
 
 /** 渡す先（following: 同じ節の、その文より後ろ）が空なら、渡す文ではなくただの繰り返し。 */

package/src/detectors/lexicon-match.ts

@@ -1,5 +1,6 @@
 import type { LexiconEntry, Sentence, Token } from "../plugin.ts";
 import { proseText } from "../measure.ts";
+import { escapeRegExp, straightApostrophes } from "../orthography.ts";
 
 /** 活用する品詞。"best" を "good" と同じ語にはしない。 */
 const INFLECTING = new Set(["VERB", "AUX"]);
@@ -15,6 +16,12 @@ const sameWord = (written: Token, entry: Token): boolean => {
   return inflects && entry.lemma?.toLowerCase() === surface && written.lemma?.toLowerCase() === surface;
 };
 
+/** 品詞が無いときに照らす形。大文字小文字と、アポストロフィの形（it’s と it's）は語を変えない。 */
+export const comparableWords = (text: string): string => straightApostrophes(text).toLowerCase();
+
+/** 文を、品詞が無いときに照らす形に。行の折り返しの空白はまとめる。 */
+export const comparableText = (sentence: Sentence): string => comparableWords(proseText(sentence));
+
 const runsAt = (tokens: readonly Token[], entry: readonly Token[], start: number): boolean =>
   entry.every((word, offset) => {
     const written = tokens[start + offset];
@@ -28,7 +35,7 @@ const runsAt = (tokens: readonly Token[], entry: readonly Token[], start: number
 export const entryIn = (sentence: Sentence, entry: LexiconEntry): boolean => {
   const tokens = sentence.tokens;
   const words = entry.tokens;
-  if (tokens === undefined || words === undefined || words.length === 0) return proseText(sentence).toLowerCase().includes(entry.pattern.toLowerCase());
+  if (tokens === undefined || words === undefined || words.length === 0) return comparableText(sentence).includes(comparableWords(entry.pattern));
   return tokens.some((_token, start) => runsAt(tokens, words, start));
 };
 
@@ -42,13 +49,45 @@ 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"]);
 
 /** 語彙の語で文が始まるか。文頭の記号は飛ばす。品詞が無ければ文字列の前方一致。 */
 export const entryOpens = (sentence: Sentence, entry: LexiconEntry): boolean => {
   const tokens = sentence.tokens;
   const words = entry.tokens;
-  if (tokens === undefined || words === undefined || words.length === 0) return proseText(sentence).toLowerCase().startsWith(entry.pattern.toLowerCase());
+  if (tokens === undefined || words === undefined || words.length === 0) return comparableText(sentence).startsWith(comparableWords(entry.pattern));
   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,52 @@ 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");
 
 /** 書いたとおりの字。行の折り返しをまたいでいたら空白 1 つに。 */
 const writtenAt = (source: string, span: Span): string => source.slice(span.start, span.end).replace(/\s+/gu, " ").trim();
@@ -83,7 +106,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 +114,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 +125,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-item.ts

@@ -0,0 +1,122 @@
+import type { Token } from "../plugin.ts";
+import { APPOSITIVE_ANCHOR, NOMINAL, verbFormOf, type Columns, type ItemScope } from "./list-sentence.ts";
+import { countIn, firstIn, lastIn, lowerBound, type TokenRange } from "./token-column.ts";
+
+// 並びの項目への問い。項目は文の中の一続きの範囲で、and / or と同じ深さの読点を除いたもの。どの問いも範囲を読み直さず、
+// 文を一度読んで作った列（list-sentence.ts）から答える。
+
+type ColumnName = keyof Columns;
+
+const count = (scope: ItemScope, name: ColumnName, item: TokenRange): number => countIn(scope.sentence.column[name], item, scope.level);
+
+const tokenAt = (scope: ItemScope, index: number): Token | undefined => (index === -1 ? undefined : scope.sentence.tokens[index]);
+
+export const firstAt = (scope: ItemScope, name: ColumnName, item: TokenRange): number => firstIn(scope.sentence.column[name], item, scope.level);
+
+const first = (scope: ItemScope, name: ColumnName, item: TokenRange): Token | undefined => tokenAt(scope, firstAt(scope, name, item));
+
+const last = (scope: ItemScope, name: ColumnName, item: TokenRange): Token | undefined =>
+  tokenAt(scope, lastIn(scope.sentence.column[name], item, scope.level));
+
+export const hasContent = (scope: ItemScope, item: TokenRange): boolean => count(scope, "content", item) > 0;
+
+export const contentCount = (scope: ItemScope, item: TokenRange): number => count(scope, "content", item);
+
+export const firstContent = (scope: ItemScope, item: TokenRange): Token | undefined => first(scope, "content", item);
+
+export const lastContent = (scope: ItemScope, item: TokenRange): Token | undefined => last(scope, "content", item);
+
+const shapeOfHead = (head: Token | undefined): string | undefined => {
+  if (head === undefined) return undefined;
+  return NOMINAL.has(head.pos) ? "NOMINAL" : head.pos;
+};
+
+/** 冠詞や引用符を飛ばした、項目の頭の品詞。the parser と an exporter と samples を同じ形と見る。 */
+export const shapeOf = (scope: ItemScope, item: TokenRange): string | undefined => shapeOfHead(firstContent(scope, item));
+
+/** 副詞を飛ばした頭の形。explain and justify と ultimately ensure は同じ動詞の項目。 */
+export const leadShape = (scope: ItemScope, item: TokenRange): string | undefined => shapeOfHead(first(scope, "contentNotAdverb", item));
+
+export const openingOf = (scope: ItemScope, item: TokenRange): Token | undefined => first(scope, "open", item);
+
+export const isParticiple = (token: Token): boolean => token.features?.["VerbForm"] === "Part";
+
+export const openingKind = (scope: ItemScope, item: TokenRange): string | undefined => {
+  const opening = openingOf(scope, item);
+  return opening !== undefined && isParticiple(opening) ? "PARTICIPLE" : shapeOf(scope, item);
+};
+
+export const hasVerb = (scope: ItemScope, item: TokenRange): boolean => count(scope, "verbal", item) > 0;
+
+export const hasListConjunction = (scope: ItemScope, item: TokenRange): boolean => count(scope, "conjunction", item) > 0;
+
+export const hasAdposition = (scope: ItemScope, item: TokenRange): boolean => count(scope, "adposition", item) > 0;
+
+export const hasDeterminer = (scope: ItemScope, item: TokenRange): boolean => count(scope, "determiner", item) > 0;
+
+/** 主語と述語のある項目。the team fixed the bug / these are crucial。gets us more は述語だけ。頭は冠詞か名詞なので、動詞はその後ろ。 */
+export const isClause = (scope: ItemScope, item: TokenRange): boolean => {
+  const opening = openingOf(scope, item);
+  if (opening === undefined || !(opening.pos === "DET" || NOMINAL.has(opening.pos))) return false;
+  return hasVerb(scope, item);
+};
+
+/** 頭の語のあとに前置詞の句を連れた項目（updates on the Google Doc）。 */
+export const hasPrepositionalTail = (scope: ItemScope, item: TokenRange): boolean => {
+  const head = firstAt(scope, "content", item);
+  return hasAdposition(scope, { start: head === -1 ? item.start : head + 1, end: item.end });
+};
+
+/** 項目の頭の分詞とその形。副詞は飛ばす（originally written）。引用符の中の語（‘modelling’）は語の例なので分詞と読まない。 */
+export const participleOpening = (scope: ItemScope, item: TokenRange): { readonly at: number; readonly form: string } | undefined => {
+  const at = firstAt(scope, "notPunctuationOrAdverb", item);
+  const opening = tokenAt(scope, at);
+  if (opening === undefined) return undefined;
+  const form = scope.sentence.words.participle.has(opening.surface.toLowerCase()) ? "Ger" : verbFormOf(opening);
+  return form === undefined ? undefined : { at, form };
+};
+
+export const hasParticiple = (scope: ItemScope, item: TokenRange, form: string): boolean => count(scope, form === "Ger" ? "gerund" : "participle", item) > 0;
+
+/** 名詞にかかる語。解析器は分詞を過去形とも読む（registered or certified mail の certified）ので、動詞も数える。 */
+const MODIFIER = new Set(["ADJ", "VERB"]);
+
+export const isModifier = (token: Token | undefined): boolean => token?.pos === "ADJ" || (token !== undefined && isParticiple(token));
+
+/** 修飾語と名詞だけの句（certified mail / artificial flavor）。冠詞や目的語を連れた動詞（adopt their resources）は違う。 */
+export const isModifiedNoun = (scope: ItemScope, item: TokenRange): boolean => {
+  const headAt = firstAt(scope, "open", item);
+  const tail = { start: headAt === -1 ? item.end : headAt + 1, end: item.end };
+  const tailLength = count(scope, "open", tail);
+  const nounPhrase = tailLength > 0 && tailLength === count(scope, "nounPhraseTail", tail);
+  return MODIFIER.has(tokenAt(scope, headAt)?.pos ?? "") && nounPhrase && APPOSITIVE_ANCHOR.has(last(scope, "open", tail)?.pos ?? "");
+};
+
+export const isPluralNounPhrase = (scope: ItemScope, item: TokenRange): boolean =>
+  count(scope, "content", item) === count(scope, "nounPhraseTail", item) && lastContent(scope, item)?.features?.["Number"] === "Plur";
+
+export const firstNoun = (scope: ItemScope, item: TokenRange): Token | undefined => first(scope, "noun", item);
+
+export const lastNoun = (scope: ItemScope, item: TokenRange): Token | undefined => last(scope, "noun", item);
+
+/** and / or の後ろの項目。次の読点か節の切れ目まで。 */
+export const itemAfter = (scope: ItemScope, at: number): TokenRange => {
+  const rest = { start: at + 1, end: scope.sentence.tokens.length };
+  const end = firstIn(scope.sentence.column.itemEnd, rest);
+  return { start: rest.start, end: end === -1 ? rest.end : end };
+};
+
+/**
+ * 項目の中で、and / or と同じ深さにある最後の例の句（such as / e.g.）の直後の位置。無ければ -1。句は項目の中で終わるものだけ。
+ * 項目の終わりをまたぐ句は、項目の最後の数語から始まるものだけなので、後ろから見て数個で決まる。
+ */
+export const exampleEnd = (scope: ItemScope, item: TokenRange): number => {
+  const starts = scope.sentence.exampleStarts.get(scope.level) ?? [];
+  const within = (from: number): number => {
+    const start = starts[from];
+    if (start === undefined || start < item.start) return -1;
+    const end = (scope.sentence.exampleEnds[start] ?? []).find((phraseLast) => phraseLast < item.end);
+    return end === undefined ? within(from - 1) : end + 1;
+  };
+  return within(lowerBound(starts, item.end) - 1);
+};

package/src/detectors/list-items.ts

@@ -0,0 +1,163 @@
+import {
+  exampleEnd,
+  firstContent,
+  hasContent,
+  hasPrepositionalTail,
+  hasVerb,
+  isClause,
+  lastContent,
+  openingOf,
+  participleOpening,
+  shapeOf,
+} from "./list-item.ts";
+import { isListConjunction, scopeOf, VERBAL, type ItemScope, type ListSentence } from "./list-sentence.ts";
+import { lowerBound, type TokenRange } from "./token-column.ts";
+
+// and / or の前の項目を、節の頭から読点ごとに切った並び。and / or ごとに節の頭から切り直すと、and の多い文で語数の二乗になる。
+// ここでは深さごとに一度だけ左から読み、読点で閉じた項目は固めて、並び全体への問い（どれも節か、最後に例の句がある項目はどれか）
+// に答えるための表を足していく。and / or のたびに作るのは、まだ閉じていない最後の 1、2 項目だけ。
+
+/** 項目ごとに一度だけ答えを覚えておく問い。 */
+export type Flag = "closed" | "example" | "participle" | "verbalShape" | "hasVerb" | "isClause" | "prepositionalTail" | "notNounHead" | "notProperNounHead";
+
+type FlagTest = (scope: ItemScope, item: TokenRange) => boolean;
+
+export const FLAG_TESTS: Readonly<Record<Flag, FlagTest>> = {
+  closed: (scope, item) => isListConjunction(openingOf(scope, item)),
+  example: (scope, item) => exampleEnd(scope, item) !== -1,
+  participle: (scope, item) => participleOpening(scope, item) !== undefined,
+  verbalShape: (scope, item) => VERBAL.has(shapeOf(scope, item) ?? ""),
+  hasVerb,
+  isClause,
+  prepositionalTail: hasPrepositionalTail,
+  notNounHead: (scope, item) => firstContent(scope, item)?.pos !== "NOUN",
+  notProperNounHead: (scope, item) => firstContent(scope, item)?.pos !== "PROPN",
+};
+
+const FLAGS = Object.keys(FLAG_TESTS).filter((name): name is Flag => Object.hasOwn(FLAG_TESTS, name));
+
+type PerFlag<T> = Record<Flag, T>;
+
+const perFlag = <T>(make: () => T): PerFlag<T> => ({
+  closed: make(),
+  example: make(),
+  participle: make(),
+  verbalShape: make(),
+  hasVerb: make(),
+  isClause: make(),
+  prepositionalTail: make(),
+  notNounHead: make(),
+  notProperNounHead: make(),
+});
+
+/** 閉じた項目と、その問いの答え。trueAt は答えが真の項目の位置、lastFalse は最後に偽だった位置（WithContent は中身のある項目だけ）。 */
+type Frozen = {
+  readonly items: TokenRange[];
+  readonly content: boolean[];
+  readonly contentAt: number[];
+  readonly shapes: (string | undefined)[];
+  /** 中身のある項目のうち、次の中身のある項目と頭の形が違う最後のもの。無ければ -1。 */
+  lastShapeChange: number;
+  readonly flags: PerFlag<boolean[]>;
+  readonly trueAt: PerFlag<number[]>;
+  readonly trueWithContentAt: PerFlag<number[]>;
+  readonly lastFalse: PerFlag<number>;
+  readonly lastFalseWithContent: PerFlag<number>;
+};
+
+const emptyFrozen = (): Frozen => ({
+  items: [],
+  content: [],
+  contentAt: [],
+  shapes: [],
+  lastShapeChange: -1,
+  flags: perFlag((): boolean[] => []),
+  trueAt: perFlag((): number[] => []),
+  trueWithContentAt: perFlag((): number[] => []),
+  lastFalse: perFlag(() => -1),
+  lastFalseWithContent: perFlag(() => -1),
+});
+
+const recordFlags = (frozen: Frozen, scope: ItemScope, item: TokenRange, content: boolean): void => {
+  const index = frozen.items.length - 1;
+  FLAGS.forEach((flag) => {
+    const holds = FLAG_TESTS[flag](scope, item);
+    frozen.flags[flag].push(holds);
+    if (holds) frozen.trueAt[flag].push(index);
+    else frozen.lastFalse[flag] = index;
+    if (holds && content) frozen.trueWithContentAt[flag].push(index);
+    if (!holds && content) frozen.lastFalseWithContent[flag] = index;
+  });
+};
+
+const freeze = (frozen: Frozen, scope: ItemScope, item: TokenRange): void => {
+  const content = hasContent(scope, item);
+  const shape = shapeOf(scope, item);
+  const previous = frozen.contentAt.at(-1);
+  frozen.items.push(item);
+  frozen.content.push(content);
+  frozen.shapes.push(shape);
+  if (content && previous !== undefined && frozen.shapes[previous] !== shape) frozen.lastShapeChange = previous;
+  if (content) frozen.contentAt.push(frozen.items.length - 1);
+  recordFlags(frozen, scope, item, content);
+};
+
+/** 形容詞のあとの読点は、名詞の前で形容詞を重ねているだけのことが多い（the long, winding bridge）。次の項目が名詞で終わるならつなげ直す。 */
+const stacks = (scope: ItemScope, previous: TokenRange, item: TokenRange): boolean =>
+  lastContent(scope, previous)?.pos === "ADJ" && lastContent(scope, item)?.pos !== "ADJ";
+
+/** 1 つの深さの並び。start は節の頭、rawStart は読点でまだ閉じていない項目の頭、pending は次の項目とつながりうる最後の項目。 */
+type LevelItems = {
+  readonly start: number;
+  readonly scope: ItemScope;
+  readonly commas: readonly number[];
+  nextComma: number;
+  rawStart: number;
+  pending: TokenRange | undefined;
+  readonly frozen: Frozen;
+};
+
+/** 節の頭から and / or までの項目。閉じた項目の表と、まだ閉じていない最後の 1、2 項目。 */
+export type ItemList = { readonly scope: ItemScope; readonly frozen: Frozen; readonly tail: readonly TokenRange[] };
+
+const addItem = (items: LevelItems, item: TokenRange): void => {
+  if (item.end <= item.start) return;
+  if (items.pending !== undefined && stacks(items.scope, items.pending, item)) {
+    items.pending = { start: items.pending.start, end: item.end };
+    return;
+  }
+  if (items.pending !== undefined) freeze(items.frozen, items.scope, items.pending);
+  items.pending = item;
+};
+
+const tailOf = (scope: ItemScope, pending: TokenRange | undefined, live: TokenRange | undefined): TokenRange[] => {
+  if (live === undefined) return pending === undefined ? [] : [pending];
+  if (pending === undefined) return [live];
+  return stacks(scope, pending, live) ? [{ start: pending.start, end: live.end }] : [pending, live];
+};
+
+/** 深さごとの並びを、and / or の位置 at まで読み進める。at は呼ぶたびに大きくなる。返した並びは、次に読み進めるまでのもの。 */
+export const listReader = (sentence: ListSentence): ((at: number) => ItemList) => {
+  const byLevel = new Map<number, LevelItems>();
+  const opened = (level: number, start: number): LevelItems => {
+    const known = byLevel.get(level);
+    if (known !== undefined && known.start === start) return known;
+    const commas = sentence.commas.get(level) ?? [];
+    const scope = scopeOf(sentence, level);
+    const fresh = { start, scope, commas, nextComma: lowerBound(commas, start), rawStart: start, pending: undefined, frozen: emptyFrozen() };
+    byLevel.set(level, fresh);
+    return fresh;
+  };
+  return (at) => {
+    const level = sentence.depths[at] ?? 0;
+    const items = opened(level, (sentence.column.clauseBreak.previous[at] ?? -1) + 1);
+    const reached = lowerBound(items.commas, at);
+    items.commas.slice(items.nextComma, reached).forEach((comma) => {
+      addItem(items, { start: items.rawStart, end: comma });
+      items.rawStart = comma + 1;
+    });
+    items.nextComma = reached;
+    const live = items.rawStart < at ? { start: items.rawStart, end: at } : undefined;
+    return { scope: items.scope, frozen: items.frozen, tail: tailOf(items.scope, items.pending, live) };
+  };
+};

package/src/detectors/list-lead-in.ts

@@ -0,0 +1,33 @@
+import type { BulletList, Sentence, Span } from "../plugin.ts";
+import { endsWithColon } from "./lead-in.ts";
+
+/** Between a lead-in and its list: only blank space. A thematic break (`***`) separates them; bold marks sit inside the sentence. */
+const ONLY_BLANKS = /^\s*$/u;
+
+/** How many sentences end at or before an offset. Sentences are in document order, so a binary search. */
+const countEndingBy = (sentences: readonly Sentence[], offset: number): number => {
+  const search = (low: number, high: number): number => {
+    if (low >= high) return low;
+    const middle = Math.floor((low + high) / 2);
+    return (sentences[middle]?.span.end ?? Infinity) <= offset ? search(middle + 1, high) : search(low, middle);
+  };
+  return search(0, sentences.length);
+};
+
+/** The sentence that ends last before the list starts, if nothing but blanks lies between them. */
+const sentenceRightBefore = (sentences: readonly Sentence[], list: BulletList, source: string): Sentence | undefined => {
+  const before = sentences[countEndingBy(sentences, list.span.start) - 1];
+  return before !== undefined && ONLY_BLANKS.test(source.slice(before.span.end, list.span.start)) ? before : undefined;
+};
+
+const insideAny = (spans: readonly Span[], offset: number): boolean => spans.some((span) => span.start <= offset && offset < span.end);
+
+/**
+ * Prose sentences ending in a colon that hand the reader straight to a list (「以下の通りです：」, "Here's what you need:").
+ * An item of a list is not prose: 「例: `code`」 ends in a colon once its code is masked, and it leads nowhere.
+ */
+export const colonLeadIns = (sentences: readonly Sentence[], lists: readonly BulletList[], listSpans: readonly Span[], source: string): Sentence[] =>
+  lists.flatMap((list) => {
+    const before = sentenceRightBefore(sentences, list, source);
+    return before !== undefined && endsWithColon(before.text) && !insideAny(listSpans, before.span.start) ? [before] : [];
+  });