chaffjs 0.19.0 → 0.21.0

package/src/detectors/relative-dates.ts

@@ -0,0 +1,113 @@
+import type { Detector, Finding, ProseDocument, Span, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { overlapsAny, spanIndex } from "../compare/spans.ts";
+import type { DurationUnit } from "../derived/date-arithmetic.ts";
+import { relativeMismatches, type DatedValue, type Relative } from "../derived/relative-dates.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** 期間の単位の語彙表。relative-year-unit は、向きの語が付くときだけ期間になる単位（「1年前」の年）。 */
+const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
+  ["duration-day", "day"],
+  ["duration-week", "week"],
+  ["duration-month", "month"],
+  ["duration-year", "year"],
+  ["relative-year-unit", "year"],
+];
+
+type Amount = Span & { readonly amount: number; readonly unit: DurationUnit };
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const unitOf = (doc: ProseDocument, written: string): DurationUnit | undefined => {
+  const unit = written.normalize("NFKC").toLowerCase();
+  return DURATION_LEXICONS.find(([id]) => patternsOf(doc, id).some((pattern) => pattern.normalize("NFKC").toLowerCase() === unit))?.[1];
+};
+
+/** 数のすぐ後ろ（空白一つまで）に書いた単位まで。木の数量は単位の前で終わることがある（3 days の 3）。 */
+const endWithUnit = (source: string, end: number, unit: string): number => {
+  const gap = source.charAt(end) === " " || source.charAt(end) === "\t" ? 1 : 0;
+  return unit !== "" && source.startsWith(unit, end + gap) ? end + gap + unit.length : end;
+};
+
+const treeAmounts = (doc: ProseDocument, tree: StructureNode): Amount[] =>
+  inDocumentOrder(tree).flatMap((node): Amount[] => {
+    const written = String(node.attrs["unit"] ?? "");
+    const unit = node.kind === "quantity" ? unitOf(doc, written) : undefined;
+    if (unit === undefined) return [];
+    return [{ start: node.span.start, end: endWithUnit(doc.source, node.span.end, written), amount: Number(node.attrs["value"]), unit }];
+  });
+
+/** 語で書いた数（two weeks）。count-number の語彙表は一から順に並ぶので、位置が数。 */
+/** 数の語と、その後ろの単位の語。単位は先読みで読むので、語を二つずつ食べずに、どの語も数の語として試せる。 */
+const WORD_AMOUNT = /(?<![\p{L}\p{N}])(\p{L}+)(?=([ \t]+)(\p{L}+)(?![\p{L}\p{N}]))/gu;
+
+const wordAmounts = (doc: ProseDocument, taken: readonly Span[]): Amount[] => {
+  const numbers = patternsOf(doc, "count-number").map((word) => word.toLowerCase());
+  const index = spanIndex(taken);
+  return [...doc.source.matchAll(WORD_AMOUNT)].flatMap((match): Amount[] => {
+    const position = numbers.indexOf((match[1] ?? "").toLowerCase());
+    const unit = unitOf(doc, match[3] ?? "");
+    const span = { start: match.index, end: match.index + (match[1] ?? "").length + (match[2] ?? "").length + (match[3] ?? "").length };
+    return position === -1 || unit === undefined || overlapsAny(index, span) ? [] : [{ ...span, amount: position + 1, unit }];
+  });
+};
+
+const LATIN = /^[a-z ]+$/iu;
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+
+/** 期間のすぐ後ろの、向きの語（後、later）。英字の語は空白を挟んで、語の切れ目まで。 */
+const directionOf = (doc: ProseDocument, amount: Amount): 1 | -1 | undefined => {
+  const after = doc.source.slice(amount.end, amount.end + 20).toLowerCase();
+  const matches = (word: string): boolean => {
+    const lower = word.toLowerCase();
+    if (!LATIN.test(word)) return after.startsWith(lower);
+    return after.startsWith(` ${lower}`) && !WORD_CHAR.test(after.charAt(lower.length + 1));
+  };
+  if (patternsOf(doc, "relative-after").some(matches)) return 1;
+  return patternsOf(doc, "relative-before").some(matches) ? -1 : undefined;
+};
+
+/** 向きの語まで含めた相対の期間。 */
+const relativesOf = (doc: ProseDocument, amounts: readonly Amount[]): Relative[] =>
+  amounts.flatMap((amount): Relative[] => {
+    const direction = directionOf(doc, amount);
+    if (direction === undefined) return [];
+    const words = patternsOf(doc, direction === 1 ? "relative-after" : "relative-before");
+    const after = doc.source.slice(amount.end).toLowerCase();
+    const word = words.find((candidate) => after.trimStart().startsWith(candidate.toLowerCase())) ?? "";
+    const end = amount.end + (after.length - after.trimStart().length) + word.length;
+    return [{ ...amount, end, direction }];
+  });
+
+const datesOf = (tree: StructureNode): DatedValue[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ ...node.span, value: String(node.attrs["value"]) }] : []));
+
+/** 相対で書いた日付（3日後の10月5日）が、基準の日付から数えた日と合わない。 */
+export const relativeDateMismatch: Detector = (doc): Finding[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const dates = datesOf(tree);
+  const fromTree = treeAmounts(doc, tree);
+  const amounts = [...fromTree, ...wordAmounts(doc, [...fromTree, ...dates])];
+  const input = {
+    source: doc.source,
+    sentences: doc.sentences.map((sentence) => sentence.span),
+    dates,
+    relatives: relativesOf(doc, amounts),
+    links: patternsOf(doc, "relative-link"),
+  };
+  return relativeMismatches(input).map((mismatch) => ({
+    rule: "relative-date-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, mismatch.target.start),
+    values: {
+      base: doc.source.slice(mismatch.base.start, mismatch.base.end),
+      relative: doc.source.slice(mismatch.relative.start, mismatch.relative.end),
+      target: doc.source.slice(mismatch.target.start, mismatch.target.end),
+      expected: mismatch.expected,
+      offset: mismatch.target.start,
+    },
+  }));
+};

