chaffjs 0.17.0 → 0.18.0

package/src/detectors/register.ts

@@ -15,21 +15,32 @@ const chainAtEnd = (preceding: readonly Token[]): readonly Token[] => {
   return preceding.slice(Math.max(head, 0));
 };
 
+/** 語彙表 neutral-ending の語（「こと」）か。書いた形か原形で照らす。 */
+const isNeutralWord = (token: Token | undefined, neutral: readonly LexiconEntry[]): boolean =>
+  token !== undefined && neutral.some((entry) => token.surface === entry.pattern || token.lemma === entry.pattern);
+
 /**
- * 非自立名詞で終わる文末は、手前の述語の連なりまで見る。「予約できること。」「おかけしましたこと。」は手前の述語が調子を持つ。
- * 要件や規程のである調は「〜こと。」で書く。「以下のとおり。」は手前も述語でないので、調子を持たないまま。
+ * 非自立名詞で終わる文末は、手前の述語の連なりまで見る。「使っているのかな？」は手前の述語が調子を持つ。
+ * 「以下のとおり。」は手前も述語でないので、調子を持たないまま。
+ * 語彙表 neutral-ending の語（「こと」）で終わる文末は手前を見ない。「〜を保持すること。」は体言止めで、要件や規程の箇条書きは
+ * ですます調の文書でもである調の文書でもこの形で書く。
  */
-const withPreceding = (ending: readonly Token[], preceding: readonly Token[]): readonly Token[] =>
-  isDependent(ending[0]) ? [...chainAtEnd(preceding), ...ending] : ending;
+const withPreceding = (ending: readonly Token[], preceding: readonly Token[], neutral: readonly LexiconEntry[]): readonly Token[] =>
+  isDependent(ending[0]) && !isNeutralWord(ending[0], neutral) ? [...chainAtEnd(preceding), ...ending] : ending;
 
 /**
- * 文末の語の調子。preceding は文末の語より前の語。
+ * 文末の語の調子。preceding は文末の語より前の語。neutral は調子を持たない文末の語（語彙表 neutral-ending）。
  * 文末に述語（動詞・形容詞・助動詞）が無ければ、ですます調でもである調でもないので undefined。
  * 「以下の通り。」「円錐形の麦わら帽子。」のような名詞で終わる文を数えると、そのままである調の少数派になっていた。
  * 書いた形でも原形でも読みでも当てる（polite-word.ts）。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
  */
