chaffjs 0.15.0 → 0.17.0

package/src/detectors/content-morphemes.ts

@@ -0,0 +1,19 @@
+// What a sentence adds to a heading, counted in content morphemes: words that stand by themselves and name something.
+// Pure; heading-echo measures a language written without spaces with it, where a character count says nothing
+// (「会社に勤めています」 carries two new words, 「について説明します」 one, in the same nine characters).
+import type { Token } from "../plugin.ts";
+
+/** 代名詞・連体詞・接続詞は、すでに書いたものを指すかつなぐだけで、中身を足さない。 */
+const CONTENT_POS = new Set(["NOUN", "PROPN", "NUM", "VERB", "ADJ", "ADV"]);
+
+/** 接頭詞・接尾・非自立の語（Bound）と、動詞にするだけの「する」（VerbType=Light）は、付いた語が中身を持つ。 */
+const isContent = (token: Token): boolean => CONTENT_POS.has(token.pos) && token.features?.["Bound"] !== "Yes" && token.features?.["VerbType"] !== "Light";
+
+/** 原形で照らす（変えました → 変える）。原形の無い語は書いた形で。 */
+const baseForm = (token: Token): string => (token.lemma ?? token.surface).toLowerCase();
+
+/** The sentence's content morphemes whose base form is not one of the heading's content morphemes, every occurrence counted. */
+export const newContentMorphemes = (heading: readonly Token[], sentence: readonly Token[]): number => {
+  const said = new Set(heading.filter(isContent).map(baseForm));
+  return sentence.filter((token) => isContent(token) && !said.has(baseForm(token))).length;
+};

package/src/detectors/en-shape.ts

@@ -79,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]];
     },
     [[]],
@@ -134,174 +134,3 @@ export const titleCaseMix: Detector = (doc, options): Finding[] => {
     values: { count: few.length, limit: options.limit, offset: section.span.start },
   }));
 };
