chaffjs 0.18.0 → 0.19.0

package/src/stet-block.ts

@@ -0,0 +1,60 @@
+import { spanOf, type MarkdownNode } from "./markdown-node.ts";
+import type { Span } from "./plugin.ts";
+
+/**
+ * Where a `<!-- stet: … -->` (scope next) stops: the end of the block right after the comment, as the Markdown parser
+ * reads it — a paragraph, a heading, a whole list, a table, a code block, a quote. Inside a list item, the item's next
+ * block. Plain text reads the same way: its paragraphs are the runs between blank lines.
+ */
+
+/** Containers whose children are blocks. Anywhere else, an HTML comment sits inside a paragraph or a heading. */
+const BLOCK_CONTAINERS: ReadonlySet<string> = new Set(["root", "listItem", "blockquote"]);
+
+type Holder = { readonly parent: MarkdownNode; readonly index: number };
+
+/** The child holding `offset`, or -1. Binary search: siblings are in source order, and a document can hold thousands of stets. */
+const childHolding = (children: readonly MarkdownNode[], offset: number): number => {
+  let low = 0;
+  let high = children.length - 1;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    const span = spanOf(children[middle] ?? { type: "" });
+    if (span === undefined) return -1;
+    if (offset < span.start) high = middle - 1;
+    else if (offset >= span.end) low = middle + 1;
+    else return middle;
+  }
+  return -1;
+};
+
+/** The deepest node holding `offset`, as its parent and its place among the parent's children. A loop: quotes nest without limit. */
+const holderOf = (root: MarkdownNode, offset: number): Holder | undefined => {
+  let found: Holder | undefined;
+  let parent: MarkdownNode | undefined = root;
+  while (parent !== undefined) {
+    const children: readonly MarkdownNode[] = parent.children ?? [];
+    const index = childHolding(children, offset);
+    if (index !== -1) found = { parent, index };
+    parent = children[index];
+  }
+  return found;
+};
+
+/** The node a stet covers: the next block when the comment stands alone, else the block the comment is part of. */
+const coveredNode = (source: string, holder: Holder, comment: Span): MarkdownNode | undefined => {
+  const siblings = holder.parent.children ?? [];
+  const node = siblings[holder.index];
+  if (node === undefined) return undefined;
+  if (!BLOCK_CONTAINERS.has(holder.parent.type)) return holder.parent;
+  const span = spanOf(node);
+  const alone = span !== undefined && source.slice(span.start, span.end).trim() === source.slice(comment.start, comment.end);
+  return alone ? siblings[holder.index + 1] : node;
+};
+
+/** The last line a `stet` (scope next) covers, for the comment at `comment` in a document parsed as `root`. */
+export const stetBlockEnd = (source: string, root: MarkdownNode, comment: Span, lineAt: (offset: number) => number): number => {
+  const holder = holderOf(root, comment.start);
+  const covered = holder === undefined ? undefined : coveredNode(source, holder, comment);
+  const end = covered === undefined ? undefined : spanOf(covered)?.end;
+  return lineAt(end ?? comment.end);
+};

package/src/stet.ts

@@ -1,9 +1,15 @@
 import type { Finding, Span } from "./plugin.ts";
+import { RULE_ID } from "./extension/plugin-name.ts";
+import { stetBlockEnd } from "./stet-block.ts";
+import { lineStarts, placeOf } from "./position.ts";
+import { parse } from "./markdown-read.ts";
 
 export type Suppression = {
   readonly rules: readonly string[];
   readonly reason: string | undefined;
   readonly line: number;
+  /** The last line a `stet` (scope next) covers: the end of the block right below the comment. Other scopes: the comment's last line. */
+  readonly blockEnd: number;
   readonly scope: "next" | "section" | "file";
 };
 
