chaffjs 0.17.0 → 0.19.0

package/src/structure/build.ts

@@ -6,11 +6,11 @@ import { resolveRelative } from "./relative-resolve.ts";
 import { maskSpans } from "../mask.ts";
 import type { DocumentProfile, Mention, NumberedLine, NumberingContext, Span, StructureKind, StructureNode, StructurePatterns } from "../plugin.ts";
 import { lineNumberAt, linesOf, type Line } from "./lines.ts";
-import { dottedNumber } from "./universal.ts";
-import { numberInSentence } from "./number-in-sentence.ts";
+import { universalNumber } from "./universal.ts";
 import { unnumberedUnit, type OpenUnit } from "./unnumbered.ts";
 import { readsOnHeading } from "./heading-leaves.ts";
 import { onLine, wrappedLine, type WrappedLine } from "./wrapped-tail.ts";
+import { foldPostOrder } from "../tree-walk.ts";
 
 /** 組み立て中の節点。できあがったら StructureNode に固める。 */
 type Draft = {
@@ -151,14 +151,6 @@ const LEAVES: readonly { readonly kind: StructureKind; readonly find: LeafFinder
   { kind: "date", find: (patterns, text) => patterns.dates?.(text) ?? [] },
 ];
 
-/** 言語を問わない通し番号。後ろが単位なら数量、本文の文の続きなら文の中の数なので、番号にしない。 */
-const universalNumber = (patterns: StructurePatterns, text: string, context: NumberingContext, plainText: boolean): NumberedLine | undefined => {
-  const dotted = dottedNumber(text, context, plainText);
-  if (dotted === undefined || patterns.countedAfter?.(dotted.number, dotted.rest) === true) return undefined;
-  const numbered = { number: dotted.number, rest: dotted.rest, isHeading: context.isHeading };
-  return numberInSentence(numbered, patterns.continuesSentence) ? undefined : dotted;
-};
-
 /** 行の中の定義・参照・義務・数量を、いま開いている最も内側の節点の子にする。 */
 const enclosingArticle = (state: State): Draft | undefined => state.stack.findLast((frame) => frame.draft.kind === "article")?.draft;
 
@@ -220,23 +212,28 @@ const extend = (state: State, end: number): void => {
   });
 };
 
-const freeze = (draft: Draft): StructureNode => ({
+const frozen = (draft: Draft, children: readonly StructureNode[]): StructureNode => ({
   kind: draft.kind,
   address: draft.address,
   span: { start: draft.start, end: draft.end },
   line: draft.line,
   attrs: draft.attrs,
-  children: draft.children.map(freeze),
+  children,
   ...(draft.ordinal === undefined ? {} : { ordinal: draft.ordinal }),
   ...(draft.level === undefined ? {} : { level: draft.level }),
   ...(draft.ordinalTo === undefined ? {} : { ordinalTo: draft.ordinalTo }),
   ...(draft.numbering === undefined ? {} : { numbering: draft.numbering }),
 });
 
-/** Markdown から取った手がかり。見出しと、中を読まない範囲（コード）。.txt はどちらも空。 */
-export type Outline = { readonly headings: readonly Heading[]; readonly opaque: readonly Span[] };
+const freeze = (root: Draft): StructureNode => foldPostOrder(root, (draft) => draft.children, frozen);
+
+/**
+ * Markdown から取った手がかり。見出しと、中を読まない範囲（コード）と、表。.txt はどれも空。
+ * 表の欄の数（版の番号 3.1.0）は値で、この文書の番号ではない。表の行は番号として読まず、数量や日付は読む。
+ */
+export type Outline = { readonly headings: readonly Heading[]; readonly opaque: readonly Span[]; readonly tables: readonly Span[] };
 
-export const NO_OUTLINE: Outline = { headings: [], opaque: [] };
+export const NO_OUTLINE: Outline = { headings: [], opaque: [], tables: [] };
 
 export type StructureInput = {
   readonly path: string;
@@ -298,11 +295,14 @@ const withCaption = (state: State, line: Line, numbered: NumberedLine | undefine
   return numbered === undefined || caption === undefined ? numbered : { ...numbered, heading: caption };
 };
 
-const readLine = (state: State, patterns: StructurePatterns, line: Line, heading: Heading | undefined, next: string | undefined): void => {
+/** 行の周り。前の行は、前の行が見出しでなく自分が表の行でないときだけ渡す。表の行は番号として読まない。 */
+type Around = { readonly next: string | undefined; readonly previous: string | undefined; readonly inTable: boolean };
+
+const readLine = (state: State, patterns: StructurePatterns, line: Line, heading: Heading | undefined, around: Around): void => {
   const text = heading === undefined ? line.text : headingLineText(line.text);
   const openNumbers = state.stack.flatMap((frame) => (frame.numbered === undefined ? [] : [frame.numbered]));
   const context = { open: openNumbers, isHeading: heading !== undefined };
-  const found = numberedLine(state, patterns, text, context);
+  const found = around.inTable ? undefined : numberedLine(state, patterns, text, context);
   const numbered = withCaption(state, line, found);
   const caption = numbered === undefined && heading === undefined ? captionOf(state.profile, text) : undefined;
   if (caption !== undefined) state.captions.set(line.number, caption);
@@ -315,7 +315,21 @@ const readLine = (state: State, patterns: StructurePatterns, line: Line, heading
   const scanned = numbered === undefined ? text : numbered.rest;
   const offset = Math.max(0, line.text.lastIndexOf(scanned));
   const onHeading = heading !== undefined;
-  if (scanned !== "") addLeaves(state, patterns, line, wrappedLine(scanned, onHeading, next), offset, onHeading);
+  // 番号付きの行は新しいまとまりの始まりなので、前の行の続きとして読まない。
+  const previous = numbered === undefined ? around.previous : undefined;
+  if (scanned !== "") addLeaves(state, patterns, line, wrappedLine(scanned, onHeading, around.next, previous), offset, onHeading);
+};
+
+/** 表の範囲に入る行の番号。表ごとに始まりと終わりの行を引くので、表の数に比例する。 */
+const tableLineNumbers = (lines: readonly Line[], tables: readonly Span[]): Set<number> => {
+  const numbers = new Set<number>();
+  tables.forEach((table) => {
+    const first = lineNumberAt(lines, table.start);
+    const last = lineNumberAt(lines, table.end);
+    if (first === undefined || last === undefined) return;
+    Array.from({ length: last - first + 1 }, (_, index) => numbers.add(first + index));
+  });
+  return numbers;
 };
 
 /**
@@ -340,8 +354,13 @@ export const buildTree = (input: StructureInput, patterns: StructurePatterns): S
     captions: new Map(),
     plainText: !input.markdown,
   };
+  const inTable = tableLineNumbers(lines, outline.tables);
   lines.forEach((line, index) => {
-    if (line.text.trim() !== "") readLine(state, patterns, line, headings.get(line.number), lines[index + 1]?.text);
+    // 見出しの後ろと表の行は、段落の折り返しではない。表のすぐ後ろの行は（GFM では）表の行になるので、表の中だけ見ればよい。
+    const apart = headings.has(line.number - 1) || inTable.has(line.number);
+    const previous = apart ? undefined : lines[index - 1]?.text;
+    const around = { next: lines[index + 1]?.text, previous, inTable: inTable.has(line.number) };
+    if (line.text.trim() !== "") readLine(state, patterns, line, headings.get(line.number), around);
     // コードの行は覆って読まないが、開いている節の中身ではある。節の最後にコードブロックがあっても、範囲をそこまで伸ばす。
     else if (input.source.slice(line.start, line.start + line.text.length).trim() !== "") extend(state, line.start + line.text.length);
   });

package/src/structure/closed-pairs.ts

@@ -0,0 +1,20 @@
+/**
+ * 閉じた括弧の組を、中身ごと外す。入れ子は内側から外れる。閉じない開きと、開かない閉じは残す。
+ * open と close は 1 字ずつ。同じ字なら、前から順に組になる。「内側の組を外す」を繰り返すと、深さの数だけ本文を読み直すので、1 度だけ読む。
+ */
+export const withoutClosedPairs = (text: string, open: string, close: string): string => {
+  const kept: string[] = [];
+  const opens: number[] = [];
+  for (const char of text) {
+    const opened = char === close ? opens.pop() : undefined;
+    if (opened !== undefined) kept.splice(opened);
+    else {
+      if (char === open) opens.push(kept.length);
+      kept.push(char);
+    }
+  }
+  return kept.join("");
+};
+
+/** 1 字（サロゲートの対も 1 字）か。 */
+export const isOneCharacter = (text: string): boolean => [...text].length === 1;

package/src/structure/date-range.ts

@@ -0,0 +1,117 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * 期間の終わりが始まりより前。二つの日付の間が範囲の記号（〜、–、through）だけか、開きの語（から）で終わりの日付に閉じの語（まで）が続くときを期間と読む。
+ * 比べるのは、両方が年月日か、両方が年月のときだけ。年の無い期間（12月28日〜1月4日）は年をまたぐかもしれない。
+ * 言語の知識（範囲の記号と語）は語彙表から受け取る。
+ */
+export type DatedSpan = { readonly offset: number; readonly end: number; readonly value: string };
+
+export type RangeWords = {
+  /** それだけで期間を作る記号と語。 */
+  readonly connectors: readonly string[];
+  /** 終わりの日付に閉じの語が続くときだけ期間を作る語（から）。 */
+  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];
+
+const comparable = (start: string, end: string): boolean => COMPARABLE.some((pattern) => pattern.test(start) && pattern.test(end));
+
+/** 日付に添えた曜日（（水））と時刻（10:00）は、期間のつなぎ目ではないので読み飛ばす。 */
+const ASIDES = /[（(][^（()）\n]{1,6}[）)]|\d{1,2}[:：]\d{2}/gu;
+
+const bare = (text: string): string => text.replace(ASIDES, "").trim().toLowerCase();
+
+const isOneOf = (text: string, words: readonly string[]): boolean => words.some((word) => word.toLowerCase() === text);
+
+/** 行の終わりまでの、終わりの日付の後ろ。曜日と時刻を除いてから閉じの語を探す。 */
+const closedAfter = (source: string, end: DatedSpan, closers: readonly string[]): boolean => {
+  const lineEnd = source.indexOf("\n", end.end);
+  const after = source
+    .slice(end.end, lineEnd === -1 ? source.length : lineEnd)
+    .replace(ASIDES, "")
+    .trimStart();
+  return closers.some((closer) => after.startsWith(closer));
+};
+
+/**
+ * 二つの日付の間のつなぎ。行をまたぐなら、つなぎは前の行の終わりにあり、次の行は終わりの日付から始まるときだけ（期間は2026年4月1日〜↵2026年3月31日）。
+ * 次の行の頭の「- 」は箇条書きの印で、範囲の記号ではない（日付を並べた一覧）。
+ */
+const jointOf = (source: string, start: DatedSpan, end: DatedSpan): string | undefined => {
+  const [first = "", ...next] = source.slice(start.end, end.offset).split("\n");
+  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)) || framed(source, start, end, joint, words)
+  );
+};
+
+/** 書いたままの期間。行をまたいだ期間は一行にする。 */
+const writtenPeriod = (source: string, start: DatedSpan, end: DatedSpan): string =>
+  source
+    .slice(start.offset, end.end)
+    .split("\n")
+    .map((part) => part.trim())
+    .join(" ");
+
+/** 隣り合う二つの日付のうち、期間をなし、終わりが始まりより前のもの。期間の書き出しを指し、書いたままの期間を見せる。 */
+export const reversedRanges = (source: string, dates: readonly DatedSpan[], words: RangeWords): StructureIssue[] =>
+  dates.slice(1).flatMap((end, index) => {
+    const start = dates[index];
+    if (start === undefined || !comparable(start.value, end.value) || end.value >= start.value) return [];
+    if (!isRange(source, start, end, words)) return [];
+    return [{ offset: start.offset, values: { start: start.value, end: end.value, period: writtenPeriod(source, start, end) } }];
+  });

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/known-mentions.ts

@@ -0,0 +1,96 @@
+import type { Mention } from "../plugin.ts";
+
+/**
+ * 条を書かない番地を読むときに引く、同じ行の既知の参照。before（名指しの参照）に、見つけた番地を順に足していく。
+ * 引くたびに全部をなめると、参照の数の二乗になる。before は並べ替えて二分探索で、足したものは深さごとに最後の一つで引く。
+ *
+ * 足すものは、正規表現で左から見つけた番地の順に来る。だから足したものの終わりは、次に引く位置より前にあり、並びの順に増える。
+ * - overlaps: [start, end) と重なるものがあるか。足したものは引く位置より前で終わるので、重ならない。
+ * - previous: 終わりが at 以前で、終わりの深さが depth のもののうち、終わりが最も後ろのもの。同じ終わりなら後から知ったもの。
+ * - endingAt: 終わりが at のもののうち、最初に知ったもの。
+ */
+export type KnownMentions = {
+  readonly overlaps: (start: number, end: number) => boolean;
+  readonly previous: (at: number, depth: number) => Mention | undefined;
+  readonly endingAt: (at: number) => Mention | undefined;
+  readonly add: (mention: Mention, depth: number) => void;
+};
+
+/** sorted の中で、pass が偽になる最初の位置。pass は先頭から真が続き、あとは偽。 */
+const firstFailing = <T>(sorted: readonly T[], pass: (item: T) => boolean): number => {
+  let [low, high] = [0, sorted.length];
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    const item = sorted[middle];
+    if (item !== undefined && pass(item)) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+};
+
+/** 始まりの順に並べ、そこまでの終わりの最大を添える。始まりが end より前のものの、終わりの最大が start より後ろなら重なる。 */
+const overlapIndex = (before: readonly Mention[]): ((start: number, end: number) => boolean) => {
+  const byStart = before.filter((mention) => !Number.isNaN(mention.start)).toSorted((left, right) => left.start - right.start);
+  let reach = -Infinity;
+  const reaches = byStart.map((mention) => {
+    reach = Math.max(reach, Number.isNaN(mention.end) ? -Infinity : mention.end);
+    return reach;
+  });
+  return (start, end) => {
+    const count = firstFailing(byStart, (mention) => mention.start < end);
+    return count > 0 && (reaches[count - 1] ?? -Infinity) > start;
+  };
+};
+
+type Ranked = { readonly mention: Mention; readonly order: number };
+
+const byEndThenOrder = (left: Ranked, right: Ranked): number => {
+  if (left.mention.end !== right.mention.end) return left.mention.end < right.mention.end ? -1 : 1;
+  return left.order - right.order;
+};
+
+/** 深さごとに、終わりの順（同じなら知った順）に並べる。 */
+const previousIndex = (before: readonly Mention[], depthOf: (at: number) => number): ((at: number, depth: number) => Mention | undefined) => {
+  const byDepth = new Map<number, Ranked[]>();
+  before.forEach((mention, order) => {
+    if (Number.isNaN(mention.end)) return;
+    const depth = depthOf(mention.end);
+    const ranked = byDepth.get(depth) ?? [];
+    ranked.push({ mention, order });
+    byDepth.set(depth, ranked);
+  });
+  const sorted = new Map([...byDepth].map(([depth, ranked]) => [depth, ranked.toSorted(byEndThenOrder)]));
+  return (at, depth) => {
+    const ranked = sorted.get(depth) ?? [];
+    return ranked[firstFailing(ranked, (entry) => entry.mention.end <= at) - 1]?.mention;
+  };
+};
+
+const firstByEnd = (mentions: readonly Mention[]): Map<number, Mention> => {
+  const found = new Map<number, Mention>();
+  mentions.forEach((mention) => {
+    if (!found.has(mention.end)) found.set(mention.end, mention);
+  });
+  return found;
+};
+
+export const knownMentions = (before: readonly Mention[], depthOf: (at: number) => number): KnownMentions => {
+  const overlapsBefore = overlapIndex(before);
+  const previousBefore = previousIndex(before, depthOf);
+  const endsBefore = firstByEnd(before);
+  const lastAddedByDepth = new Map<number, Mention>();
+  const endsAdded = new Map<number, Mention>();
+  return {
+    overlaps: overlapsBefore,
+    previous: (at, depth) => {
+      const known = previousBefore(at, depth);
+      const added = lastAddedByDepth.get(depth);
+      return added !== undefined && (known === undefined || added.end >= known.end) ? added : known;
+    },
+    endingAt: (at) => endsBefore.get(at) ?? endsAdded.get(at),
+    add: (mention, depth) => {
+      lastAddedByDepth.set(depth, mention);
+      if (!endsAdded.has(mention.end)) endsAdded.set(mention.end, mention);
+    },
+  };
+};

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

@@ -1,5 +1,6 @@
 import type { StructureNode } from "../plugin.ts";
 import { inDocumentOrder, type StructureIssue } from "./issues.ts";
+import { numbersQuotedInside } from "./quoted-number.ts";
 
 const labelOf = (node: StructureNode): string => String(node.attrs["label"] ?? node.address);
 
@@ -9,10 +10,10 @@ type Ordered = { readonly node: StructureNode; readonly ordinal: number; readonl
  * 同じ親の子のうち、番号の付いたものを種類と深さごとに分ける。条と項は別の並び、項と号も別の並び。
  * 法令の第 1 項は番号が無いので、その号（一、二）と第 2 項（２）は同じ条の直下に並ぶ。深さで分けないと「二の次が２」に見える。
  */
-const sequencesOf = (parent: StructureNode): Ordered[][] => {
+const sequencesOf = (parent: StructureNode, quoting: ReadonlySet<StructureNode>): Ordered[][] => {
   const groups = new Map<string, Ordered[]>();
   parent.children.forEach((node) => {
-    if (node.ordinal === undefined) return;
+    if (node.ordinal === undefined || quoting.has(node)) return;
     const key = `${node.kind}/${String(node.level ?? "")}`;
     // 配列を作り直さずに足す。条が何千もある法令で二乗にしない。
     const group = groups.get(key) ?? [];
@@ -41,9 +42,12 @@ const breaksIn = (sequence: readonly Ordered[]): StructureIssue[] =>
  * 番号の抜けと重なり。比べるのは同じ親の子どうしだけ。英米の法令は章ごとに Section 101、201 と百の位を変えるので、
  * 文書全体の通し番号として比べると抜けに見える。最初の番号は見ない。日本語の項は 2 から番号を振る。
  * 1 に戻った番号は新しい並びの始まりとして扱うので、「(a) の後の (a)」の重なりは見逃す。
+ * 同じ番号の節を中に持つ節（ほかの文書の条を引いた手本の見出し）は、並びに入れない。
  */
-export const numberingBreaks = (tree: StructureNode): StructureIssue[] =>
-  inDocumentOrder(tree)
-    .flatMap(sequencesOf)
+export const numberingBreaks = (tree: StructureNode): StructureIssue[] => {
+  const quoting = numbersQuotedInside(tree);
+  return inDocumentOrder(tree)
+    .flatMap((parent) => sequencesOf(parent, quoting))
     .flatMap(breaksIn)
     .toSorted((left, right) => left.offset - right.offset);
+};