chaffjs 0.34.0 → 0.35.0

package/src/detectors/signals.ts

@@ -4,12 +4,17 @@ 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 { nameSpansOf } from "./acronym-name.ts";
 import { abbreviates, expansionAt, termEntryAcronyms, type ExpandedAt } from "./acronym-expansion.ts";
 import { isExplained } from "./acronym-compound.ts";
+import { statedAcronyms } from "./acronym-definition.ts";
+import { isBracketed, isInHeading, isNamePart } from "./acronym-lone.ts";
 import { conjugatedForms } from "./conjugated-form.ts";
-import { evidenceSpans, hasNumeral, startsWithin } from "./concrete-evidence.ts";
+import { evidenceSpans, hasNumeral, isClaim, isLabelOnly, startsWithin, type AdviceWords } from "./concrete-evidence.ts";
 import { letteredIndexEntries } from "./lettered-index.ts";
+import { outlineLabelSpans } from "./outline-label.ts";
 import { hasPredicateIn } from "./gram-predicate.ts";
+import { gramPassagesOf } from "./gram-passages.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
 import { referenceListSpans } from "../reference-lists.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence } from "../plugin.ts";
@@ -127,12 +132,23 @@ const tallySentence = (doc: ProseDocument, sentence: Sentence, tally: Tally): vo
     });
 };
 
-const gramsOf = (doc: ProseDocument): Tally => {
+const gramsOf = (doc: ProseDocument, sentences: readonly Sentence[]): Tally => {
   const tally: Tally = { counts: new Map(), first: new Map() };
-  doc.sentences.forEach((sentence) => tallySentence(doc, sentence, tally));
+  sentences.forEach((sentence) => tallySentence(doc, sentence, tally));
   return tally;
 };
 
+type Repeat = { readonly key: string; readonly count: number; readonly at: FirstSeen | undefined };
+
+/** 範囲（gram-passages.ts）ごとに数える。よくある質問の別々の答えは別の範囲。 */
+const repeatsOf = (doc: ProseDocument, limit: number): Repeat[] =>
+  gramPassagesOf(doc.sections).flatMap((sentences) => {
+    const tally = gramsOf(doc, sentences);
+    return [...tally.counts.entries()]
+      .filter(([key, count]) => count > limit && isPhrasing(key, doc.lengthUnit))
+      .map(([key, count]) => ({ key, count, at: tally.first.get(key) }));
+  });
+
 /**
  * 語句が文の中で占める範囲に、述語になる動詞か助動詞があるか（gram-predicate.ts）。
  * 品詞が無ければ見分けられないので、これまでどおり言い回しとして数える。
@@ -145,11 +161,8 @@ const hasPredicate = (at: FirstSeen | undefined, unit: ProseDocument["lengthUnit
 
 export const ngramRepetition: Detector = (doc, options): Finding[] => {
   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(([key, count]) => ({ key, count, at: tally.first.get(key) }))
+  const worst = repeatsOf(doc, options.limit)
+    .toSorted((left, right) => right.count - left.count)
     .find(({ at }) => hasPredicate(at, doc.lengthUnit));
   if (worst === undefined) return [];
   const at = worst.at?.sentence;
@@ -274,8 +287,8 @@ const expandsInHeading = (heading: string, acronym: string, expandedAt: Expanded
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
-const notationOf = (doc: ProseDocument): NotAcronymSpans =>
-  notAcronymSpansOf({
+const notationOf = (doc: ProseDocument): NotAcronymSpans => {
+  const notation = notAcronymSpansOf({
     meridiem: patternsOf(doc, "meridiem"),
     timeZones: patternsOf(doc, "time-zone"),
     currencies: patternsOf(doc, "currency-code"),
@@ -287,6 +300,17 @@ const notationOf = (doc: ProseDocument): NotAcronymSpans =>
     titles: patternsOf(doc, "name-title"),
     dateTimeUnits: patternsOf(doc, "date-time-unit"),
   });
+  const names = nameSpansOf({
+    legalForms: patternsOf(doc, "legal-form"),
+    determiners: patternsOf(doc, "name-determiner"),
+    citationSeries: patternsOf(doc, "citation-series"),
+    carriers: patternsOf(doc, "carrier-name"),
+    namePrefixes: patternsOf(doc, "name-prefix"),
+    streetSuffixes: patternsOf(doc, "street-suffix"),
+    capitalPhrases: patternsOf(doc, "capital-phrase"),
+  });
+  return (text) => [...notation(text), ...names(text)];
+};
 
 /** 定義の語は、語彙表の形（という）と、この文書で活用して書かれた形（といいます）の両方で照らす。 */
 const definitionVerbsOf = (doc: ProseDocument): string[] => {
@@ -294,30 +318,57 @@ const definitionVerbsOf = (doc: ProseDocument): string[] => {
   return [...verbs, ...conjugatedForms(doc.sentences, verbs)];
 };
 
+const acronymFinding = (acronym: string, hit: Hit, count: number, limit: number): Finding => ({
+  rule: "undefined-acronym",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: hit.sentence.text.trim(),
+  values: { word: acronym, count, limit, offset: hit.offset },
+});
+
+const isNamePartAt = (acronym: string, hit: Hit): boolean => {
+  const start = hit.offset - hit.sentence.span.start;
+  return isNamePart(hit.sentence.text, start, start + acronym.length);
+};
+
+/**
+ * 説明のない略語が上限に届かなくても、この文書が自分で上限の数だけ略語を展開しているなら、展開しなかった 1 つも指す。
+ * 書き手が展開する文書では、展開の抜けは抜けとして読める。名前の一部の略語（SRI International）は、そのときも指さない。
+ */
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
-  // HTTP のメソッド名（GET）は略語ではないので、通じる略語と同じく展開を求めない。
+  // HTTP のメソッド名（GET）は略語ではなく、税の名前（VAT、GST）は読み手が名前として知るので、通じる略語と同じく展開を求めない。
   // 並べた名前（JAXA）も、繋いだ略語（JAXA-ISAS）の片割れとして説明済みに数える。
-  const common = new Set([...(options.lexicon ?? []).map((entry) => entry.pattern), ...patternsOf(doc, "http-method"), ...(doc.names ?? [])]);
+  const common = new Set([
+    ...(options.lexicon ?? []).map((entry) => entry.pattern),
+    ...patternsOf(doc, "http-method"),
+    ...patternsOf(doc, "tax-code"),
+    ...(doc.names ?? []),
+  ]);
   const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: definitionVerbsOf(doc) });
-  const entries = termEntryAcronyms(doc.source);
+  const stated = statedAcronyms(doc.source, { statements: patternsOf(doc, "definition-statement"), markers: patternsOf(doc, "definition-marker") });
+  const entries = new Set([...termEntryAcronyms(doc.source), ...stated]);
   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 = outsideSpans(acronymsOf(doc, notationOf(doc)), referenceListSpans(doc.source, patternsOf(doc, "reference-list-heading")));
-  const unexplained = new Set([...firstHits(hits).keys()].filter((acronym) => !isExplained(acronym, explainedAlone)));
+  const hits = outsideSpans(acronymsOf(doc, notationOf(doc)), [
+    ...referenceListSpans(doc.source, patternsOf(doc, "reference-list-heading")),
+    ...outlineLabelSpans(doc.source, patternsOf(doc, "numbered-division")),
+  ]);
+  const acronyms = [...firstHits(hits).keys()];
+  const unexplained = new Set(acronyms.filter((acronym) => !isExplained(acronym, explainedAlone)));
+  const bracketed = (acronym: string): boolean => [body, ...headings].some((text) => isBracketed(text, acronym));
+  // 定義の一覧（"SOW" means …）で定義する書き手も、略語を展開する書き手と数える。
+  const definedByWriter = (acronym: string): boolean => bracketed(acronym) || stated.has(acronym);
+  const writerSpellsOut = acronyms.filter((acronym) => !common.has(acronym) && explainedAlone(acronym) && definedByWriter(acronym)).length >= options.limit;
   // 日付を読むには文書の木を作る。上限に届かない文書では作らない。
-  if (unexplained.size < options.limit) return [];
+  if (unexplained.size < options.limit && !writerSpellsOut) return [];
   const bare = [...firstHits(outsideSpans(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
-  if (bare.length < options.limit) return [];
-  return bare.map(([acronym, hit]) => ({
-    rule: "undefined-acronym",
-    severity: "info",
-    line: 0,
-    column: 0,
-    quote: hit.sentence.text.trim(),
-    values: { word: acronym, count: bare.length, limit: options.limit, offset: hit.offset },
-  }));
+  if (bare.length >= options.limit) return bare.map(([acronym, hit]) => acronymFinding(acronym, hit, bare.length, options.limit));
+  if (!writerSpellsOut) return [];
+  const alone = bare.filter(([acronym, hit]) => !isNamePartAt(acronym, hit) && !isInHeading(headings, acronym));
+  return alone.map(([acronym, hit]) => acronymFinding(acronym, hit, alone.length, options.limit));
 };
 
 /**
@@ -341,9 +392,26 @@ const openingOf = (sentence: Sentence | undefined, unit: ProseDocument["lengthUn
 
 const hasNumeralIn = (section: Section): boolean => section.sentences.some((sentence) => hasNumeral(sentence.tokens ?? []));
 
+/** これより短い節は、具体物があるべきか判断できない。 */
+const MIN_SENTENCES = 3;
+
+const adviceWordsOf = (doc: ProseDocument): AdviceWords => ({
+  openers: (doc.lexicons["advice-opener"] ?? []).map((entry) => entry.pattern),
+  endings: (doc.lexicons["advice-ending"] ?? []).map((entry) => entry.pattern),
+});
+
+/** 文の半分以上が問いか指示の節（質問の一覧、手引き）は、数字で裏づける主張をしていない。番号だけの文（a.）は数えない。 */
+const mostlyClaims = (section: Section, language: string, advice: AdviceWords): boolean => {
+  const said = section.sentences.filter((sentence) => !isLabelOnly(sentence));
+  return said.filter((sentence) => isClaim(sentence, language, advice)).length * 2 > said.length;
+};
+
 export const concreteEvidence: Detector = (doc, options): Finding[] => {
   const entries = letteredIndexEntries(doc.sections);
-  const sections = doc.sections.filter((section) => section.sentences.length >= 3 && !entries.has(section));
+  const advice = adviceWordsOf(doc);
+  const sections = doc.sections.filter(
+    (section) => section.sentences.length >= MIN_SENTENCES && !entries.has(section) && mostlyClaims(section, doc.language, advice),
+  );
   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/structure-tree.ts

@@ -1,7 +1,8 @@
 import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
 import { danglingReferences, duplicateDefinitions, inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { numberingBreaks } from "../structure/numbering.ts";
-import { listNumberBreaks, writtenNumbers } from "../structure/list-numbering.ts";
+import { htmlTextBlocks } from "../structure/html-text-blocks.ts";
+import { listsNumberBreaks } from "../structure/list-numbering.ts";
 import { weekdayMismatches } from "../structure/weekday.ts";
 import { documentDateOf } from "./document-date.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
@@ -48,19 +49,20 @@ const findingsOf =
           values: { ...issue.values, offset: issue.offset },
         }));
 
-export const danglingReference: Detector = findingsOf("dangling-reference", danglingReferences);
-const structureNumberingGap: Detector = findingsOf("numbering-gap", numberingBreaks);
+export const danglingReference: Detector = (doc, options) =>
+  findingsOf("dangling-reference", (tree, source) => danglingReferences(tree, source, patternsOf(doc, "section-name-noun")))(doc, options);
+/** Markdown の HTML ブロックの中の条は木に入らない。そこを挟んだ抜けは、見えなかった番号かもしれない。 */
+const structureNumberingGap: Detector = (doc, options) =>
+  findingsOf("numbering-gap", (tree, source) => numberingBreaks(tree, doc.markup?.markdown === true ? htmlTextBlocks(source) : []))(doc, options);
 
 const lineStartAt = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
 
-/** The written numbers of the document's Markdown ordered lists that skip or repeat (structure/list-numbering.ts). */
-const QUOTED_LINE = /^[ \t]*>/u;
-
 /** 引用の中の箇条書きは、ほかの文書の例で、この文書の番号ではない。 */
-const isQuotedList = (source: string, start: number): boolean => QUOTED_LINE.test(source.slice(lineStartAt(source, start), start));
+const isQuotedList = (source: string, start: number): boolean => /^[ \t]*>/u.test(source.slice(lineStartAt(source, start), start));
 
+/** The written numbers of the document's Markdown ordered lists that skip or repeat (structure/list-numbering.ts). */
 const listNumberingGaps = (doc: ProseDocument): StructureIssue[] =>
-  doc.lists.filter((list) => !isQuotedList(doc.source, list.span.start)).flatMap((list) => listNumberBreaks(writtenNumbers(doc.source, list.itemSpans) ?? []));
+  listsNumberBreaks(doc.source, doc.lists, (list) => !isQuotedList(doc.source, list.span.start));
 
 const lineFindingOf = (doc: ProseDocument, issue: StructureIssue): Finding => ({
   rule: "numbering-gap",

package/src/detectors/template-sections.ts

@@ -0,0 +1,37 @@
+import type { Lexicon, MarkupHeading } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+type Span = { readonly start: number; readonly end: number };
+
+/** Lexicon group of placeholder-word: a word that, in a heading, says what follows is a template (Template, 雛形). */
+export const TEMPLATE = "template";
+
+const LATIN = /\p{Script=Latin}/u;
+
+/** Does the character beside a match end the word? A Latin edge needs a non-letter next to it; a CJK word stands anywhere. */
+const boundsWord = (edge: string, beside: string | undefined): boolean => !LATIN.test(edge) || beside === undefined || !/[\p{L}\p{N}]/u.test(beside);
+
+const holdsWordAt = (text: string, pattern: string, index: number): boolean =>
+  boundsWord(pattern[0] ?? "", text[index - 1]) && boundsWord(pattern.at(-1) ?? "", text[index + pattern.length]);
+
+/** The heading names a template: one of the words appears in it as a whole word, in any case. */
+export const namesTemplate = (heading: string, words: Lexicon): boolean => {
+  const text = heading.toLowerCase();
+  return words.some((word) => {
+    const pattern = word.pattern.toLowerCase();
+    return [...text.matchAll(new RegExp(escapeRegExp(pattern), "gu"))].some((match) => holdsWordAt(text, pattern, match.index));
+  });
+};
+
+/** A heading's section runs from the heading to the next one at its depth or above; text before a template title stays checked. */
+const sectionOf = (headings: readonly MarkupHeading[], index: number, documentEnd: number): Span => {
+  const heading = headings[index];
+  const next = headings.slice(index + 1).find((later) => later.depth <= (heading?.depth ?? 0));
+  return { start: heading?.start ?? 0, end: next?.start ?? documentEnd };
+};
+
+/** The parts of a document under a heading that names a template: their blanks are the point, not a slip. */
+export const templateSections = (headings: readonly MarkupHeading[], documentEnd: number, words: Lexicon): Span[] =>
+  words.length === 0 ? [] : headings.flatMap((heading, index) => (namesTemplate(heading.text, words) ? [sectionOf(headings, index, documentEnd)] : []));
+
+export const isInside = (spans: readonly Span[], offset: number): boolean => spans.some((span) => span.start <= offset && offset < span.end);

package/src/detectors/titled-run.ts

@@ -0,0 +1,43 @@
+import type { Token } from "../plugin.ts";
+import { quotedSpans } from "../quoted-span.ts";
+
+/** 題の付いたものの名前を閉じる語（語彙表 title-ending: 〜要綱、〜試験、〜事業、〜法）。 */
+export type TitleWords = { readonly endings: readonly string[] };
+
+/** 題を囲む括弧。鉤括弧と、見出しや分類の名前を囲む隅付き括弧。 */
+const TITLE_MARKS = { "「": "」", "『": "』", "【": "】" };
+/** 名前のすぐ後ろに付く、その名前の補い（就職氷河期世代）、略称（以下「奨励金」という。）、日付や番号。 */
+const QUALIFIER_OPENERS = new Set(["（", "("]);
+/** 閉じる語の前に要る字数。1 字なら、題ではなく普通の語（新法、本事業）。 */
+const MIN_BODY_LENGTH = 2;
+const BLANK = /^\s*$/u;
+
+const surfaceOf = (tokens: readonly Token[]): string => tokens.map((token) => token.surface).join("");
+
+/**
+ * 連なりの語（run: 隙間なく並ぶ語）が、題の名前を閉じる語で終わるか。閉じる語は語の切れ目で始まる
+ * （地方自治法の「法」は語、解決方法の「法」は方法の一部）。閉じる語の前に 2 字以上の語が要る。
+ */
+export const endsInTitle = (run: readonly Token[], words: TitleWords): boolean =>
+  run.some((_, at) => {
+    const tail = surfaceOf(run.slice(at));
+    return words.endings.includes(tail) && [...surfaceOf(run.slice(0, at))].length >= MIN_BODY_LENGTH;
+  });
+
+/**
+ * 文（text）の start から end までの連なりが、題の名前の置き方をしているか。
+ * 括弧の中身の終わりで閉じる（「令和8年度高度統計人材育成強化拠点形成事業」）、すぐ後ろに補いの括弧が付く
+ * （国家公務員中途採用者選考試験（就職氷河期世代））、または文がその連なりだけ（要綱の題を並べた行）。
+ */
+export const isTitlePosition = (text: string, start: number, end: number): boolean => {
+  const closesBracket = quotedSpans(text, TITLE_MARKS).some((span) => span.end === end && span.start <= start);
+  const qualified = QUALIFIER_OPENERS.has(text.charAt(end));
+  const alone = BLANK.test(text.slice(0, start)) && BLANK.test(text.slice(end));
+  return closesBracket || qualified || alone;
+};
+
+/**
+ * 文書の中で題として置かれた名前（titled: 題の置き方をした連なりと、見出しの中の漢字の連なり）に、
+ * この連なりの字（text）が名前の終わりとして含まれるか。同じ名前は、文の中で使っても名前（認定職業訓練実施奨励金の支給額）。
+ */
+export const isTitledName = (text: string, titled: readonly string[]): boolean => titled.some((name) => name.endsWith(text));

package/src/detectors/unbalanced-bracket.ts

@@ -5,6 +5,7 @@ import { quoteAround } from "./quote-around.ts";
 import { mergeSpans } from "../span-merge.ts";
 import { firstEndingAfter } from "../soft-break.ts";
 import { isLabelClose, isLabelInAside } from "./bracket-label.ts";
+import { isInchMark } from "./inch-mark.ts";
 
 /**
  * 括弧の組。どの言語でも同じ字の決まりなので、語彙表ではなくここに置く。family は形（丸・角）で、全角と半角は同じ形の別の幅。
@@ -93,6 +94,8 @@ export const bracketProblems = (text: string): BracketProblem[] => {
   const scan: Scan = { open: [], problems: [] };
   const heads = paragraphHeads(text);
   [...text.matchAll(MARKS)].forEach((match) => {
+    const quoteOpen = scan.open.some((entry) => entry.bracket.family === "quote");
+    if (isInchMark(text, match.index, quoteOpen)) return;
     const opening = BY_OPEN.get(match[0]);
     const closing = BY_CLOSE.get(match[0]);
     if (opening !== undefined) openWith(scan, opening, match.index, heads.has(match.index));

package/src/detectors/undefined-term.ts

@@ -91,6 +91,8 @@ const findingOf = (doc: ProseDocument, use: UndefinedTerm): Finding => ({
 });
 
 const NAME_LISTS = ["proper-name-word", "place-region", "calendar-name", "month-name", "company-form", "party-role"] as const;
+/** The lists whose words end a name right after a comma (Post Holdings, Inc.; Canton, Ohio). */
+const FORM_ENDS = ["company-form", "place-region"] as const;
 
 /** Capitalised terms, for a language whose package lists the words that join one name (name-joiner); Japanese has none. */
 const capitalisedUses = (doc: ProseDocument, sentences: readonly (readonly Token[])[], defined: readonly Defined[]): UndefinedTerm[] => {
@@ -99,6 +101,12 @@ const capitalisedUses = (doc: ProseDocument, sentences: readonly (readonly Token
     names: NAME_LISTS.flatMap((id) => patternsOf(doc, id)),
     divisions: patternsOf(doc, "numbered-division"),
     joiners: patternsOf(doc, "name-joiner"),
+    nameEnds: patternsOf(doc, "proper-name-word"),
+    formEnds: FORM_ENDS.flatMap((id) => patternsOf(doc, id)),
+    definitionMarkers: patternsOf(doc, "definition-marker"),
+    definedElsewhere: patternsOf(doc, "defined-elsewhere"),
+    capacityMarkers: patternsOf(doc, "capacity-marker"),
+    articles: patternsOf(doc, "article"),
   };
   const marked = [...(doc.markup?.headings ?? []), ...doc.links, ...setApartSpans(doc.source)];
   return capitalisedTerms({ source: doc.source, readable: readableText(doc.source), sentences, defined, named: namedWords(doc.source), marked, words });

package/src/detectors/unfilled-placeholder.ts

@@ -0,0 +1,10 @@
+import type { Detector } from "../plugin.ts";
+import { unfilledPlaceholder } from "./ai-phrasing.ts";
+import { TEMPLATE, isInside, templateSections } from "./template-sections.ts";
+
+/** A blank under a heading that names a template (Template, 雛形) is what the template is for, so it is not reported. */
+export const unfilledPlaceholderOutsideTemplates: Detector = (doc, options) => {
+  const words = (options.lexicon ?? []).filter((word) => word.group === TEMPLATE);
+  const templates = templateSections(doc.markup?.headings ?? [], doc.source.length, words);
+  return unfilledPlaceholder(doc, options).filter((finding) => !isInside(templates, Number(finding.values["offset"])));
+};

package/src/detectors/vague-density.ts

@@ -0,0 +1,68 @@
+// Vague words dense for the document's length (vague-word-density). Each sentence counts the vague words it holds once:
+// a word inside a longer one ("timely" in "in a timely manner") is that longer word, and a word inside a term of art of the
+// document's genre ("reasonably" in a contract, "adequately compensate" as the test for an injunction) is not vague
+// there. The rule speaks once per sentence, about the document's density. Pure: the words come from the language's
+// lexicons vague-word and vague-word-term-of-art, the genre from the options.
+import { entriesForGenre } from "../lexicon-genres.ts";
+import { escapeRegExp } from "../orthography.ts";
+import type { Detector, Finding, Lexicon, LexiconEntry, Sentence } from "../plugin.ts";
+import { comparableText, comparableWords, entryRanges } from "./lexicon-match.ts";
+import { rateOver } from "./lexicon.ts";
+
+const TERMS_OF_ART = "vague-word-term-of-art";
+
+type Place = { readonly start: number; readonly end: number };
+
+type Match = { readonly pattern: string; readonly place: Place };
+
+/** Token spans are places in the document and text places are in the sentence, so one sentence uses one kind for every entry. */
+const readsTokens = (sentence: Sentence, entries: Lexicon): boolean =>
+  sentence.tokens !== undefined && entries.every((entry) => (entry.tokens?.length ?? 0) > 0);
+
+/** Where an entry stands in the sentence, as character spans: its tokens, or the comparable text. */
+const placesOf = (sentence: Sentence, entry: LexiconEntry, byTokens: boolean): Place[] => {
+  const tokens = sentence.tokens;
+  if (byTokens && tokens !== undefined)
+    return entryRanges(sentence, entry).map((range) => ({ start: tokens[range.start]?.span.start ?? 0, end: tokens[range.end - 1]?.span.end ?? 0 }));
+  const word = comparableWords(entry.pattern);
+  if (word === "") return [];
+  return [...comparableText(sentence).matchAll(new RegExp(escapeRegExp(word), "gu"))].map((found) => ({ start: found.index, end: found.index + word.length }));
+};
+
+const matchesOf = (sentence: Sentence, lexicon: Lexicon, byTokens: boolean): Match[] =>
+  lexicon.flatMap((entry) => placesOf(sentence, entry, byTokens).map((place) => ({ pattern: entry.pattern, place })));
+
+const covers = (outer: Place, inner: Place): boolean => outer.start <= inner.start && inner.end <= outer.end;
+
+const isLonger = (outer: Match, inner: Match): boolean => outer.place.end - outer.place.start > inner.place.end - inner.place.start;
+
+/** The vague words of one sentence, in the order written, each once: none inside a longer vague word or a term of art. */
+export const vagueWordsIn = (sentence: Sentence, vague: Lexicon, termsOfArt: Lexicon): string[] => {
+  const byTokens = readsTokens(sentence, [...vague, ...termsOfArt]);
+  const matches = matchesOf(sentence, vague, byTokens);
+  const terms = matchesOf(sentence, termsOfArt, byTokens);
+  const kept = matches.filter(
+    (match) => !matches.some((other) => isLonger(other, match) && covers(other.place, match.place)) && !terms.some((term) => covers(term.place, match.place)),
+  );
+  return [...new Set(kept.toSorted((left, right) => left.place.start - right.place.start).map((match) => match.pattern))];
+};
+
+type SentenceHits = { readonly sentence: Sentence; readonly words: readonly string[] };
+
+export const vagueDensity: Detector = (doc, options): Finding[] => {
+  const termsOfArt = entriesForGenre(doc.lexicons[TERMS_OF_ART] ?? [], options.genre);
+  const hits: SentenceHits[] = doc.sentences
+    .map((sentence) => ({ sentence, words: vagueWordsIn(sentence, options.lexicon ?? [], termsOfArt) }))
+    .filter((hit) => hit.words.length > 0);
+  const count = hits.reduce((sum, hit) => sum + hit.words.length, 0);
+  const density = rateOver(doc, count, options.limit);
+  if (density === undefined) return [];
+  return hits.map(({ sentence, words }) => ({
+    rule: "vague-word-density",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: sentence.text.trim(),
+    values: { matched: words[0] ?? "", count, density, limit: options.limit, offset: sentence.span.start },
+  }));
+};

package/src/facts/fact-scope.ts

@@ -118,20 +118,69 @@ const headCount = (heads: ReadonlyMap<string, readonly number[]>, from: number,
 
 type Lines = { readonly lines: readonly Line[]; readonly breakers: readonly number[]; readonly heads: ReadonlyMap<string, readonly number[]> };
 
-const scopeOf = (fact: Fact, innermost: StructureNode | undefined, at: Lines): { scope: string; record: boolean } => {
+/** 表の、見出しを繰り返した何番目の並びの升か（table-facts の columnGroup）。並びごとに別の範囲。 */
+type PlacedFact = Fact & { readonly columnGroup?: number };
+
+const scopeOf = (fact: PlacedFact, innermost: StructureNode | undefined, at: Lines): { scope: string; record: boolean } => {
   const index = lineIndexAt(at.lines, fact.value.start);
   const from = innermost === undefined ? 0 : lineIndexAt(at.lines, innermost.span.start);
   const to = innermost === undefined ? at.lines.length : lineIndexAt(at.lines, innermost.span.end - 1) + 1;
-  const scope = [innermost?.address ?? "doc", (at.breakers[index] ?? 0) - (at.breakers[from] ?? 0), parentItem(at.lines, index)].join("#");
+  const place = [innermost?.address ?? "doc", (at.breakers[index] ?? 0) - (at.breakers[from] ?? 0), parentItem(at.lines, index)];
+  const scope = [...place, ...(fact.columnGroup === undefined ? [] : [`g${fact.columnGroup}`])].join("#");
   return { scope, record: headCount(at.heads, from, to, fact.key) >= RECORD_REPEATS };
 };
 
+const MAX_PARAGRAPH_HEAD = 40;
+/** 文の終わりか続きの印。これで終わる行は小見出しではない。 */
+const SENTENCE_END = /[.!?。．！？:：;；,、，]$/u;
+const NOT_PLAIN_LINE = /^[ \t]*(?:[#>|]|```|~~~)/u;
+/** setext の見出しの下線。上の行は見出しで、節として木が分ける。 */
+const SETEXT_UNDERLINE = /^[ \t]*(?:=+|-+)[ \t]*$/u;
+
+/**
+ * 段落の頭の、短い名前だけの行（「Example」「Element 1 (standard rated portion)」「例」）。文の終わりの印も値も無く、項目や表の行でもない。
+ * 例や場合ごとに名前を付けた段落の頭で、続く値はその例の値。
+ */
+const isNameOnly = (line: string): boolean => {
+  const text = line.trim();
+  if (text === "" || text.length > MAX_PARAGRAPH_HEAD) return false;
+  return /\p{L}/u.test(text) && !SENTENCE_END.test(text) && !LIST_ITEM.test(line) && !NOT_PLAIN_LINE.test(line);
+};
+
+const isParagraphHead = (lines: readonly Line[], index: number, valueLines: ReadonlySet<number>): boolean => {
+  const startsParagraph = (lines[index - 1]?.text.trim() ?? "") === "";
+  const isSetextHeading = SETEXT_UNDERLINE.test(lines[index + 1]?.text ?? "");
+  return startsParagraph && !isSetextHeading && !valueLines.has(index) && isNameOnly(lines[index]?.text ?? "");
+};
+
+/** 小見出しの代わりの行の数に、段落の頭の名前だけの行も数える。 */
+const withParagraphHeads = (lines: readonly Line[], facts: readonly Fact[]): number[] => {
+  const valueLines = new Set(facts.map((fact) => lineIndexAt(lines, fact.value.start)));
+  return lines.reduce<number[]>(
+    (counts, line, index) => {
+      counts.push((counts[index] ?? 0) + (isBreaker(line) || isParagraphHead(lines, index, valueLines) ? 1 : 0));
+      return counts;
+    },
+    [0],
+  );
+};
+
+/** paragraphHeads: 段落の頭の名前だけの行（Example、例）でも範囲を分ける。 */
+export type ScopeReading = { readonly paragraphHeads?: boolean };
+
 /** 事実ごとに、比べてよい範囲と、文書のどの部分かを付ける。 */
-export const scopedFacts = (facts: readonly Fact[], tree: StructureNode, source: string, summaryWords: readonly string[]): ScopedFact[] => {
+export const scopedFacts = (
+  facts: readonly PlacedFact[],
+  tree: StructureNode,
+  source: string,
+  summaryWords: readonly string[],
+  reading: ScopeReading = {},
+): ScopedFact[] => {
   if (facts.length === 0) return [];
   const nodes = inDocumentOrder(tree).filter((node) => CONTAINERS.has(node.kind));
   const lines = linesOf(source);
-  const at: Lines = { lines, breakers: breakerCounts(lines), heads: headLines(lines) };
+  const breakers = reading.paragraphHeads === true ? withParagraphHeads(lines, facts) : breakerCounts(lines);
+  const at: Lines = { lines, breakers, heads: headLines(lines) };
   return facts
     .toSorted((left, right) => left.value.start - right.value.start)
     .map((fact) => {

package/src/facts/table-facts.ts

@@ -67,18 +67,21 @@ const cellLabel = (rowLabel: string, column: string, headings: readonly string[]
   return headings.length > TWO_COLUMNS ? `${rowLabel} ${column}` : rowLabel;
 };
 
-/** 列が三つ以上の表の升は、行の見出し（row）と列の見出し（column）の二つで名前になる。 */
-export type TableFact = Fact & { readonly cell?: { readonly row: string; readonly column: string } };
+/**
+ * 列が三つ以上の表の升は、行の見出し（row）と列の見出し（column）の二つで名前になる。
+ * columnGroup: 見出しの並びを繰り返す表（Day | Hours | Day | Hours の、第1週と第2週を横に並べた表）の、何番目の並びの升か。
+ */
+export type TableFact = Fact & { readonly cell?: { readonly row: string; readonly column: string }; readonly columnGroup?: number };
 
 const rowFacts = (
-  row: Line,
+  cells: readonly Cell[],
   headings: readonly string[],
   values: readonly FactValue[],
   source: string,
   totals?: TotalColumns,
   counts?: CountLabelWords,
 ): TableFact[] => {
-  const [first, ...rest] = cellsOf(row);
+  const [first, ...rest] = cells;
   if (first === undefined) return [];
   const rowLabel = plain(first.text);
   const isCountHead = (value: FactValue): boolean => counts !== undefined && isCountLabelHead(source, first, value, counts);
@@ -94,11 +97,45 @@ const rowFacts = (
   });
 };
 
+const MIN_GROUPS = 2;
+
+/** 見出しが同じ並びを二度以上繰り返すなら、その並びの幅。並びごとに別の表として読む。 */
+export const columnGroupWidth = (headings: readonly string[]): number | undefined => {
+  const keys = headings.map(keyOf);
+  const widths = Array.from({ length: Math.floor(keys.length / MIN_GROUPS) - 1 }, (_, index) => index + TWO_COLUMNS);
+  return widths.find((width) => keys.length % width === 0 && keys[0] !== "" && keys.every((key, index) => key === keys[index % width]));
+};
+
+const groupsOf = <T>(items: readonly T[], width: number | undefined): T[][] =>
+  width === undefined ? [[...items]] : Array.from({ length: Math.ceil(items.length / width) }, (_, index) => items.slice(index * width, (index + 1) * width));
+
+/** columnGroups: 見出しを繰り返す表を、並びごとに読む（並びの升には columnGroup が付く）。 */
+export type TableReading = { readonly columnGroups?: boolean };
+
+type RowReading = { readonly values: readonly FactValue[]; readonly source: string; readonly totals?: TotalColumns; readonly counts?: CountLabelWords };
+
+/** 一つの行の升の値。見出しを繰り返す表（width がある）は、並びごとに読んで columnGroup を付ける。 */
+const groupedRowFacts = (row: Line, headings: readonly string[], width: number | undefined, at: RowReading): TableFact[] => {
+  const headingGroups = groupsOf(headings, width);
+  return groupsOf(cellsOf(row), width).flatMap((cells, group) => {
+    const facts = rowFacts(cells, headingGroups[group] ?? [], at.values, at.source, at.totals, at.counts);
+    return width === undefined ? facts : facts.map((fact) => ({ ...fact, columnGroup: group }));
+  });
+};
+
 /** 文書の表すべての升の値。 */
-export const tableFacts = (source: string, values: readonly FactValue[], totals?: TotalColumns, counts?: CountLabelWords): TableFact[] =>
+export const tableFacts = (
+  source: string,
+  values: readonly FactValue[],
+  totals?: TotalColumns,
+  counts?: CountLabelWords,
+  reading: TableReading = {},
+): TableFact[] =>
   tablesOf(linesOf(source)).flatMap((table) => {
     const headings = cellsOf(table.header).map((cell) => plain(cell.text));
-    return table.rows.flatMap((row) => rowFacts(row, headings, values, source, totals, counts));
+    const width = reading.columnGroups === true ? columnGroupWidth(headings) : undefined;
+    const at: RowReading = { values, source, ...(totals === undefined ? {} : { totals }), ...(counts === undefined ? {} : { counts }) };
+    return table.rows.flatMap((row) => groupedRowFacts(row, headings, width, at));
   });
 
 /** 文書の表すべての、本体の行の升（見出しの行を除く）。text は書いたまま。 */