@@ -23,10 +29,6 @@ const SCOPE: Readonly<Record<string, Suppression["scope"]>> = { stet: "next", "s
 /** 理由は em dash のあと。書かなくてもよいが、書かないと chaff suppressions に並ぶ。 */
 const REASON_MARK = "\u2014";
 
-const RULE_ID = /^[a-z][a-z0-9-]*$/u;
-
-const lineOf = (source: string, offset: number): number => source.slice(0, offset).split("\n").length;
-
 const splitBody = (body: string): { rules: string[]; reason: string | undefined } => {
   const at = body.indexOf(REASON_MARK);
   const head = at === -1 ? body : body.slice(0, at);
@@ -43,37 +45,61 @@ const splitBody = (body: string): { rules: string[]; reason: string | undefined
   };
 };
 
-export const parseSuppressions = (source: string): Suppression[] =>
-  [...source.matchAll(PATTERN)].map((match) => ({
-    ...splitBody(match[2] ?? ""),
-    line: lineOf(source, match.index),
-    scope: SCOPE[match[1] ?? "stet"] ?? "next",
-  }));
+const scopeOf = (match: RegExpMatchArray): Suppression["scope"] => SCOPE[match[1] ?? "stet"] ?? "next";
+
+/** 1-based line of an offset, from a table built once: a document can hold thousands of stets. */
+const lineFinder = (source: string): ((offset: number) => number) => {
+  const starts = lineStarts(source);
+  return (offset) => placeOf(starts, offset).line;
+};
 
-/** stet が効く範囲。next は直後の塊、section は次の見出しまで、file は全体。 */
-const NEXT_LINES = 6;
+export const parseSuppressions = (source: string): Suppression[] => {
+  const matches = [...source.matchAll(PATTERN)];
+  const lineAt = lineFinder(source);
+  // Only a plain stet needs the tree, to find the block it stops at; a stet-file alone does not pay for a parse.
+  const root = matches.some((match) => scopeOf(match) === "next") ? parse(source) : undefined;
+  return matches.map((match) => {
+    const comment = { start: match.index, end: match.index + match[0].length };
+    const scope = scopeOf(match);
+    return {
+      ...splitBody(match[2] ?? ""),
+      line: lineAt(match.index),
+      blockEnd: root !== undefined && scope === "next" ? stetBlockEnd(source, root, comment, lineAt) : lineAt(comment.end),
+      scope,
+    };
+  });
+};
 
+/** stet が効く範囲。next は直後の塊（段落・見出し・箇条書き・表）の終わりまで、section は次の見出しまで、file は全体。 */
 const covers = (suppression: Suppression, finding: Finding, sectionEnds: readonly number[], lastLine: number): boolean => {
   if (!suppression.rules.includes(finding.rule)) return false;
   if (suppression.scope === "file") return true;
   // 抑制は「この先の箇所」に対して書く。遡って効くと、意図せず黙る範囲が広がる。
   if (finding.line < suppression.line) return false;
-  if (suppression.scope === "next") return finding.line - suppression.line <= NEXT_LINES;
+  if (suppression.scope === "next") return finding.line <= suppression.blockEnd;
   return finding.line <= (sectionEnds.find((line) => line > suppression.line) ?? lastLine);
 };
 
 export type Suppressed = { readonly finding: Finding; readonly suppression: Suppression };
 
-export type Applied = { readonly kept: readonly Finding[]; readonly suppressed: readonly Suppressed[]; readonly unusedReasonless: readonly Suppression[] };
+export type Applied = {
+  readonly kept: readonly Finding[];
+  readonly suppressed: readonly Suppressed[];
+  readonly unusedReasonless: readonly Suppression[];
+  /** Every rule a stet in the document names, whether or not it silenced anything. */
+  readonly named: readonly string[];
+};
 
 export const applySuppressions = (source: string, findings: readonly Finding[], sections: readonly Span[]): Applied => {
   const suppressions = parseSuppressions(source);
-  const sectionEnds = sections.map((span) => lineOf(source, span.end));
+  const lineAt = lineFinder(source);
+  const sectionEnds = sections.map((span) => lineAt(span.end));
   const lastLine = source.split("\n").length;
   const matched = findings.map((finding) => ({ finding, suppression: suppressions.find((entry) => covers(entry, finding, sectionEnds, lastLine)) }));
   return {
     kept: matched.filter((entry) => entry.suppression === undefined).map((entry) => entry.finding),
     suppressed: matched.flatMap((entry) => (entry.suppression === undefined ? [] : [{ finding: entry.finding, suppression: entry.suppression }])),
     unusedReasonless: suppressions.filter((entry) => entry.reason === undefined),
+    named: [...new Set(suppressions.flatMap((entry) => entry.rules))],
   };
 };

package/src/structure/date-range.ts

@@ -1,3 +1,4 @@
+import { escapeRegExp } from "../orthography.ts";
 import type { StructureIssue } from "./issues.ts";
 
 /**
@@ -13,6 +14,18 @@ export type RangeWords = {
   /** 終わりの日付に閉じの語が続くときだけ期間を作る語（から）。 */
   readonly openers: readonly string[];
   readonly closers: readonly string[];
+  /** 始まりの日付の前の語と、二つの日付の間の語の組で期間を作るもの（from … to、between … and）。 */
+  readonly frames: readonly RangeFrame[];
+  /** 同じ文にあれば、組を期間ではなく日付の変更と読む語（moved from … to、… was postponed）。 */
+  readonly changes: readonly string[];
+};
+
+export type RangeFrame = { readonly lead: string; readonly joint: string };
+
+/** 語彙表の「from … to」を、前の語と間の語に分ける。「…」の無い語は組ではない。 */
+export const rangeFrameOf = (pattern: string): RangeFrame | undefined => {
+  const [lead, joint, ...rest] = pattern.split("…").map((part) => part.trim().toLowerCase());
+  return lead === undefined || joint === undefined || lead === "" || joint === "" || rest.length > 0 ? undefined : { lead, joint };
 };
 
 const COMPARABLE = [/^\d{4}-\d{2}-\d{2}$/u, /^\d{4}-\d{2}$/u];
