chaffjs 0.35.0 → 0.37.0

package/src/structure/build.ts

@@ -9,6 +9,7 @@ import { lineNumberAt, linesOf, type Line } from "./lines.ts";
 import { universalNumber } from "./universal.ts";
 import { unnumberedUnit, type OpenUnit } from "./unnumbered.ts";
 import { readsOnHeading } from "./heading-leaves.ts";
+import { unspacedHeadings } from "./unspaced-heading.ts";
 import { onLine, wrappedLine, type WrappedLine } from "./wrapped-tail.ts";
 import { foldPostOrder } from "../tree-walk.ts";
 
@@ -260,10 +261,11 @@ const headingsByLine = (lines: readonly Line[], headings: readonly Heading[]): M
  * 見出しの行から見出しの言葉を取る。コードを覆った後の行から取るので、見出しの中のコードも読まない。
  * ATX（行頭が #）なら印と閉じの # を外す。setext（下線で書く見出し）の末尾の # は言葉なので残す。
  */
-const headingLineText = (text: string): string => {
+const headingLineText = (text: string, atx: boolean): string => {
   const line = text.trim();
   if (!line.startsWith("#")) return headingText(line);
-  return atxHeadingText(line.replace(/^#{1,6}(?=[ \t]|$)/u, "").trim());
+  // A heading that ends on its own line is ATX, and its hashes go even with no space after them (unspaced-heading.ts).
+  return atxHeadingText(line.replace(atx ? /^#{1,6}/u : /^#{1,6}(?=[ \t]|$)/u, "").trim());
 };
 
 const captionPatterns = new WeakMap<DocumentProfile, RegExp | undefined>();
@@ -319,7 +321,7 @@ const withCaption = (state: State, line: Line, numbered: NumberedLine | undefine
 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 text = heading === undefined ? line.text : headingLineText(line.text, heading.end <= line.start + line.text.length);
   const openNumbers = state.stack.flatMap((frame) => (frame.numbered === undefined ? [] : [frame.numbered]));
   const context = { open: openNumbers, isHeading: heading !== undefined };
   const found = around.inTable ? undefined : (numberedLine(state, patterns, text, context) ?? codeTitledNumber(state, patterns, text, heading, context));
@@ -361,7 +363,8 @@ export const buildTree = (input: StructureInput, patterns: StructurePatterns): S
   // コードは同じ長さの空白で覆ってから読む。コードブロックの行は空になって飛ばされ、
   // 文中の `第99条` は参照として拾われない。位置は元の文書のまま。
   const lines = linesOf(maskSpans(input.source, outline.opaque));
-  const headings = headingsByLine(lines, outline.headings);
+  const marked = headingsByLine(lines, outline.headings);
+  const headings = input.markdown ? new Map([...marked, ...unspacedHeadings(lines, marked, patterns)]) : marked;
   const attrs = { path: input.path, language: input.language, ...(input.profile === undefined ? {} : { profile: input.profile.id }) };
   const doc = draftOf("doc", "", { text: "", start: 0, number: 1 }, attrs);
   doc.end = input.source.length;

package/src/structure/contents-lines.ts

@@ -0,0 +1,63 @@
+import type { MarkupHeading } from "../plugin.ts";
+import { lineNumberAt, type Line } from "./lines.ts";
+
+// 目次・索引の行と、番号に題だけを続けた行。どれも本文の文ではなく、文書の案内。純関数: 行と Markdown の見出しを受け取る。
+
+/** 項目の終わり（ページ番号、条の番地 2.04(c)）の後ろに、次の項目の大文字が続く所。 */
+const ENTRY_BREAK = /(?<![\p{L}\p{N}$.,])\d+(?:\.\d+)*(?:\([\p{L}\p{N}]{1,4}\))*\s+(?=\p{Lu})/gu;
+/** 一行に詰めた目次・索引と読むのに要る、項目の切れ目の数（Closing 2 Section 1.2 The Merger 2 ARTICLE II）。 */
+const MIN_ENTRY_BREAKS = 3;
+/** 目次・索引の行の言葉は、ほとんどが大文字で始まる。短くない語のうち小文字で始まる語がこの割合以上なら文。 */
+const MAX_LOWERCASE_SHARE = 1 / 3;
+/** これより短い語（of、and、the、番地の (c)、iii）は、題の中でも小文字で書く。 */
+const MIN_CAPITALISED_LENGTH = 4;
+const WORD = /\p{L}[\p{L}'’-]*/gu;
+const LOWERCASE_START = /^\p{Ll}/u;
+
+/** 短くない語のうち、小文字で始まる語の割合。 */
+const lowercaseShare = (text: string): number => {
+  const words = (text.match(WORD) ?? []).filter((word) => word.length >= MIN_CAPITALISED_LENGTH);
+  return words.length === 0 ? 1 : words.filter((word) => LOWERCASE_START.test(word)).length / words.length;
+};
+
+/** 項目と番号を一行に詰めた目次・索引（Section 1.1 Closing 2 Section 1.2 The Merger 2、Company RSU 2.04(b) Company SEC Documents 4.07(a)）。 */
+const isPackedContents = (text: string): boolean => [...text.matchAll(ENTRY_BREAK)].length >= MIN_ENTRY_BREAKS && lowercaseShare(text) < MAX_LOWERCASE_SHARE;
+
+/** 番号に題を続けただけの行（1 Supply of Ingredients）。題の語は大文字で始まり、文の終わりの印を持たない。 */
+const NUMBERED_TITLE = /^\s*\d+(?:\.\d+)*\.?\s+\p{Lu}[^.。:;,!?]*$/u;
+/** 題と読む語の数の上限。 */
+const MAX_TITLE_WORDS = 8;
+
+const NOT_LATIN_LETTER = /[^\P{L}\p{Script=Latin}]/u;
+
+/** 英語の題の言葉か: 語が多すぎず、短くない語がどれも大文字で始まる（Supply of Ingredients、Extension; Waiver）。 */
+export const isTitleWords = (text: string): boolean => {
+  const words = text.match(WORD) ?? [];
+  return (
+    words.length > 0 &&
+    !NOT_LATIN_LETTER.test(text) &&
+    words.length <= MAX_TITLE_WORDS &&
+    words.every((word) => word.length < MIN_CAPITALISED_LENGTH || !LOWERCASE_START.test(word))
+  );
+};
+
+const isNumberedTitle = (text: string): boolean => NUMBERED_TITLE.test(text) && isTitleWords(text);
+
+/** 目次の見出し（語彙表 toc-heading）の下、次の見出しまでの行の番号。 */
+const linesUnderContentsHeading = (lines: readonly Line[], headings: readonly MarkupHeading[], tocWords: readonly string[]): number[] => {
+  const names = new Set(tocWords.map((word) => word.toLowerCase()));
+  return headings.flatMap((heading, index) => {
+    if (!names.has(heading.text.trim().toLowerCase())) return [];
+    const from = lineNumberAt(lines, heading.start) ?? 0;
+    const next = headings[index + 1];
+    const to = next === undefined ? lines.length + 1 : (lineNumberAt(lines, next.start) ?? lines.length + 1);
+    return lines.filter((line) => line.number > from && line.number < to).map((line) => line.number);
+  });
+};
+
+/** 目次・索引の行と、番号に題だけを続けた行の番号（1 始まり）。 */
+export const contentsLineNumbers = (lines: readonly Line[], headings: readonly MarkupHeading[], tocWords: readonly string[]): ReadonlySet<number> =>
+  new Set([
+    ...linesUnderContentsHeading(lines, headings, tocWords),
+    ...lines.filter((line) => isPackedContents(line.text) || isNumberedTitle(line.text)).map((line) => line.number),
+  ]);

package/src/structure/defining-names.ts

@@ -0,0 +1,155 @@
+import { escapeRegExp } from "../orthography.ts";
+
+// 定義の括弧の前に書いた名前と、それを定義より前で写した所。純関数: 文（本文の一続き）と、その中の位置だけを見る。
+
+/** 一つの文。start は文書の中の位置。 */
+type Sentence = { readonly start: number; readonly text: string };
+
+const OPENING_BRACKET = /[\s（(]/u;
+
+/** 定義の括弧を開けた字（（、空白）を後ろから外した、括弧の前の名前。 */
+export const nameBefore = (text: string): string => {
+  let end = text.length;
+  while (end > 0 && OPENING_BRACKET.test(text.charAt(end - 1))) end -= 1;
+  return text.slice(0, end);
+};
+
+/** 二つの文字列が後ろから何字重なるか。 */
+export const sharedTail = (left: string, right: string): number => {
+  let shared = 0;
+  while (shared < left.length && shared < right.length && left.at(-1 - shared) === right.at(-1 - shared)) shared += 1;
+  return shared;
+};
+
+/** 漢字・仮名の名前の頭を決める字。名前はこの字の後ろから括弧の前まで（、株式会社ジェイアール東日本企画（以下「会社」））。 */
+const NAME_BOUNDARY = /[\s、。，．,.;；:：（）()「」『』【】［］[\]]/u;
+const LATIN_NAME_END = /[\p{Script=Latin}\p{N}.]$/u;
+const CAPITALISED = /^[\p{Lu}\p{N}&]/u;
+/** 大文字の語のあいだにだけ入る、短い小文字の語（Board of Directors の of）。 */
+const CONNECTOR = /^\p{Ll}{1,3}$/u;
+const TOKEN = /\S+/gu;
+
+/** 英語の名前: 括弧の前から遡った、大文字で始まる語の並び（Youth Sports Management, LLC、Board of Directors）。 */
+const latinNameIn = (text: string): string => {
+  const tokens = [...text.matchAll(TOKEN)];
+  const kept = (index: number): boolean => {
+    const word = tokens[index]?.[0] ?? "";
+    const previous = tokens[index - 1]?.[0] ?? "";
+    return CAPITALISED.test(word) || (CONNECTOR.test(word) && CAPITALISED.test(previous) && !previous.endsWith(","));
+  };
+  const stop = tokens.findLastIndex((_, index) => !kept(index));
+  const first = tokens[stop + 1];
+  return first === undefined ? "" : text.slice(first.index);
+};
+
+/** 括弧の前の長い名前。英字で終われば大文字の語の並び、そうでなければ句読点・括弧の後ろから。 */
+export const longNameIn = (text: string): string => {
+  if (LATIN_NAME_END.test(text)) return latinNameIn(text);
+  const chars = [...text];
+  return chars.slice(chars.findLastIndex((char) => NAME_BOUNDARY.test(char)) + 1).join("");
+};
+
+/** 定義の括弧の前の名前（name）、その前の文（before）、括弧の中の語より前（head: (this “Agreement”) の (this 。引用符は空白にする）。 */
+export type DefiningName = { readonly name: string; readonly before: string; readonly head: string };
+
+const LETTER_OR_SPACE = /[\p{L}\p{N}\s]/u;
+
+/** 終わりの引用符と強調の印（“、「、***）を空白にしたもの。 */
+const withoutOpeningQuote = (text: string): string => {
+  const chars = [...text];
+  return `${chars.slice(0, chars.findLastIndex((char) => LETTER_OR_SPACE.test(char)) + 1).join("")} `;
+};
+const ROUND_OPEN = new Set(["（", "("]);
+const ROUND_CLOSE = new Set(["）", ")"]);
+
+/** text の終わりで開いたままの丸括弧の位置（…法律（令和6年法律第69号。以下「…」の（）。無ければ undefined。 */
+const openBracketAt = (text: string): number | undefined => {
+  const open: number[] = [];
+  text.split("").forEach((char, index) => {
+    if (ROUND_OPEN.has(char)) open.push(index);
+    else if (ROUND_CLOSE.has(char)) open.pop();
+  });
+  return open.at(-1);
+};
+
+/** 文の中の定義の範囲 [spanStart, spanEnd) から、定義の前の名前を取る。定義が括弧の中の注記の後ろにあれば、その括弧の前の名前。位置は文書の中の位置。 */
+export const definingNameOf = (sentence: Sentence, spanStart: number, spanEnd: number, term: string): DefiningName => {
+  const beforeSpan = sentence.text.slice(0, spanStart - sentence.start);
+  const prefix = nameBefore(beforeSpan.slice(0, openBracketAt(beforeSpan) ?? beforeSpan.length));
+  const name = longNameIn(prefix);
+  const span = sentence.text.slice(spanStart - sentence.start, spanEnd - sentence.start);
+  const termAt = span.indexOf(term);
+  return { name, before: prefix.slice(0, prefix.length - name.length), head: termAt === -1 ? "" : withoutOpeningQuote(span.slice(0, termAt)) };
+};
+
+/** 長い名前の写しと読むのに、語のほかに名前と重ならなければならない字の数（手引き の前の「の」と「成」）。 */
+export const MIN_ECHO = 2;
+const LATIN_WORD_CHAR = /[\p{Script=Latin}\p{N}]/u;
+
+/** 名前の from の位置が英語の語の途中なら、次の語の頭へ進める。limit を越えれば undefined。 */
+const wordStartFrom = (name: string, from: number, limit: number): number | undefined => {
+  if (from === 0 || !LATIN_WORD_CHAR.test(name.charAt(from - 1)) || !LATIN_WORD_CHAR.test(name.charAt(from))) return from;
+  const space = name.slice(from).search(/\s/u);
+  return space === -1 || from + space + 1 > limit ? undefined : from + space + 1;
+};
+
+const indexesOf = (text: string, part: string): number[] => [...text.matchAll(new RegExp(escapeRegExp(part), "gu"))].map((match) => match.index);
+
+/**
+ * 文の at にある語が、定義の名前 name（語を含む、語より長い名前）の写しの中にあるか（Board of Directors (the "Board") より前の
+ * Board of Directors、株式会社エムケイシステム（以下「会社」）より前の株式会社エムケイシステム）。写しは名前の終わりまで同じで、
+ * 頭は名前の語の切れ目から。
+ */
+export const echoesName = (sentence: Sentence, at: number, term: string, name: string): boolean =>
+  name !== term &&
+  indexesOf(name, term).some((index) => {
+    if (!sentence.text.startsWith(name.slice(index + term.length), at + term.length)) return false;
+    const shared = Math.min(index, sharedTail(name.slice(0, index), sentence.text.slice(0, at)));
+    const start = wordStartFrom(name, index - shared, index);
+    return start !== undefined && name.length - start - term.length >= MIN_ECHO;
+  });
+
+const LATIN_LETTER = /\p{Script=Latin}/u;
+
+const SCRIPTS = [/\p{Script=Han}/u, /\p{Script=Hiragana}/u, /\p{Script=Katakana}/u];
+
+/** 二つの字が同じ字の種類（漢字、平仮名、片仮名）か。基本規程の「本」は、前の「基」と一続きの語の一部。 */
+const sameScript = (left: string, right: string): boolean => SCRIPTS.some((script) => script.test(left) && script.test(right));
+
+/** 漢字・仮名の頭が、前の語に続かずに text の終わりにあるか（この規則、本規程。基本規程の本、そこの規則のこの は当たらない）。 */
+const endsWithWordPrefix = (text: string, prefix: string): boolean =>
+  text.endsWith(prefix) && !sameScript(text.charAt(text.length - prefix.length - 1), prefix.charAt(0));
+
+/** text の終わりが、文書自身を指す頭（この、本、this）か。英語の頭は語として（this の後ろに空白）、大文字小文字を問わない。 */
+const endsWithSelfPrefix = (text: string, prefixes: readonly string[]): boolean =>
+  prefixes.some((prefix) =>
+    LATIN_LETTER.test(prefix) ? new RegExp(String.raw`(?<![\p{L}\p{N}])${escapeRegExp(prefix)}\s+$`, "iu").test(text) : endsWithWordPrefix(text, prefix),
+  );
+
+/** 定義が文書自身の名前か（この就業規則（以下「規則」）、本規程（以下「規程」）、This Agreement … (this "Agreement")）。 */
+export const namesItself = (defining: DefiningName, prefixes: readonly string[]): boolean =>
+  endsWithSelfPrefix(defining.head, prefixes) ||
+  endsWithSelfPrefix(defining.before, prefixes) ||
+  prefixes.some((prefix) => !LATIN_LETTER.test(prefix) && defining.name.startsWith(prefix));
+
+/** 文の at の語の前が、文書自身を指す頭か（この規則、this Agreement）。 */
+export const followsSelfPrefix = (sentence: Sentence, at: number, prefixes: readonly string[]): boolean =>
+  endsWithSelfPrefix(sentence.text.slice(0, at), prefixes);
+
+/** 前の語を見るのに遡る字の数。 */
+const LOOK_BEHIND_CHARS = 80;
+/** 語の前が、文の頭ではない大文字の語か（Navistar Financial Corporation の Corporation）。The Company の The は文の頭なので当たらない。 */
+const AFTER_CAPITALISED_WORD = /\p{L}[ \u00a0]\p{Lu}[\p{L}\p{N}&'’-]*[ \u00a0]$/u;
+
+/** 英語の語が、前の大文字の語から続く長い名前の終わりにあるか。 */
+export const endsLatinName = (sentence: Sentence, at: number, term: string): boolean =>
+  LATIN_LETTER.test(term.charAt(0)) && AFTER_CAPITALISED_WORD.test(sentence.text.slice(Math.max(0, at - LOOK_BEHIND_CHARS), at));
+
+/** 語のすぐ後ろの括弧とその中身（こども性暴力防止法（…に関する法律）の（…に関する法律））。 */
+const GLOSS_AFTER = /^\s*[（(]([^）)]*)[）)]/u;
+
+/** 文の at の語が、すぐ後ろの括弧に定義の長い名前を書き添えているか。語の意味はその場で分かる。 */
+export const glossedWithName = (sentence: Sentence, at: number, term: string, name: string): boolean => {
+  const gloss = GLOSS_AFTER.exec(sentence.text.slice(at + term.length))?.[1];
+  return gloss !== undefined && name.length >= term.length + MIN_ECHO && gloss.trim().endsWith(name);
+};

package/src/structure/definition-use.ts

@@ -1,6 +1,20 @@
 import type { Span, StructureNode } from "../plugin.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { inDocumentOrder } from "./issues.ts";
+import { isTitleWords } from "./contents-lines.ts";
+import { verbFormsOf } from "./gerund-phrase.ts";
+import {
+  definingNameOf,
+  echoesName,
+  endsLatinName,
+  followsSelfPrefix,
+  glossedWithName,
+  MIN_ECHO,
+  nameBefore,
+  namesItself,
+  sharedTail,
+  type DefiningName,
+} from "./defining-names.ts";
 
 // 定義した語が本文で使われているか、定義より前に使われていないか。どちらも木の定義と、本文の文の字面だけで決まる。
 
@@ -96,13 +110,23 @@ const groupsOf = (terms: readonly DefinedTerm[]): TermGroup[] => {
   return [...groups.values()];
 };
 
-/** 定義したのに、定義の外で一度も使っていない語。同じ語の定義が二つあれば、最初の一つだけを言う（二つ目は duplicate-definition）。 */
-export const unusedDefinitions = (terms: readonly DefinedTerm[], texts: readonly BodyText[], mentioned: Mentioned = NEVER_MENTIONED): DefinedTerm[] => {
+/** 語か、動名詞で始まる句の動詞の形（Exercising your options の exercise your options）が、定義の外に一度でも現れるか。 */
+const isUsed = (group: TermGroup, texts: readonly BodyText[], determiners: ReadonlySet<string>): boolean =>
+  [group.first.term, ...verbFormsOf(group.first.term, determiners)].some((form) => usesOf(form, texts, group.spans).length > 0);
+
+/**
+ * 定義したのに、定義の外で一度も使っていない語。同じ語の定義が二つあれば、最初の一つだけを言う（二つ目は duplicate-definition）。
+ * determiners: 動名詞の後ろに来て、それが目的語を取る動詞だと分かる語（英語の a, the, your）。
+ */
+export const unusedDefinitions = (
+  terms: readonly DefinedTerm[],
+  texts: readonly BodyText[],
+  mentioned: Mentioned = NEVER_MENTIONED,
+  determiners: ReadonlySet<string> = new Set(),
+): DefinedTerm[] => {
   const groups = groupsOf(terms);
   const examples = quotesExamples(groups, texts, mentioned);
-  return groups
-    .filter((group) => !(examples && group.first.bare === true) && usesOf(group.first.term, texts, group.spans).length === 0)
-    .map((group) => group.first);
+  return groups.filter((group) => !(examples && group.first.bare === true) && !isUsed(group, texts, determiners)).map((group) => group.first);
 };
 
 /**
@@ -131,9 +155,42 @@ const LETTER = /\p{L}/gu;
 /** 札の文が語のほかに持ってよい字の数（"The Agreement." の The）。 */
 const LABEL_SLACK = 3;
 
-/** 語だけの札の文（**12.2.** Taxes.、1. The Agreement.）。条の頭に語を掲げただけで、使用ではない。 */
+/**
+ * 札の終わりに添えた条の番地の注（（第7条関係）、(Section 4)）。同じ形の括弧の一組で、入れ子が無く、中身は番号を含む 20 字まで。
+ * 長い括弧、番号の無い括弧（(if any)）、文の途中の括弧は、文の一部として読む。
+ */
+const SECTION_NOTE = /(?:（[^（）()]{0,20}）|\([^（）()]{0,20}\))[.。．]?\s*$/u;
+const NUMBER = /[\p{N}〇一二三四五六七八九十]/u;
+
+const withoutSectionNote = (text: string): string => {
+  const note = SECTION_NOTE.exec(text);
+  return note === null || !NUMBER.test(note[0]) ? text : text.slice(0, note.index);
+};
+
+/**
+ * 語だけの札の文（**12.2.** Taxes.、1. The Agreement.、（1）文化芸術推進基本計画（第7条関係））。条や節の頭に語を掲げただけで、
+ * 使用ではない。終わりに添えた条の番地の注は札の字に数えない。
+ */
 const isLabel = (body: BodyText | undefined, term: string): boolean =>
-  body !== undefined && (body.text.replaceAll(term, "").match(LETTER) ?? []).length <= LABEL_SLACK;
+  body !== undefined && (withoutSectionNote(body.text.trimEnd()).replaceAll(term, "").match(LETTER) ?? []).length <= LABEL_SLACK;
+
+/** 番地の後ろの、条の題の始まり（Section 1.1   Closing. の Closing）。 */
+const AFTER_ADDRESS = /\d\.?\s+(?=\p{Lu})/gu;
+/** 文の終わりまでが、文の終わりの印を一つしか持たない（題の終わりの点）。 */
+const CAPTION_TO_END = /^[^.!?。]*[.。]?$/u;
+
+/**
+ * 条の題の中か。番地の後ろに題を置いて文がその題で終わる所（Section 1.1 Closing.）か、文が題だけのもの（Section 6.06. の後ろの
+ * Financing Covenant.、Company Stockholder Meeting; Company Proxy Statement.）。
+ */
+const insideCaption = (body: BodyText | undefined, offset: number): boolean => {
+  if (body === undefined) return false;
+  const at = offset - body.start;
+  const starts = [...body.text.matchAll(AFTER_ADDRESS)].filter((start) => start.index + start[0].length <= at);
+  const last = starts.at(-1);
+  const caption = last === undefined ? body.text : body.text.slice(last.index + last[0].length);
+  return CAPTION_TO_END.test(caption.trimEnd()) && isTitleWords(caption);
+};
 
 /** 文書の位置が、題・見出し・条の見出しの行にあるか。見出しは節の中身に名前を付けるだけで、語を使った所ではない。 */
 export type IsTitle = (offset: number) => boolean;
@@ -169,24 +226,6 @@ const insideKatakanaName = (texts: readonly BodyText[], term: string, offset: nu
   return (KATAKANA.test(term.charAt(0)) && joinedBefore) || (KATAKANA.test(term.at(-1) ?? "") && joinedAfter);
 };
 
-/** 長い名前の写しと読むのに、語の前で定義の名前と重ならなければならない字の数（手引き の前の「の」と「成」）。 */
-const MIN_ECHO = 2;
-const OPENING_BRACKET = /[\s（(]/u;
-
-/** 定義の括弧を開けた字（（、空白）を後ろから外した、括弧の前の名前。 */
-const nameBefore = (text: string): string => {
-  let end = text.length;
-  while (end > 0 && OPENING_BRACKET.test(text.charAt(end - 1))) end -= 1;
-  return text.slice(0, end);
-};
-
-/** 二つの文字列が後ろから何字重なるか。 */
-const sharedTail = (left: string, right: string): number => {
-  let shared = 0;
-  while (shared < left.length && shared < right.length && left.at(-1 - shared) === right.at(-1 - shared)) shared += 1;
-  return shared;
-};
-
 /**
  * 定義の括弧の前に書いた長い名前（…ガイドライン作成の手引き（以下、「手引き」という。））を、定義より前でそのまま書いた所。
  * 名前が語で終わり、語の前の字も名前と同じなら、それは長い名前で、定義した短い名前の使用ではない。
@@ -229,10 +268,81 @@ const CAPITAL_OR_NON_LATIN = /\p{Lu}|[^\p{Script=Latin}\p{N}\s\p{P}]/u;
  */
 const isDistinctive = (term: string): boolean => CAPITAL_OR_NON_LATIN.test(term) && !SINGLE_KANJI.test(term);
 
+/** 文の途中の定義ごとの、括弧の前の名前。 */
+const definingNames = (terms: readonly DefinedTerm[], texts: readonly BodyText[]): Map<DefinedTerm, DefiningName> =>
+  new Map(
+    terms.flatMap((term): [DefinedTerm, DefiningName][] => {
+      const sentence = term.inline ? sentenceAt(texts, term.span.start) : undefined;
+      return sentence === undefined ? [] : [[term, definingNameOf(sentence, term.span.start, term.span.end, term.term)]];
+    }),
+  );
+
+/**
+ * 語を含む、もっと長い名前の中の現れか。別の語の定義の中（(the "Certificate of Merger") の Certificate）、もっと長い定義した語
+ * （NFLN Agreement の NFLN）、定義の括弧の前の名前の写し（Board of Directors）、大文字の語に続く英語の名前の終わり。
+ */
+type InsideLongerName = (term: string, offset: number) => boolean;
+
+/** 位置がどれかの範囲の中か。範囲を頭の順に並べ、二分探索で引く（定義が何千あっても、現れ一つに対数）。 */
+const insideAnyOf = (spans: readonly Span[]): ((offset: number) => boolean) => {
+  const sorted = spans.toSorted((left, right) => left.start - right.start);
+  const furthestEnd: number[] = [];
+  sorted.forEach((span, index) => furthestEnd.push(Math.max(furthestEnd[index - 1] ?? 0, span.end)));
+  return (offset) => {
+    let low = 0;
+    let high = sorted.length - 1;
+    while (low <= high) {
+      const middle = (low + high) >> 1;
+      if ((sorted[middle]?.start ?? 0) <= offset) low = middle + 1;
+      else high = middle - 1;
+    }
+    if (high < 0 || (furthestEnd[high] ?? 0) <= offset) return false;
+    return offset < (sorted[high]?.end ?? 0) || inside(offset, sorted.slice(0, high));
+  };
+};
+
+const insideLongerNameIn = (texts: readonly BodyText[], terms: readonly DefinedTerm[], names: ReadonlyMap<DefinedTerm, DefiningName>): InsideLongerName => {
+  const insideDefinition = insideAnyOf(terms.map((term) => term.span));
+  const longNames = [...new Set([...[...names.values()].map((defining) => defining.name), ...terms.map((term) => term.term)])];
+  const holding = new Map<string, readonly string[]>();
+  const namesHolding = (term: string): readonly string[] => {
+    const known = holding.get(term);
+    if (known !== undefined) return known;
+    const found = longNames.filter((name) => name !== term && name.includes(term));
+    holding.set(term, found);
+    return found;
+  };
+  return (term, offset) => {
+    if (insideDefinition(offset)) return true;
+    const sentence = sentenceAt(texts, offset);
+    if (sentence === undefined) return false;
+    const at = offset - sentence.start;
+    return endsLatinName(sentence, at, term) || namesHolding(term).some((name) => echoesName(sentence, at, term, name));
+  };
+};
+
+/**
+ * 前で書いても読み手が分かる所。文書自身の名前と定義した語（この就業規則（以下「規則」））を同じ頭を付けて書いた所（この規則は、…）と、
+ * すぐ後ろの括弧に定義の長い名前を書き添えた所（こども性暴力防止法（…に関する法律））。
+ */
+const explainedInPlace = (
+  texts: readonly BodyText[],
+  term: string,
+  defining: DefiningName | undefined,
+  prefixes: readonly string[],
+  offset: number,
+): boolean => {
+  const sentence = sentenceAt(texts, offset);
+  if (defining === undefined || sentence === undefined) return false;
+  const at = offset - sentence.start;
+  return (namesItself(defining, prefixes) && followsSelfPrefix(sentence, at, prefixes)) || glossedWithName(sentence, at, term, defining.name);
+};
+
 /**
  * 文の途中で括弧に入れて定義した語（(the "Seller")、以下「甲」という）を、その定義の文より前で使っている所。最初の一つだけ。
  * 定義の文の中の現れ（株式会社GovTech東京（以下「GovTech東京」という。））は、定義する名前そのものなので数えない。札の文も、
- * isTitle が言う題・見出しの行も、漢字で終わる語にさらに漢字が続く長い語の一部も、定義の括弧の前の長い名前を写した所も数えない。
+ * isTitle が言う題・見出し・目次の行も、漢字で終わる語にさらに漢字が続く長い語の一部も、定義の括弧の前の長い名前を写した所も、
+ * 語を含むもっと長い名前の中も数えない。文書自身の名前を定義した語は、selfPrefixes（この、本、this）を付けて前で書いても数えない。
  * 定義の条（"Seller" means、「甲」とは）は条の並びの頭にも終わりにも置く書き方があるので、前で使っても言わない。
  * 定義の語の無い括弧の引用（("The key point is")）は例の引用と同じ形なので、その語を引用符で挙げただけの現れ
  * （Its sentences open with "The key point is"）は使用ではない。定義の語のある定義（(the "Seller")、以下「買主」という）は、
@@ -243,21 +353,28 @@ export const usesBeforeDefinition = (
   texts: readonly BodyText[],
   mentioned: Mentioned = NEVER_MENTIONED,
   isTitle: IsTitle = NEVER_TITLE,
-): TermUse[] =>
-  groupsOf(terms)
+  selfPrefixes: readonly string[] = [],
+): TermUse[] => {
+  const inline = terms.filter((term) => term.inline);
+  const names = definingNames(terms, texts);
+  const insideLongerName = insideLongerNameIn(texts, terms, names);
+  return groupsOf(terms)
     .filter((group) => group.first.inline && isDistinctive(group.first.term))
     .flatMap(({ first: defined, spans }) => {
-      const inline = terms.filter((term) => term.inline);
       const defining = sentenceAt(texts, defined.span.start)?.start ?? defined.span.start;
-      const uses = usesOf(defined.term, texts, spans, "exact", defined.bare === true ? mentioned : NEVER_MENTIONED);
+      const uses = usesOf(defined.term, texts, spans, "exact", defined.bare === true ? mentioned : NEVER_MENTIONED).filter((offset) => offset < defining);
       const first = uses.find(
         (offset) =>
           !isLabel(sentenceAt(texts, offset), defined.term) &&
+          !insideCaption(sentenceAt(texts, offset), offset) &&
           !isTitle(offset) &&
           !continuesInHan(texts, defined.term, offset) &&
           !insideKatakanaName(texts, defined.term, offset) &&
           !echoesLongName(texts, defined, offset) &&
-          !insideDefiningName(texts, inline, defined, offset),
+          !insideDefiningName(texts, inline, defined, offset) &&
+          !insideLongerName(defined.term, offset) &&
+          !explainedInPlace(texts, defined.term, names.get(defined), selfPrefixes, offset),
       );
-      return first !== undefined && first < defining ? [{ term: defined, offset: first }] : [];
+      return first === undefined ? [] : [{ term: defined, offset: first }];
     });
+};

package/src/structure/gerund-phrase.ts

@@ -0,0 +1,31 @@
+// A defined phrase led by an English gerund and its object ("Exercising your options" means ...) names an act, and the
+// document then writes the act as a verb: exercise your options, exercised their options. Pure.
+
+const GERUND = /^(\p{Script=Latin}{2,})ing$/u;
+/** A consonant written twice before -ing (running, setting): the verb has it once. */
+const DOUBLED = /(\p{Script=Latin})\1$/u;
+
+/** The verb forms a stem takes (file, files, filed, filing for "Filing"; exercise for "Exercising"). */
+const formsOf = (stem: string): string[] => {
+  const single = DOUBLED.test(stem) ? [stem.slice(0, -1)] : [];
+  return [...new Set([stem, `${stem}e`, `${stem}es`, `${stem}s`, `${stem}ed`, `${stem}ing`, ...single, ...single.map((verb) => `${verb}s`)])];
+};
+
+const capitalised = (word: string): boolean => word.charAt(0) !== word.charAt(0).toLowerCase();
+
+/**
+ * The same phrase with its leading gerund written as the other forms of its verb ("exercise your options",
+ * "exercised your options" for "Exercising your options"). Only when a determiner follows the gerund (a, the, your):
+ * then it takes an object and is a verb. "Building materials" and "Pricing information" name things, and "Licensing"
+ * alone may be a noun. Empty when the phrase does not take that shape.
+ */
+export const verbFormsOf = (term: string, determiners: ReadonlySet<string>): string[] => {
+  const [first, second, ...rest] = term.split(" ");
+  if (first === undefined || second === undefined || !determiners.has(second.toLowerCase())) return [];
+  const stem = GERUND.exec(first.toLowerCase())?.[1];
+  if (stem === undefined) return [];
+  return formsOf(stem)
+    .map((form) => (capitalised(first) ? `${form.charAt(0).toUpperCase()}${form.slice(1)}` : form))
+    .map((form) => [form, second, ...rest].join(" "))
+    .filter((form) => form !== term);
+};

package/src/structure/issues.ts

@@ -1,5 +1,6 @@
 import type { StructureNode } from "../plugin.ts";
 import { writtenReading } from "./written-resolve.ts";
+import { partAt } from "./attached-parts.ts";
 import { namedTargets, pointsToNamedSection } from "./section-names.ts";
 import { listedTags } from "./listed-tags.ts";
 import { namesAbsentUnit } from "./unit-word.ts";
@@ -9,7 +10,8 @@ import { referencesInCitedDocuments } from "./cited-document-section.ts";
 // 木だけで決まる誤り。参照先が無い、番号が飛ぶ・重なる、同じ語を二度定義する。
 // 意味の食い違いは判定しない。書いてあることから機械で決まるものだけを出す。
 
-export type StructureIssue = { readonly offset: number; readonly values: Readonly<Record<string, string | number>> };
+/** variant は、rule の messages から文を選ぶ鍵。無ければ message。 */
+export type StructureIssue = { readonly offset: number; readonly values: Readonly<Record<string, string | number>>; readonly variant?: string };
 
 const NUMBERED: ReadonlySet<string> = new Set(["chapter", "article", "item"]);
 
@@ -195,13 +197,15 @@ const definitionsInOrder = (tree: StructureNode): Definition[] => {
 /**
  * 同じ語の二度目以降の定義。どちらが正しいかは決めず、両方の場所を示す。
  * 範囲を限った定義（この条において「X」とは）は、同じ条の中でだけ比べる。別の条で定義し直すのは正しい書き方。
+ * 添付した文書（partStarts から始まる Exhibit A など）は別の文書なので、その中の定義はその中でだけ比べる。
  */
-export const duplicateDefinitions = (tree: StructureNode): StructureIssue[] => {
+export const duplicateDefinitions = (tree: StructureNode, partStarts: readonly number[] = []): StructureIssue[] => {
   const first = new Map<string, StructureNode>();
   return definitionsInOrder(tree).flatMap(({ node, article }) => {
     const term = textOf(node, "term");
     const within = node.attrs["within"] === undefined ? article : textOf(node, "within");
-    const key = node.attrs["scope"] === "local" ? `${within}\u0000${term}` : term;
+    const scoped = node.attrs["scope"] === "local" ? `${within}\u0000${term}` : term;
+    const key = `${partAt(partStarts, node.span.start)}\u0000${scoped}`;
     const earlier = first.get(key);
     if (earlier === undefined) {
       first.set(key, node);