chaffjs 0.17.0 → 0.19.0

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/space-before-punctuation.ts

@@ -0,0 +1,32 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+/**
+ * 字で終わる語（閉じ括弧や閉じ引用符が一つ付いてもよい）のすぐ後ろの半角空白一つと、それに続く句読点（"word ."、"(word) ,"）。句読点の後ろは空白か行の終わりか閉じの記号で、
+ * ".NET" や ".5" のように次の語の頭の点は数えない。数の後ろ（式の "[ 1 , N ]"）と、"Note : " "ISSN : " のように欄の印として空けるコロンは見ない。
+ */
+const SPACED_MARK = /(?<=\p{L}[)\]}"'”’]?) (?=[.,;?!](?:[\s)\]"'”’]|$))/gu;
+
+/** 空白で区切った点の並び（". . ."）。省略の印と、目次の点線。 */
+const SPACED_DOTS = /^\. ?\./u;
+
+const DOTS_REACH = 3;
+
+const isSpacedEllipsis = (text: string, space: number): boolean => SPACED_DOTS.test(text.slice(space + 1, space + 1 + DOTS_REACH));
+
+/**
+ * 本文（prose）の中の、句読点の前の空白の位置。prose はコード・URL・強調の印を空白で覆うので、覆ってできた空白（"*word* ." の "*"）は
+ * 書き手が打った空白ではない。source の同じ位置も空白のときだけ数える。
+ */
+export const spacesBeforePunctuation = (prose: string, source: string): number[] =>
+  [...prose.matchAll(SPACED_MARK)].map((match) => match.index).filter((space) => source.charAt(space) === " " && !isSpacedEllipsis(prose, space));
+
+export const spaceBeforePunctuation: Detector = (doc): Finding[] =>
+  spacesBeforePunctuation(doc.prose ?? doc.source, doc.source).map((space) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(doc.source, space, space + 2),
+    values: { mark: doc.source.charAt(space + 1), offset: space },
+  }));

package/src/detectors/spelling-variety.ts

