chaffjs 0.18.0 → 0.20.0

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/absolute-exception.ts

@@ -0,0 +1,104 @@
+import type { Span, Token } from "../plugin.ts";
+import { CONTENT } from "./modal-conflict.ts";
+
+// An absolute obligation (すべての〜は…しなければならない, "must always", 「一切…してはならない」) and, later in the same document
+// and outside its own article or paragraph, an exception for the same act (「ただし…を除く」, "except"). The absolute
+// statement does not carry the exception, so a reader who stops at it applies it to every case.
+
+/** One sentence read for this rule. */
+export type Statement = {
+  readonly offset: number;
+  /** Content words (lemmas, lower case), without the absolute word, the exception word and the modal marker. */
+  readonly words: readonly string[];
+  /** The absolute word it holds (すべての, always), if any. */
+  readonly absolute: string | undefined;
+  /** The exception word it holds (ただし, except), if any. */
+  readonly exception: string | undefined;
+  /** It holds exactly one obligation marker, and that marker requires or forbids (must, must not). */
+  readonly obligation: boolean;
+  /** The act the obligation binds: the content word next to the marker (comply in "must comply", 負う in 「負わないものとする」). */
+  readonly act: string | undefined;
+  /** Where its own provisos sit: the start of its article, list or paragraph. */
+  readonly unit: number;
+};
+
+const lemmaOf = (token: Token): string => (token.lemma !== undefined && token.lemma !== "" ? token.lemma : token.surface).toLowerCase();
+
+const outside = (token: Token, spans: readonly Span[]): boolean => spans.every((span) => token.span.end <= span.start || span.end <= token.span.start);
+
+/**
+ * Pure: the act an obligation binds. The content word nearest the marker, by tokens, leaving out light verbs (する, be)
+ * and the words in `skip`; on a tie the verb, else the one after the marker (English puts the verb after "must", Japanese
+ * before 「なければならない」).
+ */
+export const actOf = (tokens: readonly Token[], marker: Span, skip: readonly Span[], lightVerbs: ReadonlySet<string>): string | undefined => {
+  const first = tokens.findIndex((token) => token.span.end > marker.start);
+  const last = tokens.findLastIndex((token) => token.span.start < marker.end);
+  if (first === -1 || last === -1) return undefined;
+  const candidates = tokens
+    .map((token, index) => ({ token, index }))
+    .filter(({ token, index }) => (index < first || index > last) && CONTENT.has(token.pos) && outside(token, skip) && !lightVerbs.has(lemmaOf(token)))
+    .map(({ token, index }) => ({ token, distance: index < first ? first - index : index - last, after: index > last }));
+  const rank = (candidate: (typeof candidates)[number]): number =>
+    candidate.distance * 4 + (candidate.token.pos === "VERB" ? 0 : 2) + (candidate.after ? 0 : 1);
+  const nearest = candidates.toSorted((left, right) => rank(left) - rank(right))[0];
+  return nearest === undefined ? undefined : lemmaOf(nearest.token);
+};
+
+export type Contradicted = { readonly absolute: Statement; readonly exception: Statement; readonly shared: readonly string[] };
+
+/** Fewer shared words than this, and the two sentences may be about different things. */
+const MIN_SHARED = 2;
+
+/** The share of the absolute statement's content words the exception must repeat to be about the same subject and act. */
+const MIN_SHARE_PERCENT = 60;
+const PERCENT = 100;
+
+const isAbsolute = (statement: Statement): boolean => statement.absolute !== undefined && statement.exception === undefined && statement.obligation;
+
+const sharedWords = (absolute: Statement, exception: Statement): string[] => {
+  const later = new Set(exception.words);
+  return absolute.words.filter((word) => later.has(word));
+};
+
+/** The exception names the act the rule binds, and repeats most of the rule's other words (its subject and object). */
+const isSameAct = (absolute: Statement, exception: Statement, shared: readonly string[]): boolean =>
+  absolute.act !== undefined &&
+  exception.words.includes(absolute.act) &&
+  shared.length >= MIN_SHARED &&
+  shared.length * PERCENT >= absolute.words.length * MIN_SHARE_PERCENT;
+
+/**
+ * Pure: absolute obligations that a later sentence, outside their own unit, makes an exception to. The absolute statement
+ * carries no exception itself, and the exception repeats most of its content words. Each absolute statement once, with
+ * the first such exception.
+ */
+export const contradictedAbsolutes = (statements: readonly Statement[]): Contradicted[] => {
+  const byWord = exceptionsByWord(statements);
+  return statements
+    .filter(isAbsolute)
+    .toSorted((left, right) => left.offset - right.offset)
+    .flatMap((absolute) => {
+      const found = (byWord.get(absolute.act ?? "") ?? [])
+        .filter((exception) => exception.offset > absolute.offset && exception.unit !== absolute.unit)
+        .map((exception) => ({ exception, shared: sharedWords(absolute, exception) }))
+        .find(({ exception, shared }) => isSameAct(absolute, exception, shared));
+      return found === undefined ? [] : [{ absolute, exception: found.exception, shared: found.shared }];
+    });
+};
+
+/** The exceptions in document order, by each of their words: an absolute rule looks only at those naming its act. */
+const exceptionsByWord = (statements: readonly Statement[]): ReadonlyMap<string, readonly Statement[]> => {
+  const byWord = new Map<string, Statement[]>();
+  statements
+    .filter((statement) => statement.exception !== undefined)
+    .toSorted((left, right) => left.offset - right.offset)
+    .forEach((exception) =>
+      new Set(exception.words).forEach((word) => {
+        const listed = byWord.get(word);
+        if (listed === undefined) byWord.set(word, [exception]);
+        else listed.push(exception);
+      }),
+    );
+  return byWord;
+};

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/issues.ts

@@ -84,6 +84,28 @@ export const danglingReferences = (tree: StructureNode, source: string): Structu
     .map((node) => ({ offset: node.span.start, values: { label: textOf(node, "label"), target: textOf(node, "target") } }));
 };
 
+/**
+ * 参照が指す節点。danglingReferences と同じ引き方（番地、章の短い番地、fallback）で、番号の付いたまとまりを引く。
+ * 同じ鍵の節点が二つ以上ある（番号の振り直しや別表の条）ときは、どれを指すのか決まらないので undefined。
+ */
+export const referenceResolver = (tree: StructureNode): ((reference: StructureNode) => StructureNode | undefined) => {
+  const byKey = new Map<string, StructureNode | null>();
+  inDocumentOrder(tree)
+    .filter((node) => NUMBERED.has(node.kind))
+    .forEach((node) => keysOf(node).forEach((key) => byKey.set(key, byKey.has(key) && byKey.get(key) !== node ? null : node)));
+  const resolve = (reference: StructureNode): StructureNode | undefined => {
+    const target = byKey.get(textOf(reference, "target"));
+    if (target !== undefined) return target ?? undefined;
+    return reference.attrs["fallback"] === undefined ? undefined : (byKey.get(fallbackKey(reference)) ?? undefined);
+  };
+  // Article 6 は Section 6 ではない。番号の書き方が両方にあって違えば、別の文書の条かもしれないので引かない。
+  return (reference) => {
+    const target = resolve(reference);
+    const written = numbering(reference);
+    return target === undefined || typeof written !== "string" || target.numbering === undefined || target.numbering === written ? target : undefined;
+  };
+};
+
 type Definition = { readonly node: StructureNode; readonly article: string };
 
 /** 定義を文書の順に、それが置かれた条の番地と一緒に並べる。範囲を限った定義は、その条の中でだけ比べるため。 */

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 };
+
+export 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);