chaffjs 0.19.0 → 0.20.0

package/src/detectors/registry/vague-link-text.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { vagueLinkText } from "../vague-link-text.ts";
+
+export const detector: Detector = vagueLinkText;

package/src/detectors/registry-files.ts

@@ -0,0 +1,12 @@
+/** A file in detectors/registry/ and the how_to_find it serves: its name without the extension. */
+export type RegistryEntry = { readonly file: string; readonly howToFind: string };
+
+/**
+ * The registry files among a directory's names, in name order. Only names ending in the extension of the running module
+ * count: from src that is .ts, from dist .js, where the .d.ts and .map files beside them are not detectors.
+ */
+export const registryEntries = (names: readonly string[], extension: string): RegistryEntry[] =>
+  names
+    .filter((name) => name.endsWith(extension) && !name.endsWith(`.d${extension}`) && name.length > extension.length)
+    .toSorted((left, right) => left.localeCompare(right, "en"))
+    .map((file) => ({ file, howToFind: file.slice(0, -extension.length) }));

package/src/detectors/registry-load.ts

@@ -0,0 +1,23 @@
+import { existsSync, readdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { registryEntries } from "./registry-files.ts";
+
+// require (not import) keeps a registry ready synchronously, without a top-level await in every importer.
+const requireModule = createRequire(import.meta.url);
+
+const detectorOf = (loaded: unknown): unknown => (typeof loaded === "object" && loaded !== null && "detector" in loaded ? loaded.detector : undefined);
+
+/**
+ * The detectors of a registry directory, one file per how_to_find, each exporting a function named detector.
+ * extension is that of the running module (.ts from src, .js from dist). A directory that is not there holds none.
+ */
+export const loadRegistry = <T>(dir: string, extension: string, isDetector: (value: unknown) => value is T): Readonly<Record<string, T>> =>
+  Object.fromEntries(
+    registryEntries(existsSync(dir) ? readdirSync(dir) : [], extension).map(({ file, howToFind }) => {
+      const path = join(dir, file);
+      const detector = detectorOf(requireModule(path));
+      if (!isDetector(detector)) throw new Error(`chaff: ${path} must export a function named detector`);
+      return [howToFind, detector];
+    }),
+  );

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

package/src/detectors/unit-consistency.ts

@@ -0,0 +1,55 @@
+import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import { nameSpans } from "../compare/proper-nouns.ts";
+import { overlapsAny, spanIndex } from "../compare/spans.ts";
+import { factValues, type FactValue } from "../facts/fact-values.ts";
+import { labelledFacts } from "../facts/labelled-facts.ts";
+import { tableFacts } from "../facts/table-facts.ts";
+import { scopedFacts } from "../facts/fact-scope.ts";
+import { measuredValues, type Measured, type MeasureUnit } from "../facts/measures.ts";
+import { unitConflicts } from "../facts/unit-conflicts.ts";
+import { factWordsOf } from "./fact-consistency.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** 量の種類ごとの語彙表。weight が基準の単位への倍率で、同じ単位を二度書けば倍率が二つ（GB の 10^9 と 2^30）。 */
+const DIMENSIONS = ["unit-length", "unit-mass", "unit-time", "unit-volume", "unit-data"] as const;
+
+const unitsOf = (doc: ProseDocument): MeasureUnit[] =>
+  DIMENSIONS.flatMap((dimension) => {
+    const factors = new Map<string, number[]>();
+    (doc.lexicons[dimension] ?? []).forEach((entry) => {
+      if (entry.weight !== undefined) factors.set(entry.pattern, [...(factors.get(entry.pattern) ?? []), entry.weight]);
+    });
+    return [...factors.entries()].map(([pattern, weights]) => ({ pattern, dimension, factors: weights }));
+  });
+
+/** fact-conflict と同じ値に、単位の付いた量を足す。量と重なる値（量の数だけを読んだもの）は量に置き換える。 */
+const valuesWith = (tree: StructureNode, doc: ProseDocument, measured: readonly Measured[]): FactValue[] => {
+  const taken = spanIndex(measured);
+  const others = factValues(tree, doc.source, nameSpans(doc)).filter((value) => !overlapsAny(taken, value));
+  return [...others, ...measured].toSorted((left, right) => left.start - right.start);
+};
+
+/** 同じ名前の量を、違う単位で書いて、換算すると合わない。 */
+export const unitMismatch: Detector = (doc): Finding[] => {
+  const tree = doc.structure;
+  if (tree === undefined) return [];
+  const measured = measuredValues(doc.source, unitsOf(doc));
+  if (measured.length === 0) return [];
+  const byStart = new Map(measured.map((value) => [value.start, value]));
+  const values = valuesWith(tree, doc, measured);
+  const facts = [...labelledFacts(doc.source, values, factWordsOf(doc)), ...tableFacts(doc.source, values)];
+  const scoped = scopedFacts(facts, tree, doc.source, []);
+  return unitConflicts(scoped, (fact) => byStart.get(fact.value.start)).map((conflict) => ({
+    rule: "unit-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, conflict.measured.start),
+    values: {
+      label: conflict.fact.label,
+      value: doc.source.slice(conflict.measured.start, conflict.measured.end),
+      other: doc.source.slice(conflict.other.start, conflict.other.end),
+      offset: conflict.measured.start,
+    },
+  }));
+};

package/src/detectors/unknown-word.ts

@@ -0,0 +1,43 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { isKnownWord, suggestionFor, wordsToCheck, type CheckedWord, type Speller } from "../spelling.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** これより短い語は見ない。短い語は一字違いの語が多すぎて言い直しが決まらず（tost は test か toast か）、略した語（impl）も多い。 */
+const MIN_LENGTH = 5;
+
+/** これより長い字の並びは語でなく、符号化したデータ（base64、ハッシュ）。一字違いの形を作ると長さの二乗で重くなる。 */
+const MAX_LENGTH = 30;
+
+const patternsOf = (doc: ProseDocument, name: string): string[] => (doc.lexicons[name] ?? []).map((entry) => entry.pattern.toLowerCase());
+
+/** 辞書と、語彙表 extra-word の語と、チームの names と、別の rule が言う誤り（known-misspelling）を足した語。 */
+const spellerOf = (doc: ProseDocument, dictionary: ReadonlySet<string>): Speller => ({
+  words: [dictionary, new Set([...patternsOf(doc, "extra-word"), ...(doc.names ?? []).map((name) => name.toLowerCase())])],
+  suffixes: (doc.lexicons["word-suffix"] ?? []).map((entry) => ({ suffix: entry.pattern, replacement: entry.instead_of ?? "" })),
+  prefixes: patternsOf(doc, "word-prefix"),
+});
+
+/** 文書で一度だけ使った語。二度以上使う語は、打ち間違いより、その文書の用語であることが多い。 */
+const usedOnce = (words: readonly CheckedWord[]): CheckedWord[] => {
+  const counts = new Map<string, number>();
+  words.forEach(({ word }) => counts.set(word, (counts.get(word) ?? 0) + 1));
+  return words.filter(({ word }) => counts.get(word) === 1);
+};
+
+/**
+ * 辞書に無い英語の語で、一字違いの辞書の語があるもの（recieve → receive）。辞書は adapter が持ち、無い言語では動かない。
+ * 大文字を含む語（固有名詞・略語）、コード・URL の中、二度以上使う語、言い直しの無い語は言わない。
+ */
+export const unknownWord: Detector = (doc): Finding[] => {
+  if (doc.dictionary === undefined) return [];
+  const speller = spellerOf(doc, doc.dictionary());
+  const known = new Set(patternsOf(doc, "known-misspelling"));
+  const words = wordsToCheck(doc.prose ?? doc.source, MIN_LENGTH, MAX_LENGTH);
+  const used = new Set(words.map(({ word }) => word).filter((word) => isKnownWord(word, speller)));
+  return usedOnce(words).flatMap(({ offset, word }) => {
+    if (known.has(word) || isKnownWord(word, speller)) return [];
+    const suggestion = suggestionFor(word, speller, used);
+    if (suggestion === undefined) return [];
+    return [{ rule: "", severity: "warning", line: 0, column: 0, quote: quoteAt(doc.source, offset), values: { word, suggestion, offset } }];
+  });
+};