chaffjs 0.15.0 → 0.16.0

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

@@ -32,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/heading-case.ts

@@ -3,11 +3,14 @@ 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()));
+  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;

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,9 +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;
 
@@ -37,25 +40,79 @@ 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; readonly quantityNouns: Lexicon };
+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 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(tokens, range, qualifiers.scope) || namesQuantity(tokens, range, qualifiers.quantityNouns));
+  return ranges.length > 0 && ranges.every((range) => qualifiedAt(tokens, range, qualifiers));
 };
 
 const qualified = (sentence: Sentence, entry: LexiconEntry, qualifiers: Qualifiers): boolean =>

package/src/detectors/orthography.ts

@@ -1,4 +1,5 @@
-import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
+import { calendarRuns, type CalendarRun, type CalendarUnits } from "../calendar-number.ts";
 import { latinBoundaries, minorityStyle, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { digitRunAround, isNumberName, sequenceLabelStarts } from "../number-name.ts";
@@ -31,13 +32,32 @@ const digitBeside = (boundary: Boundary): number => {
   return boundary.spaced ? boundary.offset + 1 : boundary.offset;
 };
 
-/** 番号・識別子として書かれた数の境目は、空け方の好みではないので数えない（number-name.ts）。 */
-const isCounted = (sentence: Sentence, boundary: Boundary, sequence: ReadonlySet<number>, topUnits: ReadonlySet<string>): boolean => {
+/** 文書全体で一度だけ読むもの。sequence は続き番号の行の頭、topUnits は都道府県の単位、calendar は日付・時刻の単位。 */
+type NumberContext = { readonly sequence: ReadonlySet<number>; readonly topUnits: ReadonlySet<string>; readonly calendar: CalendarUnits };
+
+/** 文の中の日付・時刻の数の、並びの頭の位置と、日付の中の位置。 */
+const calendarPlaces = (sentence: Sentence, units: CalendarUnits): ReadonlyMap<number, CalendarRun["place"]> =>
+  new Map(calendarRuns(sentence.text, sentence.tokens, sentence.span.start, units).map(({ run, place }) => [run.start, place]));
+
+/**
+ * 日付・時刻の中の境目（「9月」の数と単位のあいだ、「2026年9月」の年と 9 のあいだ）は、詰めて書く決まりで好みではない。
+ * 日付の前の境目（「は 9月」の空白）は、数の前をどう空けるかという書き手の書き方なので数える。
+ */
+const isInsideCalendar = (boundary: Boundary, place: CalendarRun["place"] | undefined): boolean =>
+  place !== undefined && (boundary.kind === "after-digit" || place === "inner");
+
+/** 番号・識別子として書かれた数（number-name.ts）と日付・時刻の中の境目は、空け方の好みではないので数えない。 */
+const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, calendar: ReadonlyMap<number, CalendarRun["place"]>): boolean => {
   if (boundary.kind === "letter") return true;
   const run = digitRunAround(sentence.text, digitBeside(boundary));
-  return run === undefined || !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, sequence, topUnits);
+  if (run === undefined) return true;
+  if (isInsideCalendar(boundary, calendar.get(run.start))) return false;
+  return !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, context.sequence, context.topUnits);
 };
 
+const patternList = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+const patternsOf = (doc: ProseDocument, id: string): ReadonlySet<string> => new Set(patternList(doc, id));
+
 /**
  * 鉤括弧で引いた題名や発言（「…ガイドライン ver. 1.1」）の中の境目。空け方は引いた元のもので、書き手の書き方ではない。
  * 括弧は日本語の字でも英数字でもないので、境目はまるごと括弧の中か外にある。
@@ -50,12 +70,16 @@ const isQuoted = (quoted: readonly Span[], boundary: Boundary): boolean => isWit
  */
 export const latinSpacing: Detector = (doc, options): Finding[] => {
   // 覆った文（prose）で探す。コードの中の「1 件」は並びに入れない。
-  const sequence = sequenceLabelStarts(doc.prose ?? doc.source);
-  const topUnits = new Set((doc.lexicons["prefecture-unit"] ?? []).map((entry) => entry.pattern));
+  const context: NumberContext = {
+    sequence: sequenceLabelStarts(doc.prose ?? doc.source),
+    topUnits: patternsOf(doc, "prefecture-unit"),
+    calendar: { chained: patternList(doc, "date-time-unit"), positional: patternsOf(doc, "calendar-unit"), year: patternsOf(doc, "calendar-year-unit") },
+  };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);
+    const calendar = calendarPlaces(sentence, context.calendar);
     return latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