@@ -45,10 +58,45 @@ const jointOf = (source: string, start: DatedSpan, end: DatedSpan): string | und
   return next.every((line) => line.trim() === "") ? bare(first) : undefined;
 };
 
+/** 英字の語は語の切れ目で照らす（from が therefrom に当たらず、moved が removed に当たらない）。 */
+const wordPattern = (word: string, tail: string): RegExp => new RegExp(`(?<![a-z])${escapeRegExp(word)}(?![a-z])${tail}`, "u");
+
+const endsWithWord = (text: string, word: string): boolean => wordPattern(word, "$").test(text);
+
+const hasWord = (text: string, word: string): boolean => wordPattern(word, "").test(text);
+
+/** 段落の切れ目（空行）。 */
+const PARAGRAPH_BREAK = "\n\n";
+
+/** 文の終わり。後ろが大文字のときだけ切る（"in Jan. from" は切らない）。切りそこねると文が長くなり、変更の語を見つけやすくなるだけ。 */
+const SENTENCE_BREAK = /[.!?]\s+(?=[A-Z])/gu;
+
+/** 二つの日付を含む文（小文字、空白は一つに）と、その中の始まりの日付の位置。行の折り返しをまたいで読む。 */
+const sentenceAround = (source: string, start: DatedSpan, end: DatedSpan): { readonly text: string; readonly before: string } => {
+  const previousBreak = source.lastIndexOf(PARAGRAPH_BREAK, start.offset);
+  const paragraphStart = previousBreak === -1 ? 0 : previousBreak + PARAGRAPH_BREAK.length;
+  const paragraphEnd = source.indexOf(PARAGRAPH_BREAK, end.end);
+  const head = source.slice(paragraphStart, start.offset);
+  const tail = source.slice(end.end, paragraphEnd === -1 ? source.length : paragraphEnd);
+  const from = [...head.matchAll(SENTENCE_BREAK)].map((match) => match.index + match[0].length).at(-1) ?? 0;
+  const to = [...tail.matchAll(SENTENCE_BREAK)][0]?.index ?? tail.length;
+  const flat = (text: string): string => text.replace(/\s+/gu, " ").toLowerCase();
+  return { text: flat(source.slice(paragraphStart + from, end.end + to)), before: flat(head.slice(from)).trimEnd() };
+};
+
+/** 前の語と間の語の組（from … to）。同じ文のどこかに変更の語（moved、postponed）があれば、日付を動かした文で、期間ではない。 */
+const framed = (source: string, start: DatedSpan, end: DatedSpan, joint: string, words: RangeWords): boolean => {
+  const sentence = sentenceAround(source, start, end);
+  const frame = words.frames.find((candidate) => candidate.joint === joint && endsWithWord(sentence.before, candidate.lead));
+  return frame !== undefined && !words.changes.some((change) => hasWord(sentence.text, change.toLowerCase()));
+};
+
 const isRange = (source: string, start: DatedSpan, end: DatedSpan, words: RangeWords): boolean => {
   const joint = jointOf(source, start, end);
   if (joint === undefined) return false;
-  return isOneOf(joint, words.connectors) || (isOneOf(joint, words.openers) && closedAfter(source, end, words.closers));
+  return (
+    isOneOf(joint, words.connectors) || (isOneOf(joint, words.openers) && closedAfter(source, end, words.closers)) || framed(source, start, end, joint, words)
+  );
 };
 
 /** 書いたままの期間。行をまたいだ期間は一行にする。 */