-
-const LIST_CONJUNCTION = new Set(["and", "or"]);
-
-const isComma = (token: Token): boolean => token.surface === ",";
-
-const commaBefore = (tokens: readonly Token[], at: number): boolean => tokens[at - 1]?.surface === ",";
-
-/** 並列はこれをまたがない。セミコロンの前後は別の節。 */
-const CLAUSE_BREAK = new Set([";", ":", "—"]);
-
-/** 各 token の前で閉じていない括弧の数。括弧の中の読点（external users (e.g., guests), and ...）は外の並列を切らない。 */
-const PAREN_STEP: Readonly<Record<string, number>> = { "(": 1, ")": -1 };
-
-const depthsOf = (tokens: readonly Token[]): number[] =>
-  tokens.reduce<{ depths: number[]; open: number }>(
-    (acc, token) => ({ depths: [...acc.depths, acc.open], open: Math.max(0, acc.open + (PAREN_STEP[token.surface] ?? 0)) }),
-    { depths: [], open: 0 },
-  ).depths;
-
-type Clause = { readonly tokens: readonly Token[]; readonly depths: readonly number[] };
-
-/** 冠詞や引用符を飛ばした、項目の頭の品詞。the parser と an exporter と samples を同じ形と見る。 */
-const NOMINAL = new Set(["NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
-
-const isContent = (token: Token): boolean => token.pos !== "DET" && token.pos !== "PUNCT" && token.pos !== "X";
-
-const shapeOf = (item: readonly Token[]): string | undefined => {
-  const head = item.find(isContent);
-  if (head === undefined) return undefined;
-  return NOMINAL.has(head.pos) ? "NOMINAL" : head.pos;
-};
-
-const VERBAL = new Set(["VERB", "AUX"]);
-
-/** 主語と述語のある項目。the team fixed the bug / these are crucial。gets us more は述語だけ。 */
-const isClause = (item: readonly Token[]): boolean => {
-  const first = item.find((token) => token.pos !== "PUNCT" && token.pos !== "X");
-  if (first === undefined || !(first.pos === "DET" || NOMINAL.has(first.pos))) return false;
-  return item.some((token) => token !== first && VERBAL.has(token.pos));
-};
-
-/** 節の頭から and / or の手前までを、同じ深さの読点で項目に切る。Oxford comma の読点のあとは空なので項目にならない。 */
-const itemsBefore = (clause: Clause, at: number): Token[][] => {
-  const level = clause.depths[at] ?? 0;
-  const start = clause.tokens.slice(0, at).findLastIndex((token) => CLAUSE_BREAK.has(token.surface)) + 1;
-  return clause.tokens
-    .slice(start, at)
-    .reduce<Token[][]>(
-      (items, token, offset) => {
-        if (isComma(token) && clause.depths[start + offset] === level) return [...items, []];
-        return [...items.slice(0, -1), [...(items.at(-1) ?? []), token]];
-      },
-      [[]],
-    )
-    .filter((item) => item.length > 0);
-};
-
-/** 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)));
-  return tokens.slice(at + 1, end === -1 ? undefined : end);
-};
-
-/**
- * 導入の句（After the review, / If it fails, / Finally, / To test it, / Based on the review,）は並列の項目ではない。
- * 節の最初の項目が前置詞・接続詞・副詞・to・過去分詞で始まり、次の項目と頭の形が違えば外す。
- * Quickly, quietly and carefully は残る。For managers, engineers and designers, も外れるが、前置詞のあとの名詞を
- * 項目と読むと、Over this period, the subcommittees and the full committee ... を並びと誤る。こちらのほうが多い。
- */
-const LEAD_POS = new Set(["ADP", "SCONJ", "ADV", "PART"]);
-
-const isParticiple = (token: Token): boolean => token.features?.["VerbForm"] === "Part";
-
-const openingOf = (item: readonly Token[]): Token | undefined => item.find((token) => token.pos !== "PUNCT" && token.pos !== "X");
-
-const openingKind = (item: readonly Token[]): string | undefined => {
-  const opening = openingOf(item);
-  return opening !== undefined && isParticiple(opening) ? "PARTICIPLE" : shapeOf(item);
-};
-
-const withoutLead = (items: readonly Token[][]): readonly Token[][] => {
-  const [first, second] = items;
-  const opening = first === undefined ? undefined : openingOf(first);
-  if (first === undefined || second === undefined || opening === undefined) return items;
-  if (!LEAD_POS.has(opening.pos) && !isParticiple(opening)) return items;
-  return openingKind(first) === openingKind(second) ? items : items.slice(1);
-};
-
-/**
- * 形容詞のあとの読点は、名詞の前で形容詞を重ねているだけのことが多い（the long, winding bridge）。
- * 次の項目が名詞で終わるならつなげ直す。形容詞そのものの並び（quick, cheap and reliable）は切ったまま。
- */
-const lastContent = (item: readonly Token[]): Token | undefined => item.findLast(isContent);
-
-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];
-  }, []);
-
-/**
- * 節を並べるなら、どの項目も節。Additionally, others can learn, and the mistake is rarer. の
- * Additionally は項目ではなく、and の前の読点は節をつなぐ読点。名詞の並びは最初の項目に前置き
- * （We shipped the parser）を抱えるので、この確かめは節の並びだけにする。
- * and の後ろだけが節なのは主語の並び（The parser, the renderer and the exporter shipped.）なので外さない。
- */
-const clausesAgree = (items: readonly Token[][], after: readonly Token[]): boolean => {
-  const last = items.at(-1);
-  if (last === undefined || !isClause(last)) return true;
-  return isClause(after) && items.every(isClause);
-};
-
-/**
- * 動詞で始まる項目を並べるなら、どの項目にも動詞がある。The scope, in contrast, is larger, and covers ... の
- * The scope は項目ではなく、後ろの述語の主語。
- */
-const hasVerb = (item: readonly Token[]): boolean => item.some((token) => VERBAL.has(token.pos));
-
-const predicatesAgree = (items: readonly Token[][], shape: string): boolean => !VERBAL.has(shape) || items.every(hasVerb);
-
-/**
- * 読点で区切った項目が 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 last = items.at(-1);
-  const shape = last === undefined ? undefined : shapeOf(last);
-  if (items.length < 2 || shape === undefined || shape !== shapeOf(after)) return undefined;
-  if (!clausesAgree(items, after) || !predicatesAgree(items, shape)) return undefined;
-  return commaBefore(clause.tokens, at);
-};
-
-/**
- * 3 つ以上の並列の最後の and / or の前に読点を打つか。Oxford comma。
- *
- * どちらが正しいかは決めない。スタイルガイドで割れる論点に立場を取ると rule ごと無視される。
- * 見るのは 1 つの文書で揃っているかだけ。spec §12.3。
- */
-const oxfordIn = (tokens: readonly Token[]): boolean | undefined => {
-  const clause = { tokens, depths: depthsOf(tokens) };
-  return tokens.reduce<boolean | undefined>(
-    (found, token, at) => found ?? (at > 0 && LIST_CONJUNCTION.has(token.surface.toLowerCase()) ? listAt(clause, at) : undefined),
-    undefined,
-  );
-};
-
-export const oxfordComma: Detector = (doc, options): Finding[] => {
-  const judged = doc.sentences.flatMap((sentence) => {
-    const oxford = oxfordIn(sentence.tokens ?? []);
-    return oxford === undefined ? [] : [{ sentence, oxford }];
-  });
-  const withComma = judged.filter((entry) => entry.oxford).length;
-  const minorityUsesComma = withComma <= judged.length - withComma;
-  const few = minorityUsesComma ? withComma : judged.length - withComma;
-  // 同数なら少数派は無い。
-  if (few === 0 || few * 2 === judged.length || few > options.limit) return [];
-  return judged
-    .filter((entry) => entry.oxford === minorityUsesComma)
-    .map(({ sentence }) => ({
-      rule: "oxford-comma-consistency",
-      severity: "info",
-      line: 0,
-      column: 0,
-      quote: sentence.text.trim(),
-      values: { count: few, limit: options.limit, offset: sentence.span.start },
-    }));
-};

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/heading-echo.ts