-      .filter((boundary) => !isQuoted(quoted, boundary) && isCounted(sentence, boundary, sequence, topUnits))
+      .filter((boundary) => !isQuoted(quoted, boundary) && isCounted(sentence, boundary, context, calendar))
       .map((boundary) => ({ sentence, ...boundary }));
   });
   return KINDS.flatMap((kind) => {

package/src/detectors/phrase-match.ts

@@ -1,4 +1,4 @@
-import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
 import { entryIn } from "./lexicon-match.ts";
 
 /** 冒頭は先頭 2 段落ぶん。「どの記事にも当てはまる書き出し」は冒頭にあるときだけ問題。 */
@@ -22,21 +22,32 @@ const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon): Hit[] =>
     return matched === undefined ? [] : [{ sentence, matched: matched.pattern }];
   });
 
-/**
- * 語彙表との照合。detector は共通で、語彙だけが言語別に差し替わる。spec §11。
- * これが L2 の全体像で、新しい言語は語彙表を書くだけで動く。
- */
-export const phraseMatch: Detector = (doc, options): Finding[] => {
-  const lexicon = options.lexicon ?? [];
-  if (lexicon.length === 0) return [];
-  const hits = hitsIn(inScope(doc, options.where), lexicon);
-  if (hits.length < options.limit) return [];
-  return hits.map((hit) => ({
+const findingsOf = (hits: readonly Hit[], limit: number): Finding[] =>
+  hits.map((hit) => ({
     rule: "",
     severity: "warning",
     line: 0,
     column: 0,
     quote: hit.sentence.text.trim(),
-    values: { matched: hit.matched, count: hits.length, limit: options.limit, offset: hit.sentence.span.start },
+    values: { matched: hit.matched, count: hits.length, limit, offset: hit.sentence.span.start },
   }));
+
+const phraseHits = (doc: ProseDocument, options: DetectorOptions): Hit[] => {
+  const lexicon = options.lexicon ?? [];
+  return lexicon.length === 0 ? [] : hitsIn(inScope(doc, options.where), lexicon);
+};
+
+/**
+ * 語彙表との照合。detector は共通で、語彙だけが言語別に差し替わる。spec §11。
+ * これが L2 の全体像で、新しい言語は語彙表を書くだけで動く。limit は指摘に要る数で、1 なら 1 つ目から言う。
+ */
+export const phraseMatch: Detector = (doc, options): Finding[] => {
+  const hits = phraseHits(doc, options);
+  return hits.length < options.limit ? [] : findingsOf(hits, options.limit);
+};
+
+/** 回数に上限がある語。limit は許す回数で、それを超えたときだけ言う。message の「N 回まで」と同じ向き。 */
+export const phraseCount: Detector = (doc, options): Finding[] => {
+  const hits = phraseHits(doc, options);
+  return hits.length <= options.limit ? [] : findingsOf(hits, options.limit);
 };

package/src/detectors/repeated-head.ts

@@ -35,10 +35,9 @@ const runsOf = (sentences: readonly Sentence[], unit: LengthUnit, lists: readonl
     // 短すぎる書き出しは「同じ」と言えない。単位ぶん揃って初めて連なりと見る。
     const full = unit === "char" ? head.length === HEAD_CHARS : head.split(" ").length === HEAD_WORDS;
     const joins = last !== undefined && last.head === head && last.container === container && !listBetween(last.members.at(-1), sentence, lists);
-    if (last !== undefined && joins && full) {
-      return [...acc.slice(0, -1), { head, container, members: [...last.members, sentence] }];
-    }
-    return [...acc, { head, container, members: [sentence] }];
+    if (last !== undefined && joins && full) acc[acc.length - 1] = { head, container, members: [...last.members, sentence] };
+    else acc.push({ head, container, members: [sentence] });
+    return acc;
   }, []);
 
 export const repeatedHead: Detector = (doc, options): Finding[] =>

package/src/detectors/signals.ts

@@ -6,7 +6,9 @@ import { expansionAt, type ExpandedAt } from "./acronym-expansion.ts";
 import { isExplained } from "./acronym-compound.ts";
 import { conjugatedForms } from "./conjugated-form.ts";
 import { evidenceSpans, hasNumeral, startsWithin } from "./concrete-evidence.ts";
+import { letteredIndexEntries } from "./lettered-index.ts";
 import { hasPredicateIn } from "./gram-predicate.ts";
+import { nameSpans, touchesAny } from "../team-names.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence } from "../plugin.ts";
 
 const PER = 1000;
@@ -62,9 +64,12 @@ export const emojiDensity: Detector = (doc, options): Finding[] => {
  */
 const GRAM = { char: 8, word: 20 };
 
-const countGrams = (text: string, width: number): Map<string, number> => {
+/** 並べた名前にかかる語句は数えない。名前が繰り返されれば、その前後（「the …」）も一緒に繰り返されるのは当たり前。 */
+const countGrams = (text: string, width: number, names: readonly string[]): Map<string, number> => {
   const counts = new Map<string, number>();
+  const named = nameSpans(text, names);
   Array.from({ length: Math.max(0, text.length - width + 1) }).forEach((_, index) => {
+    if (touchesAny(named, index, index + width)) return;
     const gram = text.slice(index, index + width);
     counts.set(gram, (counts.get(gram) ?? 0) + 1);
   });
@@ -93,7 +98,8 @@ const gramsOf = (doc: ProseDocument): Map<string, number> => {
   const counts = new Map<string, number>();
   doc.sentences.forEach((sentence) => {
     const text = doc.lengthUnit === "char" ? proseText(sentence).replace(/\s+/gu, "") : proseText(sentence);
-    countGrams(text, GRAM[doc.lengthUnit]).forEach((count, gram) => counts.set(gram, (counts.get(gram) ?? 0) + count));
+    const names = doc.lengthUnit === "char" ? (doc.names ?? []).map((name) => name.replace(/\s+/gu, "")) : (doc.names ?? []);
+    countGrams(text, GRAM[doc.lengthUnit], names).forEach((count, gram) => counts.set(gram, (counts.get(gram) ?? 0) + count));
   });
   return counts;
 };
@@ -117,7 +123,7 @@ export const ngramRepetition: Detector = (doc, options): Finding[] => {
   const sentenceWith = (gram: string): Sentence | undefined => doc.sentences.find((sentence) => gramText(sentence, doc.lengthUnit).includes(gram));
   const worst = [...gramsOf(doc).entries()]
     .filter(([gram, count]) => count > options.limit && isPhrasing(gram, doc.lengthUnit))
-    .sort(([, left], [, right]) => right - left)
+    .toSorted(([, left], [, right]) => right - left)
     .map(([gram, count]) => ({ gram, count, at: sentenceWith(gram) }))
     .find(({ gram, at }) => at === undefined || hasPredicate(gram, at, doc.lengthUnit));
   if (worst === undefined) return [];
@@ -194,9 +200,10 @@ const spansOf = (text: string, notation: NotAcronymSpans): Span[] => [
 
 type AcronymHit = { readonly word: string; readonly hit: Hit };
 
+/** チームが並べた名前の中の略語（NTT Docomo の NTT）は、名前の一部であって説明を待つ略語ではない。 */
 const acronymsOf = (doc: ProseDocument, notation: NotAcronymSpans): AcronymHit[] =>
   doc.sentences.flatMap((sentence) => {
-    const excluded = spansOf(sentence.text, notation);
+    const excluded = [...spansOf(sentence.text, notation), ...nameSpans(sentence.text, doc.names ?? [])];
     return [...sentence.text.matchAll(ACRONYM)]
       .filter((match) => !excluded.some((span) => span.start <= match.index && match.index + match[0].length <= span.end))
       .map((match) => ({ word: match[0], hit: { sentence, offset: sentence.span.start + match.index } }));
@@ -232,7 +239,8 @@ const definitionVerbsOf = (doc: ProseDocument): string[] => {
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
   // HTTP のメソッド名（GET）は略語ではないので、通じる略語と同じく展開を求めない。
-  const common = new Set([...(options.lexicon ?? []).map((entry) => entry.pattern), ...patternsOf(doc, "http-method")]);
+  // 並べた名前（JAXA）も、繋いだ略語（JAXA-ISAS）の片割れとして説明済みに数える。
+  const common = new Set([...(options.lexicon ?? []).map((entry) => entry.pattern), ...patternsOf(doc, "http-method"), ...(doc.names ?? [])]);
   const seen = new Map<string, Hit>();
   acronymsOf(doc, notationOf(doc)).forEach(({ word, hit }) => {
     if (!seen.has(word)) seen.set(word, hit);
@@ -273,7 +281,8 @@ const openingOf = (sentence: Sentence | undefined, unit: ProseDocument["lengthUn
 const hasNumeralIn = (section: Section): boolean => section.sentences.some((sentence) => hasNumeral(sentence.tokens ?? []));
 
 export const concreteEvidence: Detector = (doc, options): Finding[] => {
-  const sections = doc.sections.filter((section) => section.sentences.length >= 3);
+  const entries = letteredIndexEntries(doc.sections);
+  const sections = doc.sections.filter((section) => section.sentences.length >= 3 && !entries.has(section));
   const bare = sections.filter(
     (section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)) && !hasNumeralIn(section) && !startsWithin(section.span, doc.links),
   );

package/src/detectors/stacked-hedge.ts

@@ -0,0 +1,93 @@
+import type { Lexicon, Sentence, Span, Token } from "../plugin.ts";
+import { entryRanges, type TokenRange } from "./lexicon-match.ts";
+import { isWithinAny, quotedIn, QUOTATION_MARKS } from "../quoted-span.ts";
+
+/** 重ねたと言うのに要る数。1 つなら慎重さで、2 つ目からは読み手が何を言い切ったのか分からなくなる。 */
+export const STACKED_AT = 2;
+
+/**
+ * 語彙表 3 つ。hedges は逃げの表現そのもの、frames はそれだけでは逃げていない包む言い方（「という状況です」、may）、
+ * scope は hedges のうち、どれだけ確かかではなくどこで成り立つかを言うもの（「場合がある」、in some cases）。
+ */
+export type HedgeWords = { readonly hedges: Lexicon; readonly frames: Lexicon; readonly scope: Lexicon };
+
+type Device = { readonly range: TokenRange; readonly hedge: boolean };
+
+export type StackedHedge = { readonly sentence: Sentence; readonly spans: readonly Span[] };
+
+const rangesOf = (sentence: Sentence, lexicon: Lexicon): TokenRange[] => lexicon.flatMap((entry) => entryRanges(sentence, entry));
+
+const contains = (outer: TokenRange, inner: TokenRange): boolean => outer.start <= inner.start && inner.end <= outer.end;
+
+const sameRange = (left: TokenRange, right: TokenRange): boolean => left.start === right.start && left.end === right.end;
+
+/**
+ * 同じ語に当たった見出しは 1 つに数える。「could」は「it could be」の一部。
+ * 同じ範囲に hedge と frame が両方当たったら hedge として残す（devices は hedge が先に並んでいる）。
+ */
+const outermost = (devices: readonly Device[]): Device[] =>
+  devices.filter(
+    (device, index) =>
+      !devices.some((other, at) => at !== index && contains(other.range, device.range) && (!sameRange(other.range, device.range) || at < index)),
+  );
+
+/** 語の並びの、文書全体の座標での範囲。 */
+const spanOf = (tokens: readonly Token[], range: TokenRange): Span | undefined => {
+  const first = tokens[range.start];
+  const last = tokens[range.end - 1];
+  return first === undefined || last === undefined ? undefined : { start: first.span.start, end: last.span.end };
+};
+
+/** 句読点と等位接続詞（and、but、及び）は節を切る。別の節の逃げは、同じ主張を二重にぼかしていない。 */
+const CLAUSE_BREAK = new Set(["PUNCT", "CCONJ"]);
+
+/** 語ごとの、文の頭から数えた節の番号。 */
+const clauseOf = (tokens: readonly Token[]): number[] =>
+  tokens.reduce<number[]>((clauses, token) => [...clauses, (clauses.at(-1) ?? 0) + (CLAUSE_BREAK.has(token.pos) ? 1 : 0)], []);
+
+const PREDICATE = new Set(["VERB", "AUX"]);
+
+/** 見せる範囲。活用する語で終わる見出し（と考えられる）は、後ろの助動詞（ます）まで含めて書いたとおりに見せる。 */
+const shownEnd = (tokens: readonly Token[], range: TokenRange): number => {
+  const last = tokens[range.end - 1];
+  if (last === undefined || !PREDICATE.has(last.pos)) return range.end;
+  const stop = tokens.findIndex((token, at) => at >= range.end && token.pos !== "AUX");
+  return stop === -1 ? tokens.length : stop;
+};
+
+/** 書き手の言葉で、どこで成り立つかを言う語ではない見出し。引用（「」『』“” "）の中は話し手の言葉。 */
+const devicesIn = (sentence: Sentence, words: HedgeWords): Device[] => {
+  const tokens = sentence.tokens ?? [];
+  const quoted = quotedIn(sentence, QUOTATION_MARKS);
+  const scope = rangesOf(sentence, words.scope);
+  const hedges = rangesOf(sentence, words.hedges).filter((range) => !scope.some((outer) => contains(outer, range)));
+  const devices = [...hedges.map((range) => ({ range, hedge: true })), ...rangesOf(sentence, words.frames).map((range) => ({ range, hedge: false }))];
+  return outermost(devices).filter((device) => {
+    const span = spanOf(tokens, device.range);
+    return span !== undefined && !isWithinAny(quoted, span);
+  });
+};
+
+/** 1 つの節に 2 つ以上あり、そのうち 1 つ以上が逃げの表現そのもの。包む言い方だけ（「という状況です」）は逃げていない。 */
+const stackedClause = (devices: readonly Device[], clauses: readonly number[]): Device[] => {
+  const clauseAt = (device: Device): number => clauses[device.range.start] ?? 0;
+  const groups = [...new Set(devices.map(clauseAt))].map((clause) => devices.filter((device) => clauseAt(device) === clause));
+  return groups.find((group) => group.length >= STACKED_AT && group.some((device) => device.hedge)) ?? [];
+};
+
+/**
+ * 1 つの文の 1 つの節に、逃げの表現を重ねているか。business-blog-harness-spec §7.2。見せる範囲を文の中の順で返す。重ねていなければ空。
+ * 品詞が無ければ語の位置が分からないので何も言わない。
+ */
+export const stackedHedgeIn = (sentence: Sentence, words: HedgeWords): Span[] => {
+  const tokens = sentence.tokens ?? [];
+  return stackedClause(devicesIn(sentence, words), clauseOf(tokens))
+    .toSorted((left, right) => left.range.start - right.range.start)
+    .flatMap((device) => spanOf(tokens, { start: device.range.start, end: shownEnd(tokens, device.range) }) ?? []);
+};
+
+export const stackedHedges = (sentences: readonly Sentence[], words: HedgeWords): StackedHedge[] =>
+  sentences.flatMap((sentence) => {
+    const spans = stackedHedgeIn(sentence, words);
+    return spans.length === 0 ? [] : [{ sentence, spans }];
+  });

package/src/detectors/superlative-amount.ts

@@ -0,0 +1,24 @@
+import type { Lexicon, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+
+/** 名詞の後ろにこれが続けば、その名詞は句の頭ではない。解析器は形容詞を名詞と読むことがある（the most frigid weather・the most cost-effective）。 */
+const JOINED = new Set(["NOUN", "PROPN", "ADJ", "X"]);
+
+const listed = (tokens: readonly Token[], range: TokenRange, amounts: Lexicon): boolean => {
+  const words = tokens
+    .slice(range.start, range.end)
+    .map((token) => token.surface.toLowerCase())
+    .join(" ");
+  return amounts.some((entry) => entry.pattern.toLowerCase() === words);
+};
+
+/**
+ * 量も言う最上級に、句の頭になる名詞がそのまま続くか（the most work・the most students・for the most part）。
+ * それは一番多いものを言っていて、何かが一番良いという主張ではない。形容詞を挟めば（the most powerful tool）主張のまま。
+ * どの最上級が量を言うかは言語パッケージの語彙表 superlative-amount が持つ。
+ */
+export const namesAmount = (tokens: readonly Token[], range: TokenRange, amounts: Lexicon): boolean => {
+  const noun = tokens[range.end];
+  const after = tokens[range.end + 1];
+  return listed(tokens, range, amounts) && noun?.pos === "NOUN" && (after === undefined || !JOINED.has(after.pos));
+};