package/src/detectors/request-owner.ts

@@ -0,0 +1,141 @@
+// A request for an action (「資料をご確認ください」 "Please send the report.") with no deadline and no person or role,
+// in its own sentence or the next. The words come from the language's lexicons; the code only combines them.
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Span, StructureNode } from "../plugin.ts";
+import { proseText } from "../measure.ts";
+import { comparableWords } from "./lexicon-match.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+
+/** The lexicons the rule reads, by name. A language without them checks nothing. */
+export const REQUEST_LEXICONS = {
+  ending: "request-ending",
+  action: "request-action",
+  condition: "request-condition",
+  deadline: "request-deadline",
+  owner: "request-owner",
+  pointer: "request-pointer",
+} as const;
+
+type Words = Readonly<Record<keyof typeof REQUEST_LEXICONS, readonly string[]>>;
+
+/** A clock time (14:00, 14時, 2pm) says when as much as a date does; a duration (3時間) does not. */
+const CLOCK = /\d{1,2}\s*(?:[:：]\d{2}|時(?!間)|\s?[ap]\.?m\.?(?![a-z]))/iu;
+
+const patternsOf = (lexicon: Lexicon | undefined): string[] => (lexicon ?? []).map((entry) => comparableWords(entry.pattern));
+
+const wordsOf = (doc: ProseDocument): Words => ({
+  ending: patternsOf(doc.lexicons[REQUEST_LEXICONS.ending]),
+  action: patternsOf(doc.lexicons[REQUEST_LEXICONS.action]),
+  condition: patternsOf(doc.lexicons[REQUEST_LEXICONS.condition]),
+  deadline: patternsOf(doc.lexicons[REQUEST_LEXICONS.deadline]),
+  owner: patternsOf(doc.lexicons[REQUEST_LEXICONS.owner]),
+  pointer: patternsOf(doc.lexicons[REQUEST_LEXICONS.pointer]),
+});
+
+/** How far apart, in characters, the action word and the request ending may be: the action must be what is requested. */
+const ACTION_REACH = 12;
+
+/** A Latin word matches whole words only ("by" is not in "maybe"); other scripts have no spaces to bound a word. */
+const matcherOf = (pattern: string): RegExp =>
+  /^[\p{Script=Latin}\d]/u.test(pattern)
+    ? new RegExp(`(?<![\\p{L}\\d])${escapeRegExp(pattern)}(?![\\p{L}\\d])`, "gu")
+    : new RegExp(escapeRegExp(pattern), "gu");
+
+type Place = { readonly start: number; readonly end: number };
+
+/** Where the lexicon's words occur in the text (after the comparable form: lower case, straight apostrophes). */
+const placesOf = (text: string, patterns: readonly string[]): Place[] => {
+  const comparable = comparableWords(text);
+  return patterns
+    .filter((pattern) => pattern !== "")
+    .flatMap((pattern) => [...comparable.matchAll(matcherOf(pattern))].map((match) => ({ start: match.index, end: match.index + match[0].length })));
+};
+
+export const containsAny = (text: string, patterns: readonly string[]): boolean => placesOf(text, patterns).length > 0;
+
+const gapBetween = (left: Place, right: Place): number => Math.max(left.start - right.end, right.start - left.end, 0);
+
+/**
+ * A request for an action: an action word next to a request ending (「確認してください」「please send」), not a condition
+ * (「ご不明な点があれば…ください」 is an offer), and not a pointer to where to read more (「詳細は資料をご確認ください」).
+ * The action has to be close to the ending, or a noun like 検討会 or 履修登録 earlier in the sentence would make one.
+ */
+export const isRequest = (text: string, words: Words): boolean => {
+  const endings = placesOf(text, words.ending);
+  const asked = placesOf(text, words.action).some((action) => endings.some((ending) => gapBetween(action, ending) <= ACTION_REACH));
+  return asked && !containsAny(text, words.condition) && !containsAny(text, words.pointer);
+};
+
+const NAMED = new Set(["PROPN"]);
+
+/** A proper noun in the request itself (「Ito, please share」) names who; one in the next sentence may be a product or a place. */
+const namesSomeone = (sentence: Sentence): boolean => (sentence.tokens ?? []).some((token) => NAMED.has(token.pos));
+
+const datedWithin = (dates: readonly Span[], span: Span): boolean => dates.some((date) => date.start >= span.start && date.start < span.end);
+
+type Bounds = { readonly starts: ReadonlySet<number>; readonly ends: ReadonlySet<number> };
+
+/** Where the sentence's words start and end in its comparable text, found by walking the token surfaces in order. */
+const wordBounds = (comparable: string, sentence: Sentence): Bounds | undefined => {
+  const tokens = sentence.tokens;
+  if (tokens === undefined || tokens.length === 0) return undefined;
+  const starts = new Set<number>();
+  const ends = new Set<number>();
+  tokens.reduce((from, token) => {
+    const surface = comparableWords(token.surface);
+    const at = surface === "" ? -1 : comparable.indexOf(surface, from);
+    if (at === -1) return from;
+    starts.add(at);
+    ends.add(at + surface.length);
+    return at + surface.length;
+  }, 0);
+  return { starts, ends };
+};
+
+/**
+ * Whether the sentence holds one of the words as whole words. With parts of speech a word must start and end on a word
+ * boundary, so 様 is not found in 同様, さん in たくさん, or まで in いままで; without them, as text.
+ */
+const holdsWord = (sentence: Sentence, patterns: readonly string[]): boolean => {
+  const comparable = comparableWords(proseText(sentence));
+  const bounds = wordBounds(comparable, sentence);
+  return placesOf(comparable, patterns).some((place) => bounds === undefined || (bounds.starts.has(place.start) && bounds.ends.has(place.end)));
+};
+
+/** Whether a sentence says when (a date, a clock time, a deadline word) or who (a role; a name in the request itself). */
+const saysWhenOrWho = (sentence: Sentence, words: Words, dates: readonly Span[], isRequestItself: boolean): boolean =>
+  datedWithin(dates, sentence.span) ||
+  CLOCK.test(proseText(sentence)) ||
+  holdsWord(sentence, words.deadline) ||
+  holdsWord(sentence, words.owner) ||
+  (isRequestItself && namesSomeone(sentence));
+
+/** A paragraph break or a new list item between two sentences: the second does not continue the first. */
+const BREAK = /\n[^\S\n]*\n|\n[^\S\n]*(?:[-*+]|\d+[.)])[^\S\n]/u;
+
+const continues = (source: string, sentence: Sentence, next: Sentence | undefined): next is Sentence =>
+  next !== undefined && !BREAK.test(source.slice(sentence.span.end, next.span.start));
+
+const dateSpans = (tree: StructureNode | undefined): Span[] =>
+  tree === undefined ? [] : inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [node.span] : []));
+
+/** The request sentences with neither a deadline nor a person in them or in the sentence after, in the same paragraph or item. */
+export const ownerlessRequests = (doc: ProseDocument): Sentence[] => {
+  const words = wordsOf(doc);
+  const dates = dateSpans(doc.structure);
+  return doc.sentences.filter((sentence, index) => {
+    if (!isRequest(proseText(sentence), words) || saysWhenOrWho(sentence, words, dates, true)) return false;
+    const next = doc.sentences[index + 1];
+    return !continues(doc.source, sentence, next) || !saysWhenOrWho(next, words, dates, false);
+  });
+};
+
+export const requestWithoutDeadline: Detector = (doc: ProseDocument): Finding[] =>
+  ownerlessRequests(doc).map((sentence) => ({
+    rule: "request-without-deadline",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: proseText(sentence),
+    values: { offset: sentence.span.start },
+  }));

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/spelling-variety.ts

@@ -8,10 +8,10 @@ import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
  */
 const SPELLING_LISTS = "spelling-";
 
-type Spelling = { readonly family: string; readonly pattern: boolean; readonly other: string };
+export type Spelling = { readonly family: string; readonly pattern: boolean; readonly other: string };
 
 /** 語（小文字）から、その語がどの組のどちらの綴りか。 */
-const spellingsOf = (lexicons: ProseDocument["lexicons"]): ReadonlyMap<string, Spelling> =>
+export const spellingsOf = (lexicons: ProseDocument["lexicons"]): ReadonlyMap<string, Spelling> =>
   new Map(
     Object.entries(lexicons)
       .filter(([id]) => id.startsWith(SPELLING_LISTS))

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 },
     },
   ];