@@ -1,4 +1,6 @@
-import { lengthOf } from "../measure.ts";
+import { lengthOf, proseText } from "../measure.ts";
+import { newContentMorphemes } from "./content-morphemes.ts";
+import { echoedHeadingUnits, trigrams } from "./heading-overlap.ts";
 import { handsOver } from "./lead-in.ts";
 import { withoutQuotedVariants } from "./quoted-variant.ts";
 import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../plugin.ts";
@@ -6,17 +8,6 @@ import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../p
 /** 見出しが短すぎると、偶然の一致で 100% になる。これ未満の見出しは見ない。 */
 const MIN_GRAMS = 4;
 
-/**
- * 文字 3-gram で測る。
- * 語 n-gram にすると wordSplit capability が要り、L1（言語を問わず動く）から外れる。
- */
-const trigrams = (text: string): Set<string> => {
-  // 大文字小文字を畳む。英語では見出しが Title Case、本文が小文字になり、
-  // 同じ語でも一致しなくなる（Generating Output → generated output）。
-  const clean = [...text.toLowerCase().replace(/\s+/gu, "")];
-  return new Set(clean.slice(0, Math.max(0, clean.length - 2)).map((__char, index) => clean.slice(index, index + 3).join("")));
-};
-
 /**
  * Jaccard ではなく包含率を使う。
  *
@@ -39,18 +30,19 @@ const containment = (heading: Set<string>, sentence: Set<string>): number => {
  */
 const NEW_MATERIAL = { word: 6, char: 20 };
 
-const headingUnits = (heading: string, unit: LengthUnit): number =>
-  unit === "word"
-    ? heading
-        .trim()
-        .split(/\s+/u)
-        .filter((word) => word.length > 0).length
-    : heading.replace(/\s+/gu, "").length;
+/**
+ * 空白で語を分けない言語は、品詞が読めれば文字ではなく見出しに無い内容語で測る。文字数は中身の量を言わない:
+ * 「会社に勤めています」は 9 文字で 会社・勤める を足し、「について説明します」は同じ 9 文字で 説明 しか足さない。
+ * 内容語 2 つで足りる（こころさんのお父さんは、会社に勤めています。）。日本語の corpus で測った（yarn corpus）。
+ */
+const NEW_CONTENT_MORPHEMES = 1;
 
 const addsLittle = (section: Section, unit: LengthUnit): boolean => {
   const first = section.firstSentence;
   if (first === undefined) return false;
-  return lengthOf(first, unit) - headingUnits(section.heading, unit) <= NEW_MATERIAL[unit];
+  if (unit === "char" && first.tokens !== undefined && section.headingTokens !== undefined)
+    return newContentMorphemes(section.headingTokens, first.tokens) <= NEW_CONTENT_MORPHEMES;
+  return lengthOf(first, unit) - echoedHeadingUnits(section.heading, proseText(first), unit) <= NEW_MATERIAL[unit];
 };
 
 /** 最初の文が、同じ節の後ろ（箇条書き・表・コード）へ読者を渡している。 */