@@ -0,0 +1,81 @@
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Span } from "../plugin.ts";
+import { minorityWithin } from "../orthography.ts";
+import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
+
+/**
+ * 綴りの組の語彙表の名前の頭。組（spelling-variant、spelling-ize）ごとに比べる。組を分けるのは、両方の書き方が一つの
+ * 書き方の決まりの中にあるから（Oxford の綴りは colour と organize を一緒に使う）。
+ */
+const SPELLING_LISTS = "spelling-";
+
+type Spelling = { readonly family: string; readonly pattern: boolean; readonly other: string };
+
+/** 語（小文字）から、その語がどの組のどちらの綴りか。 */
+const spellingsOf = (lexicons: ProseDocument["lexicons"]): ReadonlyMap<string, Spelling> =>
+  new Map(
+    Object.entries(lexicons)
+      .filter(([id]) => id.startsWith(SPELLING_LISTS))
+      .flatMap(([family, entries]: [string, Lexicon]) =>
+        entries.flatMap((entry): [string, Spelling][] =>
+          entry.instead_of === undefined
+            ? []
+            : [
+                [entry.pattern.toLowerCase(), { family, pattern: true, other: entry.instead_of }],
+                [entry.instead_of.toLowerCase(), { family, pattern: false, other: entry.pattern }],
+              ],
+        ),
+      ),
+  );
+
+const WORD = /\p{L}+/gu;
+
+/** 語の直前の開きの引用符。引いた語（use ‘organise’ not ‘organize’）は書き手の綴りではなく、話題にした語。 */
+const OPENING_QUOTE = /[‘'"“]/u;
+const CAPITAL = /^\p{Lu}/u;
+
+/** 大文字で始まる次の語。文の頭でも、大文字の語が続けば名前（Labor Day、Centre Court）。 */
+const CAPITALISED_NEXT = /^[ \t]+\p{Lu}/u;
+
+export type SpelledWord = { readonly written: string; readonly offset: number; readonly spelling: Spelling };
+
+/**
+ * 文の中の、組に載った綴りの語。文の頭でないのに大文字で始まる語と、大文字の語が続く語（Labor Day、World Health Organization）は名前で、名前の綴りは
+ * 変えられないので数えない。引用符で引いたものの中も、引いた元の綴りなので数えない。offset は文書の中の位置。
+ */
+export const spelledWordsIn = (sentence: Sentence, spellings: ReadonlyMap<string, Spelling>): SpelledWord[] => {
+  const quoted: readonly Span[] = quotedSpans(sentence.text, QUOTATION_MARKS);
+  const first = sentence.text.search(/\p{L}/u);
+  return [...sentence.text.matchAll(WORD)].flatMap((match) => {
+    const spelling = spellings.get(match[0].toLowerCase());
+    const named = CAPITAL.test(match[0]) && (match.index !== first || CAPITALISED_NEXT.test(sentence.text.slice(match.index + match[0].length)));
+    const inQuote =
+      isWithinAny(quoted, { start: match.index, end: match.index + match[0].length }) || OPENING_QUOTE.test(sentence.text.charAt(match.index - 1));
+    return spelling === undefined || named || inQuote ? [] : [{ written: match[0], offset: sentence.span.start + match.index, spelling }];
+  });
+};
+
+type Located = { readonly sentence: Sentence; readonly word: SpelledWord };
+
+const findingOf = ({ sentence, word }: Located, count: number, of: number): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: sentence.text.trim(),
+  values: { matched: word.written, other: word.spelling.other, count, of, offset: word.offset },
+});
+
+/**
+ * イギリスとアメリカの綴り（colour と color、centre と center）が一つの文書で混ざっているか。組ごとに、文書の中で少ないほうを
+ * 指摘する。どちらが正しいかは決めない。少ないほうが組の limit パーセントを超えるなら、使い分けと見て言わない。
+ */
+export const spellingVariety: Detector = (doc, options): Finding[] => {
+  const spellings = spellingsOf(doc.lexicons);
+  const located: Located[] = doc.sentences.flatMap((sentence) => spelledWordsIn(sentence, spellings).map((word) => ({ sentence, word })));
+  const families = [...new Set(located.map(({ word }) => word.spelling.family))];
+  return families.flatMap((family) => {
+    const ofFamily = located.filter(({ word }) => word.spelling.family === family);
+    const odd = minorityWithin(ofFamily, ({ word }) => word.spelling.pattern, options.limit);
+    return odd.map((entry) => findingOf(entry, odd.length, ofFamily.length));
+  });
+};

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 { rangeFrameOf, 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,47 @@ 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),
+  frames: (doc.lexicons["range-frame"] ?? []).flatMap((entry) => rangeFrameOf(entry.pattern) ?? []),
+  changes: (doc.lexicons["date-change-word"] ?? []).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

@@ -1,9 +1,10 @@
 import { charLength, lengthOf } from "../measure.ts";