-export const registerOf = (ending: readonly Token[], preceding: readonly Token[], polite: readonly LexiconEntry[]): Register | undefined => {
-  const judged = withPreceding(ending, preceding);
+export const registerOf = (
+  ending: readonly Token[],
+  preceding: readonly Token[],
+  polite: readonly LexiconEntry[],
+  neutral: readonly LexiconEntry[] = [],
+): Register | undefined => {
+  const judged = withPreceding(ending, preceding, neutral);
   if (!judged.some(isPredicate)) return undefined;
   return judged.some((token) => isPoliteWord(token, polite)) ? "polite" : "plain";
 };
@@ -56,21 +67,36 @@ export const groupOf = (offset: number, lists: readonly Span[], runs: readonly S
 /** group: 文が入っているまとまり（groupOf の値）。本文なら undefined。 */
 export type Judged = { readonly register: Register; readonly group: number | undefined };
 
-/** 混ざった文と、その文が属する本文または箇条書きの中の少数派の数。 */
+/** 混ざった文と、その文が属するまとまり（本文、または箇条書き 1 つ）の中の少数派の数。文書全体の数ではない。 */
 export type Slip<T extends Judged> = { readonly entry: T; readonly count: number };
 
 const countIn = (judged: readonly Judged[], register: Register): number => judged.filter((entry) => entry.register === register).length;
 
+/** 多いほう。同数なら undefined。 */
+export const majorityOf = (judged: readonly Judged[]): Register | undefined => {
+  const difference = countIn(judged, "polite") - countIn(judged, "plain");
+  if (difference === 0) return undefined;
+  return difference > 0 ? "polite" : "plain";
+};
+
 /** 少ないほう。同数なら文書全体で少ないほう、それも同数なら丁寧体。 */
 const minorityOf = (group: readonly Judged[], whole: readonly Judged[]): Register => {
-  const difference = countIn(group, "polite") - countIn(group, "plain");
-  if (difference !== 0) return difference < 0 ? "polite" : "plain";
+  const majority = majorityOf(group);
+  if (majority !== undefined) return majority === "polite" ? "plain" : "polite";
   return countIn(whole, "polite") <= countIn(whole, "plain") ? "polite" : "plain";
 };
 
+/**
+ * 箇条書きの中の少数派が、文書全体では多数派か。それなら箇条書きの中で文書の調子に寄せた側なので、直す側ではない。
+ * 常体の多い箇条書きにですます調の文が混ざっても、ですます調の文書なら「多いほうに揃えて」は文書の少数派へ揃えることになる。
+ */
+export const followsDocument = (group: number | undefined, minority: Register, whole: readonly Judged[]): boolean =>
+  group !== undefined && majorityOf(whole) === minority;
+
 const slipsInGroup = <T extends Judged>(judged: readonly T[], group: number | undefined, limit: number): Slip<T>[] => {
   const members = judged.filter((entry) => entry.group === group);
   const minority = minorityOf(members, judged);
+  if (followsDocument(group, minority, judged)) return [];
   const slips = members.filter((entry) => entry.register === minority);
   // 片方しか無ければ揃っている。少数派が閾値を超えて多ければ、混在ではなく別の文体。
   if (slips.length === 0 || slips.length > limit) return [];
@@ -80,6 +106,7 @@ const slipsInGroup = <T extends Judged>(judged: readonly T[], group: number | un
 /**
  * 調子が混ざった文を、judged の順で。本文は本文どうし、箇条書きと番号で始まる段落の並びは 1 つずつ、その中で揃っているかを見る。
  * ですます調の本文に常体の箇条書きを置くのはよくある書き方で、箇条書きが丸ごと揃っていれば混在ではない。
+ * 箇条書きの中で混ざっていても、少数派が文書全体の多数派なら指さない（followsDocument）。
  */
 export const slipsOf = <T extends Judged>(judged: readonly T[], limit: number): Slip<T>[] => {
   const slips = [...new Set(judged.map((entry) => entry.group))].flatMap((group) => slipsInGroup(judged, group, limit));

package/src/detectors/roman-numeral.ts

@@ -3,3 +3,6 @@
  * 各桁が省けるので空文字にも当たる。1 文字目があることを先読みで求める。
  */
 export const ROMAN_NUMERAL = "(?=[MDCLXVI])M{0,4}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})";
+
+/** ハイフンかダッシュで繋いだ数字の範囲（II-VI、I–III）も、一つの番号として読む。 */
+export const romanRangeOf = (numeral: string): string => `${numeral}(?:[-–]${numeral})?`;

package/src/detectors/sentence-ending.ts

@@ -12,11 +12,11 @@ import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } f
  */
 type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
-const registerOfSentence = (sentence: Sentence, polite: readonly LexiconEntry[]): Register | undefined => {
+const registerOfSentence = (sentence: Sentence, polite: readonly LexiconEntry[], neutral: readonly LexiconEntry[]): Register | undefined => {
   const ending = endingTokens(sentence);
   const tokens = sentence.tokens ?? [];
   const head = ending[0] === undefined ? -1 : tokens.indexOf(ending[0]);
-  return registerOf(ending, head > 0 ? tokens.slice(0, head) : [], polite);
+  return registerOf(ending, head > 0 ? tokens.slice(0, head) : [], polite, neutral);
 };
 
 /** 番号で始まる段落の並び。木を組むのは高いので、調子が一つだけの文書（混ざりようがない）では組まない。 */
@@ -30,25 +30,32 @@ const runsOf = (doc: ProseDocument, registers: readonly Register[]): Span[] => {
   );
 };
 
-export const sentenceEnding: Detector = (doc, options): Finding[] => {
-  const polite = options.lexicon ?? [];
+/** 調子を持つ文と、比べ合うまとまり（groupOf）。polite は語彙表 polite-ending。 */
+export const judgedSentences = (doc: ProseDocument, polite: readonly LexiconEntry[]): Entry[] => {
+  const neutral = doc.lexicons["neutral-ending"] ?? [];
   const lists = doc.lists.map((list) => list.span);
   const found = doc.sentences.flatMap((sentence, index): { sentence: Sentence; register: Register }[] => {
     if (!isClosed(sentence) || continuesInto(sentence, doc.sentences[index + 1])) return [];
-    const register = registerOfSentence(sentence, polite);
+    const register = registerOfSentence(sentence, polite, neutral);
     return register === undefined ? [] : [{ sentence, register }];
   });
   const runs = runsOf(
     doc,
     found.map((entry) => entry.register),
   );
-  const judged = found.map((entry): Entry => ({ ...entry, group: groupOf(entry.sentence.span.start, lists, runs) }));
-  return slipsOf(judged, options.limit).map(({ entry: { sentence }, count }) => ({
+  return found.map((entry): Entry => ({ ...entry, group: groupOf(entry.sentence.span.start, lists, runs) }));
+};
+
+export const sentenceEnding: Detector = (doc, options): Finding[] => {
+  const judged = judgedSentences(doc, options.lexicon ?? []);
+  // 数えたのは文が属するまとまりの中なので、文言もそのまとまりを名指す（本文の中で / この箇条書きの中で）。
+  return slipsOf(judged, options.limit).map(({ entry: { sentence, group }, count }) => ({
     rule: "no-mixed-desumasu",
     severity: "warning",
     line: 0,
     column: 0,
     quote: sentence.text.trim(),
+    ...(group === undefined ? {} : { variant: "list" }),
     values: { count, limit: options.limit, offset: sentence.span.start },
   }));
 };

package/src/detectors/sentence-length.ts

@@ -1,15 +1,26 @@
 import { lengthOf, proseText } from "../measure.ts";
-import type { Detector, Finding } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, LengthUnit, Sentence } from "../plugin.ts";
+
+type Measure = { readonly size: number; readonly limit: number; readonly variant?: string };
+
+/** 文書と違う言語の文（和文の中の英文）は、その言語の単位と上限で測る。rule がその言語の段を持たなければ文書のもので。 */
+const measureOf = (sentence: Sentence, unit: LengthUnit, options: DetectorOptions): Measure => {
+  const embedded = sentence.embeddedLanguage;
+  const limit = embedded === undefined ? undefined : options.embeddedLimits?.[embedded.id];
+  if (embedded === undefined || limit === undefined) return { size: lengthOf(sentence, unit), limit: options.limit };
+  return { size: lengthOf(sentence, embedded.lengthUnit), limit, variant: `embedded-${embedded.id}` };
+};
 
 export const sentenceLength: Detector = (doc, options): Finding[] =>
   doc.sentences
-    .map((sentence) => ({ sentence, size: lengthOf(sentence, doc.lengthUnit) }))
-    .filter(({ size }) => size > options.limit)
-    .map(({ sentence, size }) => ({
+    .map((sentence) => ({ sentence, measure: measureOf(sentence, doc.lengthUnit, options) }))
+    .filter(({ measure }) => measure.size > measure.limit)
+    .map(({ sentence, measure }) => ({
       rule: "max-sentence-length",
       severity: "warning",
       line: 0,
       column: 0,
       quote: proseText(sentence),
-      values: { count: size, limit: options.limit, offset: sentence.span.start },
+      values: { count: measure.size, limit: measure.limit, offset: sentence.span.start },
+      ...(measure.variant === undefined ? {} : { variant: measure.variant }),
     }));

package/src/detectors/signals.ts

@@ -1,8 +1,10 @@
 import { proseText } from "../measure.ts";
 import { dateSpans, wordsOf } from "./structure.ts";
-import { compacted, placeOf } from "./gram-place.ts";
+import { compacted, placeAt, type Compacted } from "./gram-place.ts";
+import { charWindows, wordWindows } from "./gram-windows.ts";
+import { furnitureMask, isFurniture } from "./gram-furniture.ts";
 import { notAcronymSpansOf, type NotAcronymSpans } from "./acronym-context.ts";
-import { expansionAt, termEntryAcronyms, type ExpandedAt } from "./acronym-expansion.ts";
+import { abbreviates, expansionAt, termEntryAcronyms, 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";
@@ -17,7 +19,7 @@ const PER = 1000;
  * これより短い文書では密度が暴れる。1 個で「1000 あたり 100」になる。
  * 単位は言語で違うので、床も分ける。英語の 200 語と日本語の 200 文字では長さが桁で違う。
  */
-const FLOOR = { word: 200, char: 500 };
+export const MIN_DOCUMENT_LENGTH = { word: 200, char: 500 };
 
 const bodyOf = (doc: ProseDocument): string => doc.sentences.map(proseText).join(" ");
 
@@ -41,7 +43,7 @@ export const emojiDensity: Detector = (doc, options): Finding[] => {
   const hits = findIn(doc, EMOJI);
   const first = hits[0];
   const rate = density(doc, hits.length);
-  if (wordsOf(doc) < FLOOR[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
+  if (wordsOf(doc) < MIN_DOCUMENT_LENGTH[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
   return [
     {
       rule: "emoji-density",
@@ -55,26 +57,17 @@ export const emojiDensity: Detector = (doc, options): Finding[] => {
 };
 
 /**
- * 同じ言い回しの繰り返し。character n-gram で見るので、語の区切りが要らない。
+ * 同じ言い回しの繰り返し。文字の並びで見るので、adapter の語の区切り（wordSplit）が要らない。英語の窓は空白で語の切れ目にそろえる。
  * spec §10 が n-gram を選んだのはこのためで、新しい言語でそのまま動く。
  */
 /**
  * 窓の幅は単位で分ける。同じ 8 文字でも、日本語では 4〜5 形態素だが英語では 1 語半にしかならない。
- * 実文書（英語 11 本）で 8 文字にしたら、上位は " generat"（generate）のような**語の断片**だった。
+ * 英語の窓は語の切れ目にそろえ、18 文字に届くまで語を足す。文字で切ると " generat" のような語の断片が上位に来る。
+ * 18 は、文字で切っていた頃の 20 文字の窓から前後の空白を除いた長さ（" juxtaposed to said "）。
  */
-const GRAM = { char: 8, word: 20 };
-
-/** 並べた名前にかかる語句は数えない。名前が繰り返されれば、その前後（「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);
-  });
-  return counts;
-};
+const GRAM = { char: 8, word: 18 };
+
+const windowsOf = (text: string, unit: ProseDocument["lengthUnit"]): Span[] => (unit === "char" ? charWindows(text, GRAM.char) : wordWindows(text, GRAM.word));
 
 /**
  * 名前ではなく言い回しだけを数える。実文書で測ったら、上位は
@@ -93,49 +86,80 @@ const CONNECTIVE = { char: /[ぁ-ゖ].*[ぁ-ゖ].*[ぁ-ゖ]/u, word: /\S \S.*\S
 
 const isPhrasing = (gram: string, unit: ProseDocument["lengthUnit"]): boolean => CONNECTIVE[unit].test(gram);
 
-/** 文をまたいで数えない。文の終わりと次の文の始まりが繋がると、固有名詞が言い回しに見える。 */
-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);
-    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;
+/** 語句が最初に数えられた所。書かれたままの語句と、文と、文の中の範囲（sentence.text の位置）。 */
+type FirstSeen = { readonly gram: string; readonly sentence: Sentence; readonly place: Span };
+
+type Tally = { readonly counts: Map<string, number>; readonly first: Map<string, FirstSeen> };
+
+/** 詰めた文の index 番目の文字が、リンクの文字か。 */
+const linkedIn = (doc: ProseDocument, sentence: Sentence, source: Compacted): ((index: number) => boolean) => {
+  const links = doc.links.filter((link) => link.start < sentence.span.end && sentence.span.start < link.end);
+  return (index) => {
+    const at = sentence.span.start + (source.offsets[index] ?? -1);
+    return links.some((link) => link.start <= at && at < link.end);
+  };
+};
+
+/** 英語は大文字と小文字を区別せずに数える。文頭の "Proposals submitted via" も文中の "proposals submitted via" も同じ言い回し。 */
+const keyOf = (gram: string, unit: ProseDocument["lengthUnit"]): string => (unit === "word" ? gram.toLowerCase() : gram);
+
+const namesOf = (doc: ProseDocument): readonly string[] =>
+  doc.lengthUnit === "char" ? (doc.names ?? []).map((name) => name.replace(/\s+/gu, "")) : (doc.names ?? []);
+
+/**
+ * 文をまたいで数えない。文の終わりと次の文の始まりが繋がると、固有名詞が言い回しに見える。
+ * 並べた名前にかかる語句も数えない。名前が繰り返されれば、その前後（「the …」）も一緒に繰り返されるのは当たり前。
+ * 一覧の飾り（gram-furniture.ts）も数えない。項目ごとに繰り返すのはひな形で、書き手ではない。
+ */
+const tallySentence = (doc: ProseDocument, sentence: Sentence, tally: Tally): void => {
+  const source = compacted(sentence.text, doc.lengthUnit);
+  const named = nameSpans(source.text, namesOf(doc));
+  const mask = furnitureMask(source.text, linkedIn(doc, sentence, source));
+  windowsOf(source.text, doc.lengthUnit)
+    .filter((window) => !touchesAny(named, window.start, window.end) && !isFurniture(source.text, mask, window))
+    .forEach((window) => {
+      const gram = source.text.slice(window.start, window.end);
+      const key = keyOf(gram, doc.lengthUnit);
+      tally.counts.set(key, (tally.counts.get(key) ?? 0) + 1);
+      const place = placeAt(source, window);
+      if (!tally.first.has(key) && place !== undefined) tally.first.set(key, { gram, sentence, place });
+    });
 };
 
-/** 数えたときと同じ形の文。char 単位では空白を詰めてから数えている。 */
-const gramText = (sentence: Sentence, unit: ProseDocument["lengthUnit"]): string => compacted(sentence.text, unit).text;
+const gramsOf = (doc: ProseDocument): Tally => {
+  const tally: Tally = { counts: new Map(), first: new Map() };
+  doc.sentences.forEach((sentence) => tallySentence(doc, sentence, tally));
+  return tally;
+};
 
 /**
  * 語句が文の中で占める範囲に、述語になる動詞か助動詞があるか（gram-predicate.ts）。
  * 品詞が無ければ見分けられないので、これまでどおり言い回しとして数える。
  */
-const hasPredicate = (gram: string, sentence: Sentence, unit: ProseDocument["lengthUnit"]): boolean => {
-  if (sentence.tokens === undefined) return true;
-  const place = placeOf(compacted(sentence.text, unit), gram);
-  if (place === undefined) return true;
-  return hasPredicateIn(sentence.tokens, { start: sentence.span.start + place.start, end: sentence.span.start + place.end }, unit);
+const hasPredicate = (at: FirstSeen | undefined, unit: ProseDocument["lengthUnit"]): boolean => {
+  if (at?.sentence.tokens === undefined) return true;
+  const start = at.sentence.span.start;
+  return hasPredicateIn(at.sentence.tokens, { start: start + at.place.start, end: start + at.place.end }, unit);
 };
 
 export const ngramRepetition: Detector = (doc, options): Finding[] => {
-  if (wordsOf(doc) < FLOOR[doc.lengthUnit]) return [];
-  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))
+  if (wordsOf(doc) < MIN_DOCUMENT_LENGTH[doc.lengthUnit]) return [];
+  const tally = gramsOf(doc);
+  const worst = [...tally.counts.entries()]
+    .filter(([key, count]) => count > options.limit && isPhrasing(key, doc.lengthUnit))
     .toSorted(([, left], [, right]) => right - left)
-    .map(([gram, count]) => ({ gram, count, at: sentenceWith(gram) }))
-    .find(({ gram, at }) => at === undefined || hasPredicate(gram, at, doc.lengthUnit));
+    .map(([key, count]) => ({ key, count, at: tally.first.get(key) }))
+    .find(({ at }) => hasPredicate(at, doc.lengthUnit));
   if (worst === undefined) return [];
-  const at = worst.at;
+  const at = worst.at?.sentence;
   return [
     {
       rule: "ngram-repetition",
       severity: "info",
       line: 0,
       column: 0,
-      quote: at?.text.trim() ?? worst.gram,
-      values: { word: worst.gram, count: worst.count, limit: options.limit, offset: at?.span.start ?? 0 },
+      quote: at?.text.trim() ?? worst.key,
+      values: { word: worst.at?.gram ?? worst.key, count: worst.count, limit: options.limit, offset: at?.span.start ?? 0 },
     },
   ];
 };
@@ -237,6 +261,13 @@ const outsideDates = (hits: readonly AcronymHit[], dates: readonly Span[]): Acro
 const isExpanded = (body: string, acronym: string, expandedAt: ExpandedAt): boolean =>
   [...body.matchAll(new RegExp(`${EDGE_BEFORE}${acronym}${EDGE_AFTER}`, "gu"))].some((match) => expandedAt(body, acronym, match.index));
 
+/**
+ * 見出しは文にならないので、見出しの中の展開（Maximum Envelope of Water (MEOW) runs）は見出しの文字列で探す。
+ * 見出しの括弧は添え書き（Your Own AI (LLM)、(Beta)）にも使うので、見出しの語から略語の文字が順に拾えるときだけ認める。
+ */
+const expandsInHeading = (heading: string, acronym: string, expandedAt: ExpandedAt): boolean =>
+  isExpanded(heading, acronym, expandedAt) && abbreviates(heading.replaceAll(acronym, " "), acronym);
+
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
 const notationOf = (doc: ProseDocument): NotAcronymSpans =>
@@ -247,6 +278,7 @@ const notationOf = (doc: ProseDocument): NotAcronymSpans =>
     usStates: patternsOf(doc, "us-state-code"),
     emphasis: patternsOf(doc, "emphasis-word"),
     divisions: patternsOf(doc, "numbered-division"),
+    abbreviatedLabels: patternsOf(doc, "abbreviated-label"),
     honorifics: patternsOf(doc, "honorific"),
     titles: patternsOf(doc, "name-title"),
     dateTimeUnits: patternsOf(doc, "date-time-unit"),
@@ -265,7 +297,9 @@ export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const common = new Set([...(options.lexicon ?? []).map((entry) => entry.pattern), ...patternsOf(doc, "http-method"), ...(doc.names ?? [])]);
   const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: definitionVerbsOf(doc) });
   const entries = termEntryAcronyms(doc.source);
-  const explainedAlone = (word: string): boolean => common.has(word) || entries.has(word) || isExpanded(body, word, expandedAt);
+  const headings = doc.sections.map((section) => section.heading);
+  const explainedAlone = (word: string): boolean =>
+    common.has(word) || entries.has(word) || isExpanded(body, word, expandedAt) || headings.some((heading) => expandsInHeading(heading, word, expandedAt));
   const hits = acronymsOf(doc, notationOf(doc));
   const unexplained = new Set([...firstHits(hits).keys()].filter((acronym) => !isExplained(acronym, explainedAlone)));
   // 日付を読むには文書の木を作る。上限に届かない文書では作らない。
@@ -339,7 +373,7 @@ export const dashDensity: Detector = (doc, options): Finding[] => {
   const hits = findIn(doc, DASH);
   const first = hits[0];
   const rate = density(doc, hits.length);
-  if (wordsOf(doc) < FLOOR[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
+  if (wordsOf(doc) < MIN_DOCUMENT_LENGTH[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
   return [
     {
       rule: "no-em-dash",

package/src/detectors/structure-tree.ts

@@ -4,11 +4,13 @@ import { numberingBreaks } from "../structure/numbering.ts";
 import { weekdayMismatches } from "../structure/weekday.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
+import { reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
+import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
 
 const QUOTE_LENGTH = 80;
 
 /** 指摘の位置から行末までを引用する。条の見出しや参照を含む一行が、読み手の探す手がかりになる。 */
-const quoteAt = (source: string, offset: number): string => {
+export const quoteAt = (source: string, offset: number): string => {
   const end = source.indexOf("\n", offset);
   return source
     .slice(offset, end === -1 ? source.length : end)
@@ -96,3 +98,45 @@ export const totalMismatch: Detector = (doc): Finding[] =>
         quote: quoteAt(doc.source, issue.offset),
         values: { ...issue.values, offset: issue.offset },
       }));
+
+const datedSpans = (tree: NonNullable<ProseDocument["structure"]>): DatedSpan[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+
+const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
+  connectors: (doc.lexicons["range-connector"] ?? []).map((entry) => entry.pattern),
+  openers: (doc.lexicons["range-opener"] ?? []).map((entry) => entry.pattern),
+  closers: (doc.lexicons["range-closer"] ?? []).map((entry) => entry.pattern),
+});
+
+/** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */
+export const dateRangeReversed: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : reversedRanges(doc.source, datedSpans(doc.structure), rangeWordsOf(doc)).map((issue) => ({
+        rule: "date-range-reversed",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: { ...issue.values, offset: issue.offset },
+      }));
+
+const shareWordsOf = (doc: ProseDocument): ShareWords => ({
+  labels: (doc.lexicons["share-label"] ?? []).map((entry) => entry.pattern),
+  exceptions: (doc.lexicons["share-exception"] ?? []).map((entry) => entry.pattern),
+  units: (doc.lexicons["percent-unit"] ?? []).map((entry) => entry.pattern),
+  totalLabels: (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern),
+});
+
+/** 構成比や内訳の百分率の和が 100% にならない。割合の語と百分率の単位は言語パッケージの語彙表から取る。 */
+export const percentSumMismatch: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : percentSumMismatches(doc.source, amountsOf(doc.structure), shareWordsOf(doc)).map((issue) => ({
+        rule: "percent-sum-mismatch",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: { ...issue.values, offset: issue.offset },
+      }));

package/src/detectors/structure.ts

@@ -4,6 +4,7 @@ import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { preambleParagraphs } from "../preamble-paragraphs.ts";
 import { isTooLongParagraph } from "../paragraph-length.ts";
+import { bodySectionOf } from "../body-section.ts";
 
 /**
  * ばらつきは変動係数（標準偏差 ÷ 平均）で測る。
@@ -118,12 +119,10 @@ const withoutDateStamps = (doc: ProseDocument, paragraphs: readonly Paragraph[])
 
 /**
  * 本題に入るまでが長い。業務文書では、読み手は結論を探しに来ている。
- *
- * 「本題」は最初の中見出し（深さ 2 以上）とする。表題（深さ 1）の直後から数えると、
- * 表題しか無い文書で全文が前置きになる。中見出しが無い文書では何も言わない。
+ * 「本題」は最初の中見出し。中見出しが無い文書では、rule が requires の headings で動かず、動かなかった理由が出る。
  */
 export const preambleLength: Detector = (doc, options): Finding[] => {
-  const body = doc.sections.find((section) => section.depth >= 2);
+  const body = bodySectionOf(doc.sections);
   if (body === undefined) return [];
   const all = preambleParagraphs(doc.paragraphs, body.span.start);
   if (all.length <= options.limit) return [];

package/src/detectors/superlative-name.ts

@@ -9,10 +9,13 @@ const joinsAsNoun = (previous: Token, token: Token | undefined): token is Token
 
 /** 空白も助詞も挟まずに続く名詞の連なり（最大|瞬間|風速）の最後の語。連なりが無ければ undefined。 */
 const lastJoined = (tokens: readonly Token[], at: number): Token | undefined => {
-  const previous = tokens[at - 1];
-  const token = tokens[at];
-  if (previous === undefined || !joinsAsNoun(previous, token)) return undefined;
-  return lastJoined(tokens, at + 1) ?? token;
+  let last: Token | undefined;
+  for (let index = at; ; index += 1) {
+    const previous = tokens[index - 1];
+    const token = tokens[index];
+    if (previous === undefined || !joinsAsNoun(previous, token)) return last;
+    last = token;
+  }
 };
 
 const measures = (noun: Token, quantities: Lexicon): boolean => quantities.some((entry) => entry.pattern === noun.surface);

package/src/detectors/superlative-scope.ts

@@ -48,9 +48,14 @@ const namedBefore = (tokens: readonly Token[], range: TokenRange, markers: Lexic
 
 /** 最上級に続く名詞句の終わり。名詞が出るまでは修飾を、出た後は名詞の連なりを読む。 */
 export const phraseEnd = (tokens: readonly Token[], at: number, nounSeen = false): number => {
-  const token = tokens[at];
-  if (token === undefined || !(nounSeen ? NOUN_RUN : PREMODIFIER).has(token.pos)) return at;
-  return phraseEnd(tokens, at + 1, nounSeen || NOMINAL.has(token.pos));
+  let end = at;
+  let seen = nounSeen;
+  for (;;) {
+    const token = tokens[end];
+    if (token === undefined || !(seen ? NOUN_RUN : PREMODIFIER).has(token.pos)) return end;
+    seen ||= NOMINAL.has(token.pos);
+    end += 1;
+  }
 };
 
 /** 最上級 + 名詞句 + 範囲の語 + 名詞句（the best pizza in Chicago・the most famous of the sculptures）。 */