package/src/detectors/heading-overlap.ts

@@ -0,0 +1,65 @@
+// How much of a section's heading its first sentence takes up: the heading's character trigrams, and the part of the
+// heading the sentence repeats, in the document's length unit. Pure; heading-echo decides with these.
+import type { LengthUnit } from "../plugin.ts";
+
+const foldedChars = (text: string): string[] => [...text.toLowerCase().replace(/\s+/gu, "")];
+
+const trigramAt = (chars: readonly string[], index: number): string => chars.slice(index, index + 3).join("");
+
+/**
+ * 文字 3-gram で測る。
+ * 語 n-gram にすると wordSplit capability が要り、L1（言語を問わず動く）から外れる。
+ */
+export const trigrams = (text: string): Set<string> => {
+  // 大文字小文字を畳む。英語では見出しが Title Case、本文が小文字になり、
+  // 同じ語でも一致しなくなる（Generating Output → generated output）。
+  const clean = foldedChars(text);
+  return new Set(clean.slice(0, Math.max(0, clean.length - 2)).map((__char, index) => trigramAt(clean, index)));
+};
+
+/** A word as compared across heading and sentence: case folded, the punctuation around it dropped ("Spacewalks?" is spacewalks). */
+const foldedWord = (word: string): string => {
+  const chars = [...word.toLowerCase()];
+  const isWordChar = (char: string): boolean => /[\p{L}\p{N}]/u.test(char);
+  return chars.slice(chars.findIndex(isWordChar), chars.findLastIndex(isWordChar) + 1).join("");
+};
+
+const headingWords = (heading: string): string[] =>
+  heading
+    .trim()
+    .split(/\s+/u)
+    .filter((word) => word.length > 0);
+
+/** Below this length a word repeats another only as itself: "on" is not repeated by "one", nor "go" by "going". */
+const MIN_STEM = 4;
+
+/** The same word, or one of them the other with an ending added (level → levels, reference → references). */
+const isSameWord = (headingWord: string, sentenceWord: string): boolean => {
+  if (headingWord === sentenceWord) return true;
+  const [shorter, longer] = headingWord.length < sentenceWord.length ? [headingWord, sentenceWord] : [sentenceWord, headingWord];
+  return shorter.length >= MIN_STEM && longer.startsWith(shorter);
+};
+
+/** The heading's words that the sentence repeats; a word of punctuation alone is never repeated. */
+const echoedWords = (heading: string, sentence: string): number => {
+  const said = sentence.split(/\s+/u).map(foldedWord);
+  return headingWords(heading)
+    .map(foldedWord)
+    .filter((word) => word !== "" && said.some((other) => isSameWord(word, other))).length;
+};
+
+/** The heading's characters (spaces aside) that a trigram the sentence also has covers. */
+const echoedChars = (heading: string, sentence: string): number => {
+  const said = trigrams(sentence);
+  const clean = foldedChars(heading);
+  const covered = new Set(clean.flatMap((__char, index) => (said.has(trigramAt(clean, index)) ? [index, index + 1, index + 2] : [])));
+  return covered.size;
+};
+
+/**
+ * How much of the heading the sentence repeats, in the document's length unit. A sentence that repeats only part of it
+ * ("How Do Astronauts Go on Spacewalks?" → "When astronauts go on spacewalks, they wear spacesuits…") keeps the rest of
+ * its length as its own material.
+ */
+export const echoedHeadingUnits = (heading: string, sentence: string, unit: LengthUnit): number =>
+  unit === "word" ? echoedWords(heading, sentence) : echoedChars(heading, sentence);

package/src/detectors/index.ts

@@ -4,18 +4,21 @@ 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 { agreementSlip } from "./agreement-slip.ts";
 import { sentenceEnding } from "./sentence-ending.ts";
 import { doubledParticle, nounEnding } from "./token-shape.ts";
 import { kanjiRun, middleDot } from "./char-shape.ts";