package/src/structure/definition-use.ts

@@ -0,0 +1,130 @@
+import type { Span, StructureNode } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { inDocumentOrder } from "./issues.ts";
+
+// 定義した語が本文で使われているか、定義より前に使われていないか。どちらも木の定義と、本文の文の字面だけで決まる。
+
+export type DefinedTerm = { readonly term: string; readonly span: Span; readonly line: number; readonly inline: boolean };
+
+/** 本文の一続き（文）。start は文書の中の位置。 */
+export type BodyText = { readonly start: number; readonly text: string };
+
+export type TermUse = { readonly term: DefinedTerm; readonly offset: number };
+
+/** 強調の印（"**Agreement**"）は語の一部ではない。 */
+const EMPHASIS_MARKS = /[*_]+/gu;
+/** 語の長さの上限。これより長い引用（表の見出し、文）は、定義した語ではない。 */
+const MAX_TERM_WORDS = 6;
+/** 文の区切りや問いを含むもの（"What do you think about...?"）は、引いた言葉で、定義した語ではない。 */
+const NOT_A_TERM = /(?:[?!,;:…。、？！]|\.$)/u;
+const HAS_LETTER = /\p{L}/u;
+
+const isTerm = (term: string): boolean => HAS_LETTER.test(term) && !NOT_A_TERM.test(term) && term.split(/\s+/u).length <= MAX_TERM_WORDS;
+
+/** 木の定義を文書の順に。語でないものは外す。inline は文の途中で括弧に入れた定義（(the "Seller")、以下「甲」という）。 */
+export const definedTerms = (tree: StructureNode): DefinedTerm[] =>
+  inDocumentOrder(tree).flatMap((node) => {
+    const term =
+      node.kind === "definition"
+        ? String(node.attrs["term"] ?? "")
+            .replaceAll(EMPHASIS_MARKS, "")
+            .trim()
+        : "";
+    return isTerm(term) ? [{ term, span: node.span, line: node.line, inline: node.attrs["placement"] === "inline" }] : [];
+  });
+
+const LATIN_EDGE = /^[\p{Script=Latin}\p{N}]|[\p{Script=Latin}\p{N}]$/u;
+/** 一字の漢字の語（「法」「甲」）は、漢字の後ろに続く所（方法、法律の前の「方」）では別の語の一部。 */
+const SINGLE_KANJI = /^\p{Script=Han}$/u;
+
+/** loose は最初の一字の大小を問わない（文頭の "Personal data"）。exact は書いたとおりだけ（"Access" は "early access" に当たらない）。 */
+type CaseMatch = "loose" | "exact";
+
+/**
+ * 語の現れを探す形。英字で始まる・終わる語は語の途中に当たらない（"Term" は "Terms" には当たり、"Termination" には当たらない）。
+ * 複数形と所有の形（Services、Policies、Seller's）は同じ語の使用。
+ */
+const termPattern = (term: string, caseMatch: CaseMatch): RegExp => {
+  const first = term.charAt(0);
+  const rest = /\p{Ll}y$/u.test(term) ? `${escapeRegExp(term.slice(1, -1))}(?:y|ie)` : escapeRegExp(term.slice(1));
+  const caseless = caseMatch === "exact" || first.toUpperCase() === first.toLowerCase();
+  const head = caseless ? escapeRegExp(first) : `[${escapeRegExp(first.toUpperCase())}${escapeRegExp(first.toLowerCase())}]`;
+  if (SINGLE_KANJI.test(term)) return new RegExp(String.raw`(?<!\p{Script=Han})${head}`, "gu");
+  if (!LATIN_EDGE.test(term)) return new RegExp(`${head}${rest}`, "gu");
+  return new RegExp(String.raw`(?<![\p{Script=Latin}\p{N}])${head}${rest}(?:e?s|['’]s?)?(?![\p{Script=Latin}\p{N}])`, "gu");
+};
+
+const inside = (offset: number, spans: readonly Span[]): boolean => spans.some((span) => span.start <= offset && offset < span.end);
+
+/** 語の現れ（文書の中の位置）を順に。定義そのもの（"Seller" means、(the "Seller")）の中の現れは使用に数えない。 */
+export const usesOf = (term: string, texts: readonly BodyText[], definitionSpans: readonly Span[], caseMatch: CaseMatch = "loose"): number[] => {
+  const pattern = termPattern(term, caseMatch);
+  return texts.flatMap((body) =>
+    [...body.text.matchAll(pattern)].map((match) => body.start + match.index).filter((offset) => !inside(offset, definitionSpans)),
+  );
+};
+
+type TermGroup = { readonly first: DefinedTerm; readonly spans: readonly Span[] };
+
+/** 語ごとに、最初の定義と、その語のすべての定義の範囲。定義が何千あっても語の数だけ回る。 */
+const groupsOf = (terms: readonly DefinedTerm[]): TermGroup[] => {
+  const groups = new Map<string, { first: DefinedTerm; spans: Span[] }>();
+  terms.forEach((defined) => {
+    const group = groups.get(defined.term);
+    if (group === undefined) groups.set(defined.term, { first: defined, spans: [defined.span] });
+    else group.spans.push(defined.span);
+  });
+  return [...groups.values()];
+};
+
+/** 定義したのに、定義の外で一度も使っていない語。同じ語の定義が二つあれば、最初の一つだけを言う（二つ目は duplicate-definition）。 */
+export const unusedDefinitions = (terms: readonly DefinedTerm[], texts: readonly BodyText[]): DefinedTerm[] =>
+  groupsOf(terms)
+    .filter((group) => usesOf(group.first.term, texts, group.spans).length === 0)
+    .map((group) => group.first);
+
+/** offset を含む文。texts は start の昇順で、二分探索で引く。 */
+const sentenceAt = (texts: readonly BodyText[], offset: number): BodyText | undefined => {
+  let low = 0;
+  let high = texts.length - 1;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    const body = texts[middle];
+    if (body === undefined) return undefined;
+    if (offset < body.start) high = middle - 1;
+    else if (offset >= body.start + body.text.length) low = middle + 1;
+    else return body;
+  }
+  return undefined;
+};
+
+const LETTER = /\p{L}/gu;
+/** 札の文が語のほかに持ってよい字の数（"The Agreement." の The）。 */
+const LABEL_SLACK = 3;
+
+/** 語だけの札の文（**12.2.** Taxes.、1. The Agreement.）。条の頭に語を掲げただけで、使用ではない。 */
+const isLabel = (body: BodyText | undefined, term: string): boolean =>
+  body !== undefined && (body.text.replaceAll(term, "").match(LETTER) ?? []).length <= LABEL_SLACK;
+
+const CAPITAL_OR_NON_LATIN = /\p{Lu}|[^\p{Script=Latin}\p{N}\s\p{P}]/u;
+
+/**
+ * 前で使ったと言える語。小文字の英語（("vendors")）はふつうの語としても使うので、前の現れが定義した語の使用とは限らない。
+ * 一字の漢字（「法」「令」）は、令和や方法の一部にも当たる。
+ */
+const isDistinctive = (term: string): boolean => CAPITAL_OR_NON_LATIN.test(term) && !SINGLE_KANJI.test(term);
+
+/**
+ * 文の途中で括弧に入れて定義した語（(the "Seller")、以下「甲」という）を、その定義の文より前で使っている所。最初の一つだけ。
+ * 定義の文の中の現れ（株式会社GovTech東京（以下「GovTech東京」という。））は、定義する名前そのものなので数えない。札の文も数えない。
+ * 定義の条（"Seller" means、「甲」とは）は条の並びの頭にも終わりにも置く書き方があるので、前で使っても言わない。
+ */
+export const usesBeforeDefinition = (terms: readonly DefinedTerm[], texts: readonly BodyText[]): TermUse[] =>
+  groupsOf(terms)
+    .filter((group) => group.first.inline && isDistinctive(group.first.term))
+    .flatMap(({ first: defined, spans }) => {
+      const defining = sentenceAt(texts, defined.span.start)?.start ?? defined.span.start;
+      const uses = usesOf(defined.term, texts, spans, "exact");
+      const first = uses.find((offset) => !isLabel(sentenceAt(texts, offset), defined.term));
+      return first !== undefined && first < defining ? [{ term: defined, offset: first }] : [];
+    });