-import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section, Span } from "../plugin.ts";
+import type { BulletList, Detector, DetectorOptions, Finding, Paragraph, ProseDocument, Section, Span } from "../plugin.ts";
 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";
 
 /**
  * ばらつきは変動係数（標準偏差 ÷ 平均）で測る。
@@ -24,6 +25,18 @@ const PERCENT = 100;
 
 const asPercent = (value: number): number => Math.round(value * PERCENT);
 
+/**
+ * 揃いすぎを測るのに要る、値の数の下限（rule の options）。値が少ないと変動係数は偶然で小さく出る。
+ * 人の書いた記事では、指摘が節や段落の少ない文書に偏っていた。
+ */
+const minimumCount = (options: DetectorOptions, name: string, fallback: number): number => {
+  const value = options.settings?.[name];
+  return typeof value === "number" ? value : fallback;
+};
+
+const DEFAULT_MIN_SECTIONS = 5;
+const DEFAULT_MIN_PARAGRAPHS = 6;
+
 const uniformity = (doc: ProseDocument, values: readonly number[], span: { start: number }, limit: number, rule: string): Finding[] => {
   const cv = coefficientOfVariation(values);
   if (cv === undefined || asPercent(cv) >= limit) return [];
@@ -64,7 +77,8 @@ const charsOf = (paragraph: Paragraph): number => paragraph.sentences.reduce((su
 export const paragraphVariance: Detector = (doc, options): Finding[] => {
   const lengths = doc.paragraphs.map(charsOf).filter((length) => length > 0);
   const first = doc.paragraphs[0];
-  return first === undefined ? [] : uniformity(doc, lengths, first.span, options.limit, "paragraph-length-variance");
+  if (first === undefined || lengths.length < minimumCount(options, "min_paragraphs", DEFAULT_MIN_PARAGRAPHS)) return [];
+  return uniformity(doc, lengths, first.span, options.limit, "paragraph-length-variance");
 };
 
 const sectionChars = (section: Section): number => section.sentences.reduce((sum, sentence) => sum + charLength(sentence), 0);
@@ -73,7 +87,8 @@ const sectionChars = (section: Section): number => section.sentences.reduce((sum
 export const sectionUniformity: Detector = (doc, options): Finding[] => {
   const lengths = doc.sections.map(sectionChars).filter((length) => length > 0);
   const first = doc.sections[0];
-  return first === undefined ? [] : uniformity(doc, lengths, first.span, options.limit, "section-length-uniformity");
+  if (first === undefined || lengths.length < minimumCount(options, "min_sections", DEFAULT_MIN_SECTIONS)) return [];
+  return uniformity(doc, lengths, first.span, options.limit, "section-length-uniformity");
 };
 
 /**
@@ -118,12 +133,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-comparison.ts

@@ -0,0 +1,47 @@
+import type { Lexicon, LexiconEntry, Sentence, Span, Token } from "../plugin.ts";
+import { isWithinAny, quotedIn, quotedSpans, QUOTATION_MARKS } from "../quoted-span.ts";
+import { entryEndsAt, entryIn, type TokenRange } from "./lexicon-match.ts";
+
+/**
+ * 比べる相手を言う語。語彙表の position で分ける。
+ * position の無い語（より・のほうが・than）は、文のどこにあっても比べる相手を言っている。
+ * position: before の語（との）は、最上級のすぐ前にあるときだけ。「SES との最大の分岐点」は相手を言うが、
+ * 「チームとの会議で最高の成果」の「との」は最上級と関わらない。
+ */
+export type ComparisonMarkers = { readonly anywhere: Lexicon; readonly before: Lexicon };
+
+export const comparisonMarkersOf = (lexicon: Lexicon): ComparisonMarkers => ({
+  anywhere: lexicon.filter((entry) => entry.position === undefined),
+  before: lexicon.filter((entry) => entry.position === "before"),
+});
+
+/** 最上級のすぐ前で、比べる相手を受ける語が終わっているか。 */
+export const counterpartBefore = (tokens: readonly Token[], range: TokenRange, markers: Lexicon): boolean =>
+  markers.some((entry) => entryEndsAt(tokens, entry, range.start));
+
+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 };
+};
+
+/** 引用符や鉤括弧の中の最上級。人の言葉や題名を引いたもので、書き手が比べずに言い切ったものではない。 */
+export const quotedRange = (sentence: Sentence, range: TokenRange): boolean => {
+  const span = spanOf(sentence.tokens ?? [], range);
+  return span !== undefined && isWithinAny(quotedIn(sentence, QUOTATION_MARKS), span);
+};
+
+/** 引いた言葉の中身を空白にした文。位置は変えない。 */
+const unquotedText = (text: string): string => {
+  const quoted = quotedSpans(text, QUOTATION_MARKS);
+  return text
+    .split("")
+    .map((char, at) => (quoted.some((span) => at >= span.start && at < span.end) ? " " : char))
+    .join("");
+};
+
+/** 語が、引いた言葉の中にしか無いか。字で照らすので、品詞の無い文でも言える。 */
+export const onlyQuoted = (sentence: Sentence, entry: LexiconEntry): boolean => {
+  const wrapped = sentence.wrapBreaks === undefined ? {} : { wrapBreaks: sentence.wrapBreaks };
+  return !entryIn({ span: sentence.span, text: unquotedText(sentence.text), ...wrapped }, entry);
+};

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）。 */