-import { adverbDensity, conjunctionRun, expletive, oxfordComma, titleCaseMix } from "./en-shape.ts";
+import { adverbDensity, conjunctionRun, expletive, titleCaseMix } from "./en-shape.ts";
+import { oxfordComma } from "./oxford-comma.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 { straySpace } from "./stray-space.ts";
 import { danglingReference, dateOrder, dateWeekdayMismatch, duplicateDefinition, numberingGap, totalMismatch } from "./structure-tree.ts";
 
 /** rule 定義の how_to_find がここを引く。rule 側は実装を知らない。 */
@@ -26,11 +29,13 @@ 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,
   "doubled-particle": doubledParticle,
   "doubled-word": doubledWord,
+  "agreement-slip": agreementSlip,
   "kanji-run": kanjiRun,
   "middle-dot": middleDot,
   "adverb-density": adverbDensity,
@@ -48,7 +53,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,
@@ -59,6 +64,7 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "proper-noun-density": properNounDensity,
   "preferred-term": preferredTerm,
   "latin-spacing": latinSpacing,
+  "stray-space": straySpace,
   "dangling-reference": danglingReference,
   "date-weekday-mismatch": dateWeekdayMismatch,
   "date-order": dateOrder,

package/src/detectors/letter-joined-name.ts

@@ -0,0 +1,15 @@
+/**
+ * 一文字を - で語の前に繋いだ名前（J-STAGE、X-RAY、T-Mobile、e-Gov）。前の一文字が新しい名前を作るので、中の大文字の語は
+ * 略語ではない（J-STAGE は STAGE の説明を待たない）。後ろに一文字を繋いだ語（ITU-T、GOODS-S）は略語の一種で、略語は
+ * 説明を待つまま。部品が二つとも二文字以上（RT-PCR）なら繋いだ略語のまま。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+// 語を空白で区切る文字（é、α、分けて書いた e と ́）や数字が接していれば長い語の一部。仮名や漢字は接していてよい（論文はJ-STAGEで）。
+const SPACED_WORD_CHAR = String.raw`\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}\p{M}\p{N}_&`;
+const LETTER_JOINED_NAME = new RegExp(String.raw`(?<![${SPACED_WORD_CHAR}.-])[A-Za-z]-[A-Za-z]{2,}(?![${SPACED_WORD_CHAR}-]|\.[A-Za-z0-9])`, "gu");
+
+/** 文の中の、一文字を - で語の前に繋いだ名前の範囲。 */
+export const letterJoinedNameSpans = (text: string): Span[] =>
+  [...text.matchAll(LETTER_JOINED_NAME)].map((match) => ({ start: match.index, end: match.index + match[0].length }));

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,13 @@
 import { joinWords } from "./word-list.ts";
+import { straightApostrophes } from "../orthography.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 +41,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 =>
@@ -170,9 +228,12 @@ export const aiTell: Detector = (doc, options): Finding[] => {
  */
 const containsWord = (text: string, word: string): boolean => new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\b`, "u").test(text);
 
+/** アポストロフィの形（don’t と don't）は短縮形かどうかを変えない。違うのは印刷の形で、文体ではない。 */
+const comparableText = (sentence: Sentence): string => straightApostrophes(sentence.text).toLowerCase();
+
 export const contractionMix: Detector = (doc, options): Finding[] => {
   const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ short: entry.pattern, long: entry.instead_of }]));
-  const body = doc.sentences.map((sentence) => sentence.text.toLowerCase()).join(" ");
+  const body = doc.sentences.map(comparableText).join(" ");
   const used = pairs.filter((pair) => containsWord(body, pair.short.toLowerCase()));
   const spelled = pairs.filter((pair) => containsWord(body, pair.long.toLowerCase()));
   // 片方しか無ければ一貫している。両方あるときだけ、少数派を指摘する。
@@ -182,7 +243,7 @@ export const contractionMix: Detector = (doc, options): Finding[] => {
   if (few.length > options.limit) return [];
   const wanted = few.map((pair) => (minorityIsShort ? pair.short : pair.long).toLowerCase());
   const hits = doc.sentences.flatMap((sentence) => {
-    const text = sentence.text.toLowerCase();
+    const text = comparableText(sentence);
     const matched = wanted.find((word) => containsWord(text, word));
     return matched === undefined ? [] : [{ sentence, matched }];
   });