package/src/structure/lazy-tree.ts

@@ -0,0 +1,15 @@
+import type { StructureNode, StructurePatterns } from "../plugin.ts";
+import { buildTree, type StructureInput } from "./build.ts";
+
+/**
+ * 構造の rule（参照先が無い・番号の抜け）が読む木を、読まれたときに一度だけ作る。どの rule も読まなければ作らない。
+ * 何万行の契約書で、他の rule の lint に代金を払わせない。構造を読めない言語（patterns が無い）では無い。
+ */
+export const lazyTree = (patterns: StructurePatterns | undefined, input: () => StructureInput): (() => StructureNode | undefined) => {
+  // null は「作ったが構造を読めない言語だった」、undefined は「まだ作っていない」。
+  const tree: { value: StructureNode | null | undefined } = { value: undefined };
+  return () => {
+    tree.value ??= patterns === undefined ? null : buildTree(input(), patterns);
+    return tree.value ?? undefined;
+  };
+};

package/src/structure/modal-conflict.ts

@@ -0,0 +1,86 @@
+import type { Sentence, Span, Token } from "../plugin.ts";
+
+// 同じ主語と行為に、逆の様相（しなければならない と してはならない、may と must not）を書いた二つの文。
+// 主語と行為は、文の中身の語（名詞・固有名詞・動詞・形容詞）の集まりで近似する。様相の語そのものは数えない。
+
+/** 木の義務の節点。type は must / must-not / may。 */
+export type Obligation = { readonly start: number; readonly end: number; readonly type: string; readonly marker: string };
+
+export type ModalStatement = { readonly offset: number; readonly type: string; readonly marker: string; readonly key: string };
+
+export type ModalConflict = { readonly statement: ModalStatement; readonly earlier: ModalStatement };
+
+const CONTENT: ReadonlySet<string> = new Set(["NOUN", "PROPN", "VERB", "ADJ"]);
+
+/** 中身の語がこれより少ない文（"You must not."）は、何を決めているかが文の外にあるので比べない。 */
+const MIN_CONTENT_WORDS = 2;
+
+/** 互いに食い違う様相。must と may は食い違わない（しなければならないことは、してよい）。 */
+const OPPOSITE: Readonly<Record<string, readonly string[]>> = {
+  must: ["must-not"],
+  "must-not": ["must", "may"],
+  may: ["must-not"],
+};
+
+const overlaps = (token: Token, spans: readonly Span[]): boolean => spans.some((span) => token.span.start < span.end && span.start < token.span.end);
+
+/** 文の中身の語を、原形の小文字で、重ねずに並べたもの。様相の語の範囲にかかる語は外す。 */
+export const contentKey = (tokens: readonly Token[], markers: readonly Span[]): string =>
+  [
+    ...new Set(
+      tokens
+        .filter((token) => CONTENT.has(token.pos) && !overlaps(token, markers))
+        .map((token) => (token.lemma !== undefined && token.lemma !== "" ? token.lemma : token.surface).toLowerCase()),
+    ),
+  ]
+    .toSorted((left, right) => left.localeCompare(right, "en"))
+    .join(" ");
+
+/** offset を含む文。sentences は start の昇順で、二分探索で引く。 */
+const sentenceAt = (sentences: readonly Sentence[], offset: number): Sentence | undefined => {
+  let low = 0;
+  let high = sentences.length - 1;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    const sentence = sentences[middle];
+    if (sentence === undefined) return undefined;
+    if (offset < sentence.span.start) high = middle - 1;
+    else if (offset >= sentence.span.end) low = middle + 1;
+    else return sentence;
+  }
+  return undefined;
+};
+
+/**
+ * 様相の語を一つだけ持つ文の、様相と中身。二つ以上持つ文（shall do A and shall not do B）は、どの語がどの行為にかかるかが
+ * 中身の語の集まりからは分からないので外す。品詞の無い文も外す。
+ */
+export const modalStatements = (obligations: readonly Obligation[], sentences: readonly Sentence[]): ModalStatement[] => {
+  const bySentence = new Map<Sentence, Obligation[]>();
+  obligations.forEach((obligation) => {
+    const sentence = sentenceAt(sentences, obligation.start);
+    if (sentence === undefined) return;
+    const found = bySentence.get(sentence);
+    if (found === undefined) bySentence.set(sentence, [obligation]);
+    else found.push(obligation);
+  });
+  return [...bySentence].flatMap(([sentence, found]) => {
+    const [only] = found;
+    if (found.length !== 1 || only === undefined || sentence.tokens === undefined) return [];
+    const key = contentKey(sentence.tokens, [only]);
+    return key.split(" ").length < MIN_CONTENT_WORDS ? [] : [{ offset: sentence.span.start, type: only.type, marker: only.marker, key }];
+  });
+};
+
+/** 前に同じ中身で逆の様相を書いた文がある文。中身と様相の組ごとに、最初の文と比べる。 */
+export const modalConflicts = (statements: readonly ModalStatement[]): ModalConflict[] => {
+  const firsts = new Map<string, ModalStatement>();
+  return statements
+    .toSorted((left, right) => left.offset - right.offset)
+    .flatMap((statement) => {
+      const earlier = (OPPOSITE[statement.type] ?? []).map((type) => firsts.get(`${type}\u0000${statement.key}`)).find((found) => found !== undefined);
+      const own = `${statement.type}\u0000${statement.key}`;
+      if (!firsts.has(own)) firsts.set(own, statement);
+      return earlier === undefined ? [] : [{ statement, earlier }];
+    });
+};

package/src/structure/numbered-clauses.ts

@@ -0,0 +1,11 @@
+import type { StructureNode } from "../plugin.ts";
+
+/**
+ * A numbered chapter (第1章), or an article numbered at the top level (第3条, 「1 適用範囲」, "2. Payment"). Clauses
+ * number from 1 at the top, so a tree whose articles are all dotted (## 0.18.0, ## 1.0 in a changelog) holds versions,
+ * not clauses. A 号 item or a heading is not a clause.
+ */
+const isClause = (node: StructureNode): boolean => node.kind === "chapter" || (node.kind === "article" && !node.address.includes("."));
+
+/** Pure: whether the tree holds a numbered clause anywhere. */
+export const numbersClauses = (node: StructureNode): boolean => isClause(node) || node.children.some(numbersClauses);

package/src/structure/universal.ts

@@ -5,7 +5,12 @@ import { numberInSentence } from "./number-in-sentence.ts";
  * 「4.2 設定」「3.1.4 Scope」のような通し番号。数字と点だけで書くので言語を問わない。
  * 各部分を 3 桁・深さを 6 までに抑え、後戻りが爆発しない形にしてある。
  */
-const DOTTED = /^[ \t]{0,3}(?<number>\d{1,3}(?:\.\d{1,3}){0,5})(?<closing>\.)?[ \t\u3000]+(?<rest>\S.*)$/u;
+const DOTTED = /^[ \t]{0,3}(?<number>\d{1,3}(?:\.\d{1,3}){0,5})(?<closing>[.．])?[ \t\u3000]+(?<rest>\S.*)$/u;
+/**
+ * 見出しで、点で閉じた番号に題を詰めて書いたもの（「7.委託」「7．委託」「2.Overview」）。後ろが数字なら小数（「1.5万人」）、
+ * 小文字なら版（「2.x 系」）なので読まない。
+ */
+const TIGHT_HEADING = /^[ \t]{0,3}(?<number>\d{1,3}(?:\.\d{1,3}){0,5})(?<closing>[.．])(?<rest>[^\s\d\p{Ll}.．].*)$/u;
 
 /**
  * RFC のようなテキストの仕様書（Markdown でないもの）の章見出し「5.  Security Considerations」。Markdown では、行内のコードを伏せた空白が
@@ -18,6 +23,9 @@ const MAX_TITLE = 80;
 
 const isTopSection = (line: string, rest: string): boolean => TOP_SECTION.test(line) && rest.length <= MAX_TITLE && !SENTENCE_END.test(rest);
 
+const dottedGroups = (line: string, context: NumberingContext): Readonly<Record<string, string | undefined>> | undefined =>
+  DOTTED.exec(line)?.groups ?? (context.isHeading ? TIGHT_HEADING.exec(line)?.groups : undefined);
+
 /** closedByDot: 番号を点で閉じたか（「5. 」）。「1.5 万人」の 1.5 は閉じていない。 */
 type DottedLine = NumberedLine & { readonly closedByDot: boolean };
 
@@ -26,7 +34,7 @@ type DottedLine = NumberedLine & { readonly closedByDot: boolean };
  * 「4.2 」のように点を含むものは、.txt の仕様書でも見出しとして書かれるので本文でも読む。
  */
 export const dottedNumber = (line: string, context: NumberingContext, plainText = false): DottedLine | undefined => {
-  const groups = DOTTED.exec(line)?.groups;
+  const groups = dottedGroups(line, context);
   const number = groups?.["number"];
   if (number === undefined) return undefined;
   const depth = number.split(".").length;

package/src/style-parse.ts

@@ -6,6 +6,9 @@ import type { Level, Localized } from "./plugin.ts";
 
 export type StyleSource = { readonly title: Localized; readonly url: string };
 
+/** { rule id: { language: limit } }. A guideline gives a number for one language (60 characters for Japanese) and none for another. */
+export type StyleLimits = Readonly<Record<string, Readonly<Record<string, number>>>>;
+
 export type StyleDefinition = {
   readonly id: string;
   readonly name: Localized;
@@ -16,6 +19,8 @@ export type StyleDefinition = {
   readonly rules: Readonly<Record<string, Level>>;
   /** { rule id: { option: value } }, checked against the rules' declared options by the tests. */
   readonly options: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+  /** The numbers the guideline sets, by language. The rule needs a level under rules too, or the limit decides nothing. */
+  readonly limits: StyleLimits;
 };
 
 const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -57,12 +62,41 @@ const optionsOf = (value: unknown, where: string): Record<string, Readonly<Recor
   );
 };
 
+const isLimit = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value) && value > 0;
+
+const languageLimitsOf = (id: string, value: unknown, where: string): Record<string, number> => {
+  if (!isRecord(value) || Object.keys(value).length === 0) throw new Error(`${where}: limits.${id} must be a map of languages to numbers`);
+  return Object.fromEntries(
+    Object.entries(value).map(([language, limit]) => {
+      if (!isLimit(limit)) throw new Error(`${where}: limits.${id}.${language} must be a number above 0`);
+      return [language, limit];
+    }),
+  );
+};
+
+const limitsOf = (value: unknown, rules: Readonly<Record<string, Level>>, where: string): Record<string, Record<string, number>> => {
+  if (value === undefined) return {};
+  if (!isRecord(value)) throw new Error(`${where}: limits must be a map of rule ids`);
+  return Object.fromEntries(
+    Object.entries(value).map(([id, byLanguage]) => {
+      if (rules[id] === undefined || rules[id] === "off") throw new Error(`${where}: limits.${id} needs ${id} under rules at a level that runs`);
+      return [id, languageLimitsOf(id, byLanguage, where)];
+    }),
+  );
+};
+
 /** One style file. Throws on anything it cannot read: the file ships with chaff, so a wrong entry is chaff's bug. */
 export const parseStyle = (raw: unknown, file: string): StyleDefinition => {
-  if (!isRecord(raw)) throw new Error(`${file}: a style must be a map`);
+  const id = isRecord(raw) ? raw["id"] : undefined;
+  if (isRecord(raw) && (typeof id !== "string" || `${id}.yaml` !== file)) throw new Error(`${file}: id must be the file's name without .yaml`);
+  return styleOf(raw, file);
+};
+
+/** One style, wherever it was written (where names it in what is thrown). Throws on anything it cannot read. */
+export const styleOf = (raw: unknown, where: string): StyleDefinition => {
+  if (!isRecord(raw)) throw new Error(`${where}: a style must be a map`);
   const id = raw["id"];
-  if (typeof id !== "string" || `${id}.yaml` !== file) throw new Error(`${file}: id must be the file's name without .yaml`);
-  const where = `${file}`;
+  if (typeof id !== "string" || id === "") throw new Error(`${where}: a style needs an id`);
   const rules = levelsOf(raw["rules"], where);
   const options = optionsOf(raw["options"], where);
   if (Object.keys(rules).length === 0 && Object.keys(options).length === 0) throw new Error(`${where}: a style must set rules or options`);
@@ -73,5 +107,6 @@ export const parseStyle = (raw: unknown, file: string): StyleDefinition => {
     source: sourceOf(raw["source"], where),
     rules,
     options,
+    limits: limitsOf(raw["limits"], rules, where),
   };
 };