chaffjs 0.14.0 → 0.16.0

package/src/detectors/en-shape.ts

@@ -1,5 +1,6 @@
 import { lengthOf } from "../measure.ts";
 import { isClosed } from "../sentence-shape.ts";
+import { isTitleCase, minorityCase, pageTitleOf } from "./heading-case.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 
 const PER = 1000;
@@ -78,11 +79,11 @@ const firstWord = (sentence: Sentence): string =>
  * 何が主張なのかが分からなくなる。
  */
 export const conjunctionRun: Detector = (doc, options): Finding[] => {
-  const heads = (options.lexicon ?? []).map((entry) => entry.pattern.toLowerCase());
+  const heads = new Set((options.lexicon ?? []).map((entry) => entry.pattern.toLowerCase()));
   const runs = doc.sentences.filter(isClosed).reduce<Sentence[][]>(
     (acc, sentence) => {
       const last = acc.at(-1) ?? [];
-      if (!heads.includes(firstWord(sentence).toLowerCase())) return [...acc.slice(0, -1), last, []];
+      if (!heads.has(firstWord(sentence).toLowerCase())) return [...acc.slice(0, -1), last, []];
       return [...acc.slice(0, -1), [...last, sentence]];
     },
     [[]],
@@ -106,19 +107,6 @@ export const conjunctionRun: Detector = (doc, options): Finding[] => {
     });
 };
 
-const WORD = /[A-Za-z][A-Za-z'-]*/gu;
-
-/** 小さい語は Title Case でも小文字のままなので、大文字化の判定から外す。 */
-const MINOR = new Set(["a", "an", "the", "and", "or", "but", "of", "in", "on", "at", "to", "for", "with", "as", "by", "from", "is"]);
-
-const isTitleCase = (heading: string): boolean | undefined => {
-  const words = [...heading.matchAll(WORD)].map((match) => match[0]).filter((word) => !MINOR.has(word.toLowerCase()));
-  // 1 語の見出しは、どちらの流儀でも先頭が大文字になる。判定できない。
-  if (words.length < 2) return undefined;
-  const capitalized = words.filter((word) => word[0] === word[0]?.toUpperCase()).length;
-  return capitalized === words.length;
-};
-
 const headingsOf = (sections: readonly Section[]): { readonly section: Section; readonly title: boolean }[] =>
   sections.flatMap((section) => {
     const title = isTitleCase(section.heading);
@@ -127,25 +115,24 @@ const headingsOf = (sections: readonly Section[]): { readonly section: Section;
 
 /**
  * 見出しの大文字化が混ざっている。どちらの流儀が正しいかは決めない。spec §12.3。
- * 見るのは文書の中で揃っているかだけで、少数派のほうを指摘する。
+ * 見るのは文書の中で揃っているかだけで、少数派のほうを指摘する。題名は指摘しない（minorityCase）。
  */
 export const titleCaseMix: Detector = (doc, options): Finding[] => {
-  const judged = headingsOf(doc.sections);
-  const title = judged.filter((entry) => entry.title).length;
-  const minorityIsTitle = title <= judged.length - title;
-  const few = minorityIsTitle ? title : judged.length - title;
-  // 同数なら少数派は無い。どちらかを「他と違う」と呼ぶのは、選びかたが恣意的になる。
-  if (few === 0 || few * 2 === judged.length || few > options.limit) return [];
-  return judged
-    .filter((entry) => entry.title === minorityIsTitle)
-    .map(({ section }) => ({
-      rule: "title-case-consistency",
-      severity: "info",
-      line: 0,
-      column: 0,
-      quote: section.heading,
-      values: { count: few, limit: options.limit, offset: section.span.start },
-    }));
+  const pageTitle = pageTitleOf(doc.sections);
+  const judged = headingsOf(doc.sections.filter((section) => section !== pageTitle));
+  const titleCase = judged.filter((entry) => entry.title).length;
+  const pageTitleCase = pageTitle === undefined ? undefined : isTitleCase(pageTitle.heading);
+  const minorityIsTitle = minorityCase({ titleCase, sentenceCase: judged.length - titleCase }, pageTitleCase);
+  const few = minorityIsTitle === undefined ? [] : judged.filter((entry) => entry.title === minorityIsTitle);
+  if (few.length > options.limit) return [];
+  return few.map(({ section }) => ({
+    rule: "title-case-consistency",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: section.heading,
+    values: { count: few.length, limit: options.limit, offset: section.span.start },
+  }));
 };
 
 const LIST_CONJUNCTION = new Set(["and", "or"]);
@@ -166,7 +153,8 @@ const depthsOf = (tokens: readonly Token[]): number[] =>
     { depths: [], open: 0 },
   ).depths;
 
-type Clause = { readonly tokens: readonly Token[]; readonly depths: readonly number[] };
+/** participleWords は、解析器が分詞と読まないが読点のあとで分詞の句を始める語（meaning）。 */
+type Clause = { readonly tokens: readonly Token[]; readonly depths: readonly number[]; readonly participleWords: ReadonlySet<string> };
 
 /** 冠詞や引用符を飛ばした、項目の頭の品詞。the parser と an exporter と samples を同じ形と見る。 */
 const NOMINAL = new Set(["NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
@@ -204,6 +192,21 @@ const itemsBefore = (clause: Clause, at: number): Token[][] => {
     .filter((item) => item.length > 0);
 };
 
+/**
+ * and / or で始まる項目で、前の並びは閉じている（offering, giving, or receiving, directly or indirectly）。
+ * 次の並びはその項目から始まる。項目が動詞で始まれば、その目的語から（Develop, maintain, and track courses, materials and events）。
+ */
+const afterClosedList = (items: readonly Token[][]): Token[][] => {
+  const closed = items.findLastIndex((item) => LIST_CONJUNCTION.has(openingOf(item)?.surface.toLowerCase() ?? ""));
+  const closing = items[closed];
+  if (closing === undefined) return [...items];
+  const body = closing.slice(closing.findIndex((token) => LIST_CONJUNCTION.has(token.surface.toLowerCase())) + 1);
+  const head = body.findIndex(isContent);
+  const rest = VERBAL.has(body[head]?.pos ?? "") ? body.slice(head + 1) : body;
+  // 項目が残らなければ、後ろは新しい句の頭。導入の句（directly or indirectly,）を外す。
+  return rest.some(isContent) ? [rest, ...items.slice(closed + 1)] : [...withoutLead(items.slice(closed + 1))];
+};
+
 /** and / or の後ろの項目。次の読点か節の切れ目まで。 */
 const itemAfter = (tokens: readonly Token[], at: number): Token[] => {
   const end = tokens.findIndex((token, index) => index > at && (isComma(token) || CLAUSE_BREAK.has(token.surface)));
@@ -245,7 +248,9 @@ const joinAdjectives = (items: readonly Token[][]): Token[][] =>
   items.reduce<Token[][]>((joined, item) => {
     const previous = joined.at(-1);
     const stacked = previous !== undefined && lastContent(previous)?.pos === "ADJ" && lastContent(item)?.pos !== "ADJ";
-    return stacked ? [...joined.slice(0, -1), [...previous, ...item]] : [...joined, item];
+    if (stacked) joined[joined.length - 1] = [...previous, ...item];
+    else joined.push(item);
+    return joined;
   }, []);
 
 /**
@@ -268,14 +273,93 @@ const hasVerb = (item: readonly Token[]): boolean => item.some((token) => VERBAL
 
 const predicatesAgree = (items: readonly Token[][], shape: string): boolean => !VERBAL.has(shape) || items.every(hasVerb);
 
+/** -ing 形（VerbForm=Ger）と過去分詞（Part）。filling the gaps と sentenced to prison は並べても並列にならない。 */
+const VERB_FORMS = new Set(["Ger", "Part"]);
+
+const verbFormOf = (token: Token): string | undefined => {
+  const form = token.features?.["VerbForm"];
+  return form !== undefined && VERB_FORMS.has(form) ? form : undefined;
+};
+
+/** 項目の頭の分詞とその形。副詞は飛ばす（originally written）。引用符の中の語（‘modelling’）は語の例なので分詞と読まない。 */
+const participleOpening = (item: readonly Token[], words: ReadonlySet<string>): { readonly at: number; readonly form: string } | undefined => {
+  const at = item.findIndex((token) => token.pos !== "PUNCT" && token.pos !== "ADV");
+  const opening = item[at];
+  if (opening === undefined) return undefined;
+  const form = words.has(opening.surface.toLowerCase()) ? "Ger" : verbFormOf(opening);
+  return form === undefined ? undefined : { at, form };
+};
+
+const hasParticiple = (item: readonly Token[], form: string): boolean => item.some((token) => verbFormOf(token) === form);
+
+/**
+ * 最初より後ろの項目が分詞で始まるとき。最初の項目にも同じ形の分詞があれば分詞の並び
+ * （are hiring engineers, buying laptops and renting desks / Tested, reviewed and approved）。後ろの項目が動詞で始まれば述語の並びで、
+ * 分詞は解析器の読み違い（the jury, cross-examined the witnesses, presented witnesses, and made）。そうでなければ分詞の句
+ * （from Latin, meaning ship or boat / the judge, sitting without a jury, and sentenced）で、並びがあるならその句の中から始まる。
+ * 分詞より前の項目と分詞そのものは項目ではない（programs, including the office, the desk and the team）。句の中の項目の形が揃わなければ
+ * 句は挿入で、並びは句の後ろだけ（relief, including an injunction, in any court ... and without / including before the date, to a
+ * Recipient ... “confidential”, “proprietary”, or the like）。
+ */
+/** 解析器は過去形と過去分詞（fixed）を見分けられない。動詞のある項目のあとの「過去分詞」の並びは、述語の並びと読む。 */
+const pastPredicates = (first: readonly Token[], form: string, after: readonly Token[], words: ReadonlySet<string>): boolean =>
+  form === "Part" && participleOpening(after, words)?.form === "Part" && hasVerb(first);
+
+const fromParticiplePhrase = (items: readonly Token[][], after: readonly Token[], words: ReadonlySet<string>): readonly Token[][] => {
+  const at = items.findIndex((item, index) => index > 0 && participleOpening(item, words) !== undefined);
+  const phrase = items[at];
+  const first = items[0];
+  const opening = phrase === undefined ? undefined : participleOpening(phrase, words);
+  if (first === undefined || phrase === undefined || opening === undefined) return items;
+  const rest = items.slice(at + 1);
+  const predicates = rest.some((item) => VERBAL.has(shapeOf(item) ?? "")) || pastPredicates(first, opening.form, after, words);
+  if (hasParticiple(first, opening.form) || predicates) return items;
+  const inPhrase = withoutLead([phrase.slice(opening.at + 1), ...rest].filter((item) => item.some(isContent)));
+  return new Set(inPhrase.map(shapeOf)).size > 1 ? rest : inPhrase;
+};
+
+const APPOSITIVE_ANCHOR = new Set(["NOUN", "PROPN"]);
+
+/**
+ * 名詞のすぐ後ろの、読点で挟まれた X and Y は同格（two HPV types, HPV16 and HPV18, that account / Governments, both state and
+ * federal, spend）。項目が 2 つに見え、and の前に読点が無く、and の後ろの項目が読点で閉じ、後ろの 2 つに動詞が無いときに同格と読む。
+ * 2 つを結ぶ同格に Oxford comma は打たないので、and の前に読点があれば 3 つの並び（the subcommittee, full committee, and
+ * chamber levels, as well as）。読点の無い本当の並び（apples, pears and plums, then ...）はこの形と見分けられず、判定から外れる。
+ */
+const isAppositive = (clause: Clause, at: number, items: readonly Token[][], after: readonly Token[]): boolean => {
+  const [anchor, head] = items;
+  if (items.length !== 2 || anchor === undefined || head === undefined || commaBefore(clause.tokens, at)) return false;
+  const end = at + 1 + after.length;
+  // 閉じた読点のあとに and / or が続くなら、並びのあとに節をつないでいる（apples, pears and plums, and went home）。
+  const joinsClause = LIST_CONJUNCTION.has(clause.tokens[end + 1]?.surface.toLowerCase() ?? "");
+  const closed = clause.tokens[end]?.surface === "," && clause.depths[end] === clause.depths[at] && !joinsClause;
+  return closed && APPOSITIVE_ANCHOR.has(lastContent(anchor)?.pos ?? "") && !hasVerb(head) && !hasVerb(after);
+};
+
+/** 副詞を飛ばした頭の形。explain and justify と ultimately ensure は同じ動詞の項目。 */
+const leadShape = (item: readonly Token[]): string | undefined => shapeOf(item.filter((token) => token.pos !== "ADV"));
+
+/**
+ * and の後ろの項目に読点と、同じ形の項目を連れた and / or が続くなら、この and は項目の中にある（searches and seizures, and
+ * the Eighth's ban）。頭の形か、節かどうかが違えば別の節をつなぐ and で、この and までが並び（apples, pears and plums, and went home / and figs fell）。
+ */
+const listContinues = (clause: Clause, at: number, after: readonly Token[]): boolean => {
+  const next = at + 1 + after.length;
+  if (clause.tokens[next]?.surface !== "," || !LIST_CONJUNCTION.has(clause.tokens[next + 1]?.surface.toLowerCase() ?? "")) return false;
+  const following = itemAfter(clause.tokens, next + 1);
+  const shape = leadShape(following);
+  return shape !== undefined && shape === leadShape(after) && isClause(following) === isClause(after);
+};
+
 /**
  * 読点で区切った項目が and / or の前に 2 つ以上あり、最後の項目と and の後ろが同じ形のときだけ並列。
  * 導入の読点（After the review, the team fixed the bug and shipped it.）や、節をつなぐ読点
  * （We tested it, and the team shipped it.）は、Oxford comma を打つかどうかの選択を見せない。
  */
 const listAt = (clause: Clause, at: number): boolean | undefined => {
-  const items = withoutLead(joinAdjectives(itemsBefore(clause, at)));
   const after = itemAfter(clause.tokens, at);
+  const items = fromParticiplePhrase(afterClosedList(withoutLead(joinAdjectives(itemsBefore(clause, at)))), after, clause.participleWords);
+  if (listContinues(clause, at, after) || isAppositive(clause, at, items, after)) return undefined;
   const last = items.at(-1);
   const shape = last === undefined ? undefined : shapeOf(last);
   if (items.length < 2 || shape === undefined || shape !== shapeOf(after)) return undefined;
@@ -289,8 +373,8 @@ const listAt = (clause: Clause, at: number): boolean | undefined => {
  * どちらが正しいかは決めない。スタイルガイドで割れる論点に立場を取ると rule ごと無視される。
  * 見るのは 1 つの文書で揃っているかだけ。spec §12.3。
  */
-const oxfordIn = (tokens: readonly Token[]): boolean | undefined => {
-  const clause = { tokens, depths: depthsOf(tokens) };
+const oxfordIn = (tokens: readonly Token[], participleWords: ReadonlySet<string>): boolean | undefined => {
+  const clause = { tokens, depths: depthsOf(tokens), participleWords };
   return tokens.reduce<boolean | undefined>(
     (found, token, at) => found ?? (at > 0 && LIST_CONJUNCTION.has(token.surface.toLowerCase()) ? listAt(clause, at) : undefined),
     undefined,
@@ -298,8 +382,9 @@ const oxfordIn = (tokens: readonly Token[]): boolean | undefined => {
 };
 
 export const oxfordComma: Detector = (doc, options): Finding[] => {
+  const participleWords = new Set((doc.lexicons["participle-word"] ?? []).map((entry) => entry.pattern.toLowerCase()));
   const judged = doc.sentences.flatMap((sentence) => {
-    const oxford = oxfordIn(sentence.tokens ?? []);
+    const oxford = oxfordIn(sentence.tokens ?? [], participleWords);
     return oxford === undefined ? [] : [{ sentence, oxford }];
   });
   const withComma = judged.filter((entry) => entry.oxford).length;

package/src/detectors/enumerated-runs.ts

@@ -61,8 +61,9 @@ export const enumeratedRuns = (paragraphs: readonly Span[], starts: readonly num
   const enumerated = paragraphs.filter((paragraph) => opensWithItem(paragraph, starts, source));
   const runs = enumerated.reduce<Span[]>((joined, paragraph) => {
     const last = joined.at(-1);
-    if (last === undefined || !isBlank(source, last.end, paragraph.start)) return [...joined, paragraph];
-    return [...joined.slice(0, -1), { start: last.start, end: paragraph.end }];
+    if (last === undefined || !isBlank(source, last.end, paragraph.start)) joined.push(paragraph);
+    else joined[joined.length - 1] = { start: last.start, end: paragraph.end };
+    return joined;
   }, []);
   return runs.filter((run) => itemsIn(run, starts, source) >= MIN_ITEMS);
 };

package/src/detectors/gram-place.ts

@@ -1,3 +1,4 @@
+import { softBreaks } from "../soft-break.ts";
 import type { LengthUnit, Span } from "../plugin.ts";
 
 /** 数えるために詰めた文と、詰めた文の各文字が元の文のどこにあったか。 */
@@ -7,15 +8,21 @@ export type Compacted = { readonly text: string; readonly offsets: readonly numb
  * n-gram を数えるときと同じ詰め方。word 単位は空白の並びを 1 つにして前後を削り、char 単位は空白を全部除く。
  * 語句が元の文のどこにあるかを戻せるよう、残した文字ごとに元の位置を持つ。
  */
+/** spans が覆う位置（UTF-16 の単位）。 */
+const offsetsIn = (spans: readonly Span[]): Set<number> =>
+  new Set(spans.flatMap((span) => Array.from({ length: span.end - span.start }, (_, step) => span.start + step)));
+
 export const compacted = (text: string, unit: LengthUnit): Compacted => {
   const chars: string[] = [];
   const offsets: number[] = [];
   const state = { pendingSpace: -1, at: 0 };
+  // 読み手に見えない改行は空白 1 つにもしない。proseText がつないだ語句を、ここでも同じ形で探せるように。
+  const hidden = offsetsIn(unit === "word" ? softBreaks(text) : []);
   Array.from(text).forEach((char) => {
     const at = state.at;
     state.at += char.length;
     if (/\s/u.test(char)) {
-      if (unit === "word" && chars.length > 0 && state.pendingSpace === -1) state.pendingSpace = at;
+      if (unit === "word" && chars.length > 0 && state.pendingSpace === -1 && !hidden.has(at)) state.pendingSpace = at;
       return;
     }
     if (state.pendingSpace !== -1) {
@@ -25,7 +32,7 @@ export const compacted = (text: string, unit: LengthUnit): Compacted => {
     }
     chars.push(char);
     // 位置は UTF-16 の単位で持つ。placeOf は indexOf の位置で引くので、絵文字（2 単位）には 2 つ置く。
-    Array.from({ length: char.length }, (_, unit) => offsets.push(at + unit));
+    Array.from({ length: char.length }, (_, codeUnit) => offsets.push(at + codeUnit));
   });
   return { text: chars.join(""), offsets };
 };

package/src/detectors/gram-predicate.ts

@@ -0,0 +1,55 @@
+import { isNamePart } from "./name-part.ts";
+import type { LengthUnit, Span, Token } from "../plugin.ts";
+
+/** 動詞と助動詞。言い回し（ることができます、it is important to）にはこれが入り、主題の名前（state and local tax）には入らない。 */
+const PREDICATE_POS = new Set(["VERB", "AUX"]);
+
+const NOUNS = new Set(["NOUN", "PROPN", "ADJ"]);
+
+/** 中身を持たない語。名前の前後に付いても、名前の繰り返しを言い回しに変えない。 */
+const FUNCTION_POS = new Set(["ADP", "DET", "CCONJ", "SCONJ", "PART", "PUNCT", "SYM", "X"]);
+
+/**
+ * 英語で名詞のすぐ前の動詞は、名詞を飾る語（形容詞を挟んでも同じ）（the upcoming fiscal year、the Disclosing Party、the borrow checker）で、
+ * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、word 単位だけで見る。
+ */
+const modifiesNoun = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean =>
+  unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "");
+
+/** 英語で大文字の名前の一部になった動詞（Procedures Guide、the Location Object）も、述語ではない。 */
+const namePartAt = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean => unit === "word" && isNamePart(tokens, index);
+
+const isName = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean => {
+  const token = tokens[index];
+  return token !== undefined && (token.pos === "PROPN" || token.features?.["NameType"] !== undefined || namePartAt(tokens, index, unit));
+};
+
+const overlaps = (token: Token, window: Span): boolean => token.span.start < window.end && window.start < token.span.end;
+
+const isCut = (token: Token, window: Span): boolean => token.span.start < window.start || window.end < token.span.end;
+
+/**
+ * 窓が名前だけを繰り返しているか。predicate（添字）のほかに窓が触れる語が、名前と中身の無い語だけで、名前が 1 つはある。
+ * 窓の端で切れた動詞（"ed in the NSF Propos" の identified、"ed by Applicable Law" の prohibited）は語尾しか入っておらず、
+ * 動詞は出てくるたびに違ってよい。繰り返されているのは名前のほう。
+ */
+const onlyNamesBeside = (tokens: readonly Token[], predicate: number, window: Span, unit: LengthUnit): boolean => {
+  const touched = tokens.flatMap((token, index) => (index !== predicate && overlaps(token, window) ? [index] : []));
+  const names = touched.filter((index) => isName(tokens, index, unit));
+  const rest = touched.filter((index) => !isName(tokens, index, unit));
+  return names.length > 0 && rest.every((index) => FUNCTION_POS.has(tokens[index]?.pos ?? ""));
+};
+
+const countsAsPredicate = (tokens: readonly Token[], index: number, window: Span, unit: LengthUnit): boolean => {
+  const token = tokens[index];
+  if (token === undefined || !PREDICATE_POS.has(token.pos) || !overlaps(token, window)) return false;
+  if (modifiesNoun(tokens, index, unit) || namePartAt(tokens, index, unit)) return false;
+  return !isCut(token, window) || !onlyNamesBeside(tokens, index, window, unit);
+};
+
+/**
+ * 語句が文の中で占める範囲（window、文書の中の位置）に、述語になる動詞か助動詞があるか。
+ * 範囲で見る。文字で探すと、同じ文の別の所の動詞「use」が、語句の中の名詞「use」に当たる。
+ */
+export const hasPredicateIn = (tokens: readonly Token[], window: Span, unit: LengthUnit): boolean =>
+  tokens.some((_, index) => countsAsPredicate(tokens, index, window, unit));

package/src/detectors/heading-case.ts

@@ -0,0 +1,44 @@
+const WORD = /[A-Za-z][A-Za-z'-]*/gu;
+
+/** 小さい語は Title Case でも小文字のままなので、大文字化の判定から外す。 */
+const MINOR = new Set(["a", "an", "the", "and", "or", "but", "of", "in", "on", "at", "to", "for", "with", "as", "by", "from", "is"]);
+
+/** 大文字だけの語（PR・FCPs）は略語で、どちらの流儀でも大文字のまま。Title Case の証拠にならない。 */
+const ACRONYM = /^[A-Z]{2,}s?$/u;
+
+const TITLE_DEPTH = 1;
+
+/** 見出しが Title Case か。判定できなければ undefined。 */
+export const isTitleCase = (heading: string): boolean | undefined => {
+  const words = [...heading.matchAll(WORD)].map((match) => match[0]).filter((word) => !MINOR.has(word.toLowerCase()) && !ACRONYM.test(word));
+  // 1 語の見出しは、どちらの流儀でも先頭が大文字になる。判定できない。
+  if (words.length < 2) return undefined;
+  const capitalized = words.filter((word) => word[0] === word[0]?.toUpperCase()).length;
+  return capitalized === words.length;
+};
+
+/**
+ * 文書の題名。最初の見出しが深さ 1 で、深さ 1 の見出しがほかに無いときの、その見出し。
+ * 深さ 1 が複数あると、最初のものが題名なのか章なのかを構造からは決められないので、題名とは呼ばない。
+ * 見出しより前の導入部（深さ 0）は見出しではないので数えない。
+ */
+export const pageTitleOf = <T extends { readonly depth: number }>(sections: readonly T[]): T | undefined => {
+  const headed = sections.filter((section) => section.depth > 0);
+  const first = headed[0];
+  if (first?.depth !== TITLE_DEPTH) return undefined;
+  return headed.filter((section) => section.depth === TITLE_DEPTH).length === 1 ? first : undefined;
+};
+
+export type CaseCounts = { readonly titleCase: number; readonly sentenceCase: number };
+
+/**
+ * 節の見出しのうち少数派の流儀（true なら Title Case）。少数派が無ければ undefined。
+ * 題名は数に入れない。題名は名前なので、節と流儀を分けるのはよくある揃えかた。
+ * 同数のときだけ題名の流儀で決める。題名と同じ流儀のほうが、書き手の選んだ流儀である見込みが高い。
+ */
+export const minorityCase = (sections: CaseCounts, pageTitleCase: boolean | undefined): boolean | undefined => {
+  if (sections.titleCase === sections.sentenceCase) return sections.titleCase === 0 || pageTitleCase === undefined ? undefined : !pageTitleCase;
+  const minorityIsTitle = sections.titleCase < sections.sentenceCase;
+  const few = minorityIsTitle ? sections.titleCase : sections.sentenceCase;
+  return few === 0 ? undefined : minorityIsTitle;
+};

package/src/detectors/heading-echo.ts

@@ -1,5 +1,6 @@
 import { lengthOf } from "../measure.ts";
 import { handsOver } from "./lead-in.ts";
+import { withoutQuotedVariants } from "./quoted-variant.ts";
 import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../plugin.ts";
 
 /** 見出しが短すぎると、偶然の一致で 100% になる。これ未満の見出しは見ない。 */
@@ -58,12 +59,15 @@ const leadsIn = (doc: ProseDocument, section: Section, phrases: readonly string[
   return first !== undefined && handsOver(first.text, doc.source.slice(first.span.end, section.span.end), phrases);
 };
 
+/** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
+const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", section.heading);
+
 export const headingEcho: Detector = (doc, options): Finding[] => {
   const leadIns = (doc.lexicons["lead-in"] ?? []).map((entry) => entry.pattern);
   return doc.sections
     .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined && addsLittle(section, doc.lengthUnit))
     .filter((section) => !leadsIn(doc, section, leadIns))
-    .map((section) => ({ section, overlap: Math.round(containment(trigrams(section.heading), trigrams(section.firstSentence?.text ?? "")) * 100) }))
+    .map((section) => ({ section, overlap: Math.round(containment(trigrams(section.heading), trigrams(echoedText(section))) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)
     .map(({ section, overlap }) => ({
       rule: "heading-echo",

package/src/detectors/index.ts

@@ -4,7 +4,7 @@ import { sentenceLength } from "./sentence-length.ts";
 import { headingEcho } from "./heading-echo.ts";
 import { repeatedHead } from "./repeated-head.ts";
 import { sentenceRhythm } from "./sentence-rhythm.ts";
-import { phraseMatch } from "./phrase-match.ts";
+import { phraseCount, phraseMatch } from "./phrase-match.ts";
 import { agentlessPassive } from "./agentless-passive.ts";
 import { doubledWord } from "./doubled-word.ts";
 import { sentenceEnding } from "./sentence-ending.ts";
@@ -13,7 +13,7 @@ import { kanjiRun, middleDot } from "./char-shape.ts";
 import { adverbDensity, conjunctionRun, expletive, oxfordComma, titleCaseMix } from "./en-shape.ts";
 import { paragraphLength, paragraphVariance, preambleLength, ruleOfThree, sectionUniformity } from "./structure.ts";
 import { concreteEvidence, dashDensity, emojiDensity, ngramRepetition, undefinedAcronym } from "./signals.ts";
-import { aiTell, contractionMix, cushionDensity, hedgingDensity, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
+import { aiTell, contractionMix, cushionDensity, hedging, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
 import { internalJargon, properNounDensity, requiredSections } from "./team.ts";
 import { latinSpacing, preferredTerm } from "./orthography.ts";
 import { danglingReference, dateOrder, dateWeekdayMismatch, duplicateDefinition, numberingGap, totalMismatch } from "./structure-tree.ts";
@@ -26,6 +26,7 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "repeated-head": repeatedHead,
   "sentence-rhythm": sentenceRhythm,
   "phrase-match": phraseMatch,
+  "phrase-count": phraseCount,
   "agentless-passive": agentlessPassive,
   "sentence-ending": sentenceEnding,
   "noun-ending": nounEnding,
@@ -48,7 +49,7 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "ngram-repetition": ngramRepetition,
   "undefined-acronym": undefinedAcronym,
   "concrete-evidence": concreteEvidence,
-  "hedging-density": hedgingDensity,
+  hedging: hedging,
   "cushion-density": cushionDensity,
   "unqualified-superlative": unqualifiedSuperlative,
   "repeated-conjunction": repeatedConjunction,

package/src/detectors/lettered-index.ts

@@ -0,0 +1,78 @@
+import type { Section } from "../plugin.ts";
+
+/** 索引の区切りは 1 文字の見出し（A, あ）で、それ自体は本文を持たない。 */
+const SINGLE_LETTER = /^\p{L}$/u;
+const FIRST_LETTER = /\p{L}/u;
+
+/** 区切りが 1 つだけなら、たまたま 1 文字の見出しかもしれない。並んで初めて索引と読む。 */
+const MIN_DIVIDERS = 2;
+
+/** カタカナとひらがなは Unicode で同じ並びにあり、この差だけ離れている。 */
+const KATAKANA = { first: 0x30a1, last: 0x30f6, toHiragana: 0x60 };
+
+type Group = { readonly run: number; readonly letter: string; readonly entries: Section[] };
+
+/** 索引で引くときの文字。最初の文字から濁点やアクセントを外し、カタカナはひらがなに、小文字は大文字にする。 */
+export const indexLetterOf = (text: string): string => {
+  const letter = FIRST_LETTER.exec(text.normalize("NFD"))?.[0] ?? "";
+  const code = letter.codePointAt(0) ?? 0;
+  const base = code >= KATAKANA.first && code <= KATAKANA.last ? String.fromCodePoint(code - KATAKANA.toHiragana) : letter;
+  return base.toUpperCase();
+};
+
+const isDivider = (section: Section): boolean => SINGLE_LETTER.test(section.heading.normalize("NFC")) && section.sentences.length === 0;
+
+/**
+ * ある深さの区切りごとに、その下の節を集める。区切りと同じ深さか浅い見出しで閉じる。
+ * 区切りでない見出しを挟んだ区切りは、別の並び（run）になる。別の親の下の A と B を 1 つの索引に綴じないため。
+ */
+const groupsAt = (sections: readonly Section[], depth: number): Group[] => {
+  const groups: Group[] = [];
+  sections.reduce<{ run: number; open: Group | undefined }>(
+    ({ run, open }, section) => {
+      if (section.depth === depth && isDivider(section)) {
+        const group = { run, letter: indexLetterOf(section.heading), entries: [] };
+        groups.push(group);
+        return { run, open: group };
+      }
+      if (open !== undefined && section.depth > depth) {
+        open.entries.push(section);
+        return { run, open };
+      }
+      return { run: run + 1, open: undefined };
+    },
+    { run: 0, open: undefined },
+  );
+  return groups;
+};
+
+const runsOf = (groups: readonly Group[]): Group[][] =>
+  [...new Set(groups.map((group) => group.run))].map((run) => groups.filter((group) => group.run === run));
+
+const ascending = (groups: readonly Group[]): boolean => groups.every((group, index) => index === 0 || (groups[index - 1]?.letter ?? "") < group.letter);
+
+/** 区切りのすぐ下の見出し（見出し語）の過半が、区切りの文字で始まる。語りの節を 1 文字の見出しで束ねただけなら、こうはならない。 */
+const headwordsFollowLetters = (groups: readonly Group[], depth: number): boolean => {
+  const matches = groups.flatMap((group) =>
+    group.entries.filter((entry) => entry.depth === depth + 1).map((entry) => indexLetterOf(entry.heading) === group.letter),
+  );
+  return matches.filter((match) => match).length * 2 > matches.length;
+};
+
+const isIndex = (groups: readonly Group[], depth: number): boolean =>
+  groups.length >= MIN_DIVIDERS && ascending(groups) && headwordsFollowLetters(groups, depth);
+
+/**
+ * 文字で区切った索引（用語集・A to Z）の項目。区切りの見出しより深い節が、次の同じ深さ以上の見出しまで続く。
+ * 項目は語の定義や表記の決まりで、根拠の要る主張ではない。
+ */
+export const letteredIndexEntries = (sections: readonly Section[]): ReadonlySet<Section> => {
+  const depths = new Set(sections.filter(isDivider).map((section) => section.depth));
+  return new Set(
+    [...depths].flatMap((depth) =>
+      runsOf(groupsAt(sections, depth))
+        .filter((run) => isIndex(run, depth))
+        .flatMap((run) => run.flatMap((group) => group.entries)),
+    ),
+  );
+};

package/src/detectors/lexicon.ts

@@ -1,8 +1,12 @@
 import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
-import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
-import { entryIn, entryOpens, entryRanges } from "./lexicon-match.ts";
+import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
+import { entryIn, entryOpens, entryRanges, type TokenRange } from "./lexicon-match.ts";
 import { scoped, scopeMarkersOf, type ScopeMarkers } from "./superlative-scope.ts";
+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";
 
 const PER = 1000;
 
@@ -36,27 +40,83 @@ const densityRule =
     }));
   };
 
-export const hedgingDensity = densityRule("excessive-hedging");
+const hedgingDensity = densityRule("excessive-hedging");
 export const cushionDensity = densityRule("cushion-phrase-density");
 
+/** 書いたとおりの字。行の折り返しをまたいでいたら空白 1 つに。 */
+const writtenAt = (source: string, span: Span): string => source.slice(span.start, span.end).replace(/\s+/gu, " ").trim();
+
+const stackedFinding = (doc: ProseDocument, stacked: StackedHedge): Finding => ({
+  rule: "excessive-hedging",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: stacked.sentence.text.trim(),
+  variant: "stacked",
+  values: {
+    matched: joinWords(
+      stacked.spans.map((span) => writtenAt(doc.source, span)),
+      doc.language,
+    ),
+    count: stacked.spans.length,
+    offset: stacked.spans[0]?.start ?? stacked.sentence.span.start,
+  },
+});
+
+/**
+ * 逃げの表現は 2 つの見方で探す。1 つの文に重ねたもの（短い文書でも 1 文で分かる）と、文書全体の密度。
+ * 重ねた文は密度の側では出さない。同じ文を同じ rule で 2 度言わない。
+ */
+export const hedging: Detector = (doc, options): Finding[] => {
+  const stacked = stackedHedges(doc.sentences, {
+    hedges: options.lexicon ?? [],
+    frames: doc.lexicons["hedge-frame"] ?? [],
+    scope: doc.lexicons["hedge-scope"] ?? [],
+  });
+  const reported = new Set(stacked.map((entry) => entry.sentence.span.start));
+  const density = hedgingDensity(doc, options).filter((finding) => !reported.has(Number(finding.values["offset"])));
+  return [...stacked.map((entry) => stackedFinding(doc, entry)), ...density];
+};
+
 /** 数字は語ではないので言語を問わない。数があれば測った結果を言っている。品詞の数（NUM）は "the best one" の one まで含むので使わない。 */
 const DIGIT = /\d/u;
 
-type Qualifiers = { readonly comparison: Lexicon; readonly scope: ScopeMarkers };
+type Qualifiers = {
+  readonly comparison: Lexicon;
+  readonly scope: ScopeMarkers;
+  readonly quantityNouns: Lexicon;
+  readonly amounts: Lexicon;
+  readonly restrictors: Restrictors;
+};
 
 const qualifiersOf = (doc: ProseDocument): Qualifiers => ({
   comparison: doc.lexicons["comparison-marker"] ?? [],
   scope: scopeMarkersOf(doc.lexicons["superlative-scope"] ?? []),
+  quantityNouns: doc.lexicons["quantity-noun"] ?? [],
+  amounts: doc.lexicons["superlative-amount"] ?? [],
+  restrictors: {
+    relatives: doc.lexicons["relative-word"] ?? [],
+    bounds: doc.lexicons["superlative-bound"] ?? [],
+    subjects: doc.lexicons["subject-pronoun"] ?? [],
+  },
 });
 
-/** どの出現も範囲を持つときだけ。1 つでも範囲の無い出現があれば、その文には限定の無い最上級がある。 */
-const everyScoped = (sentence: Sentence, entry: LexiconEntry, scope: ScopeMarkers): boolean => {
+/** 範囲・節・分詞・形容詞のどれかが最上級を限っているか、最上級が量か名前を言っているか。 */
+const qualifiedAt = (tokens: readonly Token[], range: TokenRange, qualifiers: Qualifiers): boolean =>
+  scoped(tokens, range, qualifiers.scope) ||
+  restricted(tokens, range, qualifiers.restrictors) ||
+  namesQuantity(tokens, range, qualifiers.quantityNouns) ||
+  namesAmount(tokens, range, qualifiers.amounts);
+
+/** どの出現も限られているか量を言うときだけ。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) => scoped(sentence.tokens ?? [], range, scope));
+  return ranges.length > 0 && ranges.every((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)) || everyScoped(sentence, entry, qualifiers.scope);
+  DIGIT.test(sentence.text) || qualifiers.comparison.some((marker) => entryIn(sentence, marker)) || everyQualified(sentence, entry, qualifiers);
 
 const bareHits = (doc: ProseDocument, lexicon: Lexicon): Hit[] => {
   const qualifiers = qualifiersOf(doc);