chaffjs 0.18.0 → 0.20.0

package/src/detectors/sentence-counts.ts

@@ -0,0 +1,112 @@
+import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence, Token } from "../plugin.ts";
+import { isWithinAny, quotedIn } from "../quoted-span.ts";
+import { entryOpens } from "./lexicon-match.ts";
+
+type TokenTest = (token: Token, at: number, tokens: readonly Token[]) => boolean;
+
+const wordsOf = (lexicon: Lexicon | undefined): ReadonlySet<string> => new Set((lexicon ?? []).map((entry) => entry.pattern));
+
+/** The tokens of a sentence that pass the test, outside anything quoted in 「」『』: a quotation is not the writer's to rephrase. */
+const countedTokens = (sentence: Sentence, test: TokenTest): Token[] => {
+  const quoted = quotedIn(sentence);
+  return (sentence.tokens ?? []).filter((token, at, tokens) => test(token, at, tokens) && !isWithinAny(quoted, token.span));
+};
+
+const findingOf = (sentence: Sentence, counted: readonly Token[], limit: number): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: sentence.text.trim(),
+  values: { word: counted[0]?.surface ?? "", count: counted.length, limit, offset: sentence.span.start },
+});
+
+const sentencesOver = (doc: ProseDocument, limit: number, test: TokenTest): Finding[] =>
+  doc.sentences.flatMap((sentence) => {
+    const counted = countedTokens(sentence, test);
+    return counted.length > limit ? [findingOf(sentence, counted, limit)] : [];
+  });
+
+/** A sentence holding more than limit tokens written as one of the lexicon's words (the suffix 的). */
+export const sentenceWordCount: Detector = (doc, options): Finding[] => {
+  const words = wordsOf(options.lexicon);
+  return sentencesOver(doc, options.limit, (token) => words.has(token.surface));
+};
+
+const NOMINAL: ReadonlySet<string> = new Set(["NOUN", "PROPN", "NUM"]);
+
+const isNominal = (token: Token | undefined): boolean => token !== undefined && NOMINAL.has(token.pos);
+
+const CLOSING_TO_OPENING: Readonly<Record<string, string>> = { "）": "（", ")": "(", "」": "「", "』": "『", "】": "【" };
+
+const isSpace = (token: Token | undefined): boolean => token !== undefined && token.surface.trim() === "";
+
+/** The index of the token an item ends with, before `at`: past spaces and a bracketed note (名前（必須）、). */
+const itemEndBefore = (at: number, tokens: readonly Token[]): number => {
+  const before = tokens.findLastIndex((token, index) => index < at && !isSpace(token));
+  const opening = CLOSING_TO_OPENING[tokens[before]?.surface ?? ""];
+  if (opening === undefined) return before;
+  const opened = tokens.findLastIndex((token, index) => index < before && token.surface === opening);
+  return opened === -1 ? before : itemEndBefore(opened, tokens);
+};
+
+/** The index of the token the next item starts with, past spaces. */
+const itemStartAfter = (at: number, tokens: readonly Token[]): number => tokens.findIndex((token, index) => index > at && !isSpace(token));
+
+/** A comma between two nouns separates listed items (名前、会社名、連絡先), not clauses. A bracketed note after an item is part of it. */
+export const separatesItems = (at: number, tokens: readonly Token[]): boolean =>
+  isNominal(tokens[itemEndBefore(at, tokens)]) && isNominal(tokens[itemStartAfter(at, tokens)]);
+
+/** A sentence cut by more than limit of the lexicon's commas (読点). Commas between listed nouns are not counted. */
+export const sentenceCommaCount: Detector = (doc, options): Finding[] => {
+  const commas = wordsOf(options.lexicon);
+  return sentencesOver(doc, options.limit, (token, at, tokens) => commas.has(token.surface) && !separatesItems(at, tokens));
+};
+
+const CONJUNCTIVE = "SCONJ";
+
+/** A sentence joining more than limit clauses with the lexicon's conjunctive particle (逆接の「が」), not the same word as a case particle. */
+export const sentenceConjunctiveCount: Detector = (doc, options): Finding[] => {
+  const words = wordsOf(options.lexicon);
+  return sentencesOver(doc, options.limit, (token) => token.pos === CONJUNCTIVE && words.has(token.surface));
+};
+
+type Opened = { readonly sentence: Sentence; readonly opener: string | undefined };
+
+const openerOf = (sentence: Sentence, lexicon: Lexicon): string | undefined => lexicon.find((entry) => entryOpens(sentence, entry))?.pattern;
+
+/** Runs of consecutive sentences in one paragraph that each open with a lexicon word. */
+export const openerRuns = (sentences: readonly Sentence[], lexicon: Lexicon): Opened[][] =>
+  sentences
+    .map((sentence) => ({ sentence, opener: openerOf(sentence, lexicon) }))
+    .reduce<Opened[][]>(
+      (runs, opened) => {
+        if (opened.opener === undefined) return [...runs, []];
+        const last = runs.at(-1) ?? [];
+        return [...runs.slice(0, -1), [...last, opened]];
+      },
+      [[]],
+    )
+    .filter((run) => run.length > 0);
+
+const runFinding = (run: readonly Opened[], options: DetectorOptions): Finding => {
+  const first = run[0];
+  return {
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: run.map(({ sentence }) => sentence.text.trim()).join(""),
+    values: { word: first?.opener ?? "", count: run.length, limit: options.limit, offset: first?.sentence.span.start ?? 0 },
+  };
+};
+
+/** More than limit sentences in a row within one paragraph, each opening with a word from the lexicon (これ, その). */
+export const openerRun: Detector = (doc, options): Finding[] => {
+  const lexicon = options.lexicon ?? [];
+  return doc.paragraphs.flatMap((paragraph) =>
+    openerRuns(paragraph.sentences, lexicon)
+      .filter((run) => run.length > options.limit)
+      .map((run) => runFinding(run, options)),
+  );
+};

package/src/detectors/sentence-load.ts

@@ -0,0 +1,45 @@
+import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
+import { proseText } from "../measure.ts";
+import { quotedSpans } from "../quoted-span.ts";
+import { bracketDepth, clauseCount, topicDistance } from "../sentence-load.ts";
+
+const findingOf = (sentence: Sentence, count: number, limit: number): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: proseText(sentence),
+  values: { count, limit, offset: sentence.span.start },
+});
+
+/** Each sentence whose measure is over the limit. A sentence the measure cannot read (undefined) is left alone. */
+const overLimit =
+  (measure: (sentence: Sentence) => number | undefined): Detector =>
+  (doc, options): Finding[] =>
+    doc.sentences.flatMap((sentence) => {
+      const count = measure(sentence);
+      return count === undefined || count <= options.limit ? [] : [findingOf(sentence, count, options.limit)];
+    });
+
+/** Which characters of the text are inside a quotation, marked once so each token is a lookup rather than a scan of every quote. */
+const quotedMask = (text: string): Uint8Array => {
+  const mask = new Uint8Array(text.length);
+  quotedSpans(text).forEach((span) => mask.fill(1, span.start, span.end));
+  return mask;
+};
+
+/** The sentence's tokens outside quotations in 「」『』: a quoted title or remark is one noun to the sentence, whatever it holds. */
+const ownTokens = (sentence: Sentence): Token[] => {
+  const mask = quotedMask(sentence.text);
+  const inQuote = (token: Token): boolean => mask[token.span.start - sentence.span.start] === 1 && mask[token.span.end - 1 - sentence.span.start] === 1;
+  return (sentence.tokens ?? []).filter((token) => !inQuote(token));
+};
+
+/** Brackets inside brackets: 「（注（a）参照）」. The depth is read from the text, so it works in every language. */
+export const bracketNesting: Detector = overLimit((sentence) => bracketDepth(sentence.text));
+
+/** Clauses chained in one sentence (調べて、まとめ、報告したが、返事がないので、…). Needs the language's tokens. */
+export const clauseChain: Detector = overLimit((sentence) => (sentence.tokens === undefined ? undefined : clauseCount(ownTokens(sentence))));
+
+/** The distance from the sentence's topic (〜は) to the end, where its predicate is. Needs the language's tokens. */
+export const topicPredicateDistance: Detector = overLimit((sentence) => (sentence.tokens === undefined ? undefined : topicDistance(ownTokens(sentence))));

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-";
+
+export type Spelling = { readonly family: string; readonly pattern: boolean; readonly other: string };
+
+/** 語（小文字）から、その語がどの組のどちらの綴りか。 */
+export 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,7 +4,7 @@ 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 { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
 
 const QUOTE_LENGTH = 80;
@@ -106,6 +106,8 @@ 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）から取る。 */

package/src/detectors/structure.ts

@@ -1,5 +1,5 @@
 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";
@@ -25,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 [];
@@ -65,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);
@@ -74,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");
 };
 
 /**

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/table-header.ts

@@ -0,0 +1,174 @@
+// The column headers of a document's tables, and the ones written two ways (担当者 / 担当, Owner / Owners, E-mail / Email).
+// Pure; reads the Markdown table rows from the source. Which spelling is right is the writer's choice, so the less common
+// one is reported. The affixes that leave a label's meaning alone (者, 欄; s, es) come from the language's lexicon.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+/** One header cell: its words as written (markup dropped), and where they start in the document. */
+export type HeaderCell = { readonly written: string; readonly offset: number };
+
+const FENCE = /^ {0,3}(`{3,}|~{3,})/u;
+const INDENTED_CODE = /^(?: {4}|\t)/u;
+const DELIMITER_CELL = /^:?-+:?$/u;
+const CELL_SEPARATOR = /(?<!\\)\|/gu;
+
+const INNER_MARKS = /[*`]/gu;
+
+/** Emphasis and code marks around a header's words (**Owner**, `id`); an underscore inside a word (user_id) stays. */
+const isWrappingMark = (char: string): boolean => char === "*" || char === "_" || char === "`";
+
+const unwrap = (text: string): string => {
+  const chars = [...text];
+  const from = chars.findIndex((char) => !isWrappingMark(char));
+  return from === -1 ? "" : chars.slice(from, chars.findLastIndex((char) => !isWrappingMark(char)) + 1).join("");
+};
+
+type Line = { readonly text: string; readonly start: number };
+
+const linesOf = (source: string): Line[] => {
+  const starts = [0, ...[...source.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.map((start, index) => ({ text: source.slice(start, (starts[index + 1] ?? source.length + 1) - 1), start }));
+};
+
+/** The lines outside fenced and indented code: a table written in a code sample is the sample's. A fence closes on its own mark. */
+const outsideCode = (lines: readonly Line[]): Line[] => {
+  const kept: Line[] = [];
+  lines.reduce<string | undefined>((open, line) => {
+    const fence = FENCE.exec(line.text)?.[1];
+    if (open !== undefined) return fence !== undefined && fence[0] === open[0] && fence.length >= open.length ? undefined : open;
+    if (fence !== undefined) return fence;
+    if (!INDENTED_CODE.test(line.text)) kept.push(line);
+    return undefined;
+  }, undefined);
+  return kept;
+};
+
+/** The cells of a table row as written, the pipes at either end dropped. */
+const rawCells = (line: Line): { readonly raw: string; readonly from: number }[] => {
+  const bounds = [-1, ...[...line.text.matchAll(CELL_SEPARATOR)].map((match) => match.index), line.text.length];
+  const cells = bounds.slice(1).map((end, index) => {
+    const from = (bounds[index] ?? -1) + 1;
+    return { raw: line.text.slice(from, end), from };
+  });
+  const inner = cells.slice(cells[0]?.raw.trim() === "" ? 1 : 0);
+  return inner.at(-1)?.raw.trim() === "" ? inner.slice(0, -1) : inner;
+};
+
+const labelCell = (line: Line, { raw, from }: { readonly raw: string; readonly from: number }): HeaderCell[] => {
+  const trimmed = raw.trim();
+  const unwrapped = unwrap(trimmed);
+  const written = unwrapped.replace(INNER_MARKS, "").trim();
+  const lead = raw.indexOf(trimmed) + trimmed.indexOf(unwrapped.trimStart());
+  return /\p{L}/u.test(written) ? [{ written, offset: line.start + from + lead }] : [];
+};
+
+/** The |---|:-:| row under a table's header: one dash cell per header cell, with a colon at either end for alignment. */
+const isDelimiterRow = (line: Line | undefined, columns: number): boolean => {
+  if (line === undefined) return false;
+  const cells = rawCells(line);
+  return cells.length === columns && cells.every((cell) => DELIMITER_CELL.test(cell.raw.trim()));
+};
+
+const isTableRow = (line: Line | undefined): line is Line => line !== undefined && line.text.includes("|") && line.text.trim() !== "";
+
+/** The body rows of the table whose delimiter row is at index: every row with a pipe up to the first line without one. */
+const bodyRows = (lines: readonly Line[], delimiter: number): Line[] => {
+  const rows: Line[] = [];
+  for (let at = delimiter + 1; at < lines.length; at += 1) {
+    const row = lines[at];
+    if (!isTableRow(row)) break;
+    rows.push(row);
+  }
+  return rows;
+};
+
+/** Two columns: a table of fields and their values (担当者 | 山田). */
+const FIELD_TABLE_COLUMNS = 2;
+
+/**
+ * The label cells of every Markdown table: the header row (the row right above a |---| row), and in a two-column table
+ * also the first cell of each row, which names a field.
+ */
+export const tableHeaderCells = (source: string): HeaderCell[] => {
+  const lines = outsideCode(linesOf(source));
+  return lines.flatMap((line, index) => {
+    const header = isTableRow(line) ? rawCells(line) : [];
+    if (header.length === 0 || !isDelimiterRow(lines[index + 1], header.length)) return [];
+    const labels = header.flatMap((cell) => labelCell(line, cell));
+    if (header.length !== FIELD_TABLE_COLUMNS) return labels;
+    const fields = bodyRows(lines, index + 1).flatMap((row) =>
+      rawCells(row)
+        .slice(0, 1)
+        .flatMap((cell) => labelCell(row, cell)),
+    );
+    return [...labels, ...fields];
+  });
+};
+
+/** The form two spellings of one label share: width, case, spaces, hyphens and middle dots folded. */
+export const foldedLabel = (written: string): string =>
+  written
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/[\s\-‐・·._]/gu, "");
+
+/** A stem shorter than this matches too much (名 against 名前, s against anything). */
+const MIN_STEM = 2;
+
+/** The label and each stem left by dropping one affix the language says does not change it (担当者 → 担当, owners → owner). */
+export const labelKeys = (written: string, affixes: readonly string[]): Set<string> => {
+  const folded = foldedLabel(written);
+  const stems = affixes
+    .filter((affix) => folded.endsWith(affix) && [...folded].length - [...affix].length >= MIN_STEM)
+    .map((affix) => folded.slice(0, -affix.length));
+  return new Set([folded, ...stems]);
+};
+
+const shareKey = (left: ReadonlySet<string>, right: ReadonlySet<string>): boolean => [...left].some((key) => right.has(key));
+
+/** The cells grouped by label: two cells are one label when they share a key. Each group in document order. */
+export const labelGroups = (cells: readonly HeaderCell[], affixes: readonly string[]): HeaderCell[][] => {
+  const keyed = cells.map((cell) => ({ cell, keys: labelKeys(cell.written, affixes) }));
+  const groups: { keys: Set<string>; cells: HeaderCell[] }[] = [];
+  keyed.forEach(({ cell, keys }) => {
+    const joined = groups.filter((group) => shareKey(group.keys, keys));
+    const merged = { keys: new Set([...keys, ...joined.flatMap((group) => [...group.keys])]), cells: [...joined.flatMap((group) => group.cells), cell] };
+    joined.forEach((group) => groups.splice(groups.indexOf(group), 1));
+    groups.push(merged);
+  });
+  return groups
+    .map((group) => group.cells.toSorted((left, right) => left.offset - right.offset))
+    .toSorted((left, right) => (left[0]?.offset ?? 0) - (right[0]?.offset ?? 0));
+};
+
+const PERCENT = 100;
+
+/**
+ * The cells of one label not written the usual way. The usual way is the most common spelling; on a tie, the first one.
+ * Nothing when the other spellings together are more than limitPercent of the label's cells.
+ */
+export const oddSpellings = (cells: readonly HeaderCell[], limitPercent: number): { readonly odd: HeaderCell[]; readonly usual: string } => {
+  const counts = new Map<string, number>();
+  cells.forEach((cell) => counts.set(cell.written, (counts.get(cell.written) ?? 0) + 1));
+  const most = Math.max(0, ...counts.values());
+  const usual = cells.find((cell) => counts.get(cell.written) === most)?.written ?? "";
+  const odd = cells.filter((cell) => cell.written !== usual);
+  return odd.length * PERCENT > limitPercent * cells.length ? { odd: [], usual } : { odd, usual };
+};
+
+const findingOf = (cell: HeaderCell, usual: string, count: number, of: number, limit: number): Finding => ({
+  rule: "table-header-variant",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: cell.written,
+  values: { written: cell.written, usual, count, of, limit, offset: cell.offset },
+});
+
+/** Each table header cell whose label the document's other tables write another way. */
+export const tableHeaderVariant: Detector = (doc: ProseDocument, options): Finding[] => {
+  const affixes = (doc.lexicons["label-affix"] ?? []).map((entry) => foldedLabel(entry.pattern));
+  return labelGroups(tableHeaderCells(doc.source), affixes).flatMap((cells) => {
+    const { odd, usual } = oddSpellings(cells, options.limit);
+    return odd.map((cell) => findingOf(cell, usual, odd.length, cells.length, options.limit));
+  });
+};

package/src/detectors/team.ts

@@ -2,7 +2,7 @@ import { proseText } from "../measure.ts";
 import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
 import { nameSpans } from "../team-names.ts";
-import type { Detector, Finding, Sentence, Span, Token } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
 /**
  * チームの言葉。社内でしか通じない語を、チームが chaff.yaml に自分で並べる。
@@ -40,6 +40,12 @@ export const internalJargon: Detector = (doc, options): Finding[] => {
 
 const has = (headings: readonly string[], wanted: string): boolean => headings.some((heading) => heading.includes(wanted));
 
+/** The wanted sections no heading names. A heading names one when it contains it: 「主なリスク」 has 「リスク」. */
+export const missingSections = (doc: Pick<ProseDocument, "sections">, wanted: readonly string[]): string[] => {
+  const headings = doc.sections.map((section) => section.heading);
+  return wanted.filter((name) => !has(headings, name));
+};
+
 /**
  * この種類の文書に無いと困る見出し。チームが chaff.yaml で決める。
  *
@@ -49,8 +55,7 @@ const has = (headings: readonly string[], wanted: string): boolean => headings.s
 export const requiredSections: Detector = (doc, options): Finding[] => {
   const wanted = doc.requiredSections;
   if (wanted.length === 0) return [];
-  const headings = doc.sections.map((section) => section.heading);
-  const missing = wanted.filter((name) => !has(headings, name));
+  const missing = missingSections(doc, wanted);
   if (missing.length < options.limit) return [];
   return [
     {
@@ -58,7 +63,10 @@ export const requiredSections: Detector = (doc, options): Finding[] => {
       severity: "error",
       line: 0,
       column: 0,
-      quote: headings.filter((heading) => heading.length > 0).join(" / "),
+      quote: doc.sections
+        .map((section) => section.heading)
+        .filter((heading) => heading.length > 0)
+        .join(" / "),
       values: { word: joinWords(missing, doc.language), count: missing.length, limit: options.limit, offset: 0 },
     },
   ];