chaffjs 0.35.0 → 0.36.0

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,19 @@
 import type { Span, StructureNode } from "../plugin.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { inDocumentOrder } from "./issues.ts";
+import { isTitleWords } from "./contents-lines.ts";
+import {
+  definingNameOf,
+  echoesName,
+  endsLatinName,
+  followsSelfPrefix,
+  glossedWithName,
+  MIN_ECHO,
+  nameBefore,
+  namesItself,
+  sharedTail,
+  type DefiningName,
+} from "./defining-names.ts";
 
 // 定義した語が本文で使われているか、定義より前に使われていないか。どちらも木の定義と、本文の文の字面だけで決まる。
 
@@ -135,6 +148,24 @@ const LABEL_SLACK = 3;
 const isLabel = (body: BodyText | undefined, term: string): boolean =>
   body !== undefined && (body.text.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 +200,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 +242,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 +327,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/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);

package/src/structure/list-lead-in.ts

@@ -0,0 +1,94 @@
+import type { Sentence, Span } from "../plugin.ts";
+
+// 箇条書きの項目の文が、どの導入の文の下にあるか。「(3) If … no such resolution is made—\n(a) the Commissioner must issue …」の
+// (a) は (3) の条件の下にあり、(a) だけを読むと条件が落ちる。
+
+/** 導入の文の終わり。この後に項目が並ぶ（"must include—"、"is made:"、「承認した場合：」）。 */
+const LEAD_IN_END = /[:：—–]\s*$/u;
+
+/** 空行。そこで段落が改まり、導入はそこを越えて探さない。 */
+const BLANK_LINE = /\n[^\S\n]*\n/u;
+
+/** 項目の頭の印: 開き括弧、番号か記号（囲み数字や仮名は 1 字）、閉じ括弧か点。 */
+const MARKER = /^\s*([(（［[]?)([0-9０-９]+|[a-zA-Zａ-ｚＡ-Ｚ]+|[一二三四五六七八九十]+|\S)([)）］\].．]?)/u;
+
+/** 1 字のローマ数字。英字の並び（(h) の次の (i)）でもありうる。 */
+const SINGLE_ROMAN = /^[ivxIVX]$/u;
+const ROMAN = /^(?:[ivxlc]{2,}|[IVXLC]{2,})$/u;
+
+const labelClass = (label: string): string => {
+  if (/^[0-9０-９]+$/u.test(label)) return "1";
+  if (ROMAN.test(label) || SINGLE_ROMAN.test(label)) return /[a-z]/u.test(label) ? "i" : "I";
+  if (/^[a-zａ-ｚ]+$/u.test(label)) return "a";
+  if (/^[A-ZＡ-Ｚ]+$/u.test(label)) return "A";
+  if (/^[一二三四五六七八九十]+$/u.test(label)) return "一";
+  if (/^[\p{Script=Katakana}\p{Script=Hiragana}]$/u.test(label)) return "イ";
+  if (/^[①-⑳㉑-㉟㊱-㊿]$/u.test(label)) return "①";
+  if (/^[⑴-⒇]$/u.test(label)) return "⑴";
+  return label;
+};
+
+/** 項目の文の頭の印の範囲（"(a)"、"①"）。番号は文の中身ではない。項目の文でなければ undefined。 */
+export const itemMarkerSpan = (sentence: Sentence): Span | undefined => {
+  const match = sentence.listItem === true ? MARKER.exec(sentence.text) : null;
+  return match === null ? undefined : { start: sentence.span.start, end: sentence.span.start + match[0].length };
+};
+
+const previousLetter = (label: string): string => String.fromCharCode(label.charCodeAt(0) - 1);
+
+/**
+ * 項目の印の形（"(1)"、"(a)"、"(i)"、"①"、"・"）。番号そのものは数えない。
+ * 1 字の i・v・x は、同じ括弧の英字の項目がその前の字（h・u・w）で終わっていれば英字、でなければローマ数字。
+ */
+export const markerShape = (text: string, lastLetters: ReadonlyMap<string, string>): { readonly shape: string; readonly letter?: string } | undefined => {
+  const match = MARKER.exec(text);
+  const [, open = "", label, close = ""] = match ?? [];
+  if (label === undefined) return undefined;
+  const letterShape = `${open}${/[a-z]/u.test(label) ? "a" : "A"}${close}`;
+  const continuesLetters = SINGLE_ROMAN.test(label) && lastLetters.get(letterShape) === previousLetter(label);
+  const shape = continuesLetters ? letterShape : `${open}${labelClass(label)}${close}`;
+  return shape === letterShape ? { shape, letter: label } : { shape };
+};
+
+type Entry = { readonly sentence: Sentence; readonly leadIns: readonly Sentence[] };
+
+/** 段落の中で、項目の形ごとの最後の項目と、すぐ前の文が導入ならその文。 */
+type Block = {
+  readonly lastByShape: Map<string, { readonly at: number; readonly entry: Entry }>;
+  readonly lastLetters: Map<string, string>;
+  leadIn: { readonly at: number; readonly entry: Entry } | undefined;
+};
+
+const newBlock = (): Block => ({ lastByShape: new Map(), lastLetters: new Map(), leadIn: undefined });
+
+/** 項目の導入の文: すぐ前の文が導入で、それより後に同じ形の項目（兄弟）が無ければその文とその導入、でなければ兄弟の導入。 */
+const leadInsOf = (block: Block, shape: string): readonly Sentence[] => {
+  const sibling = block.lastByShape.get(shape);
+  const leadIn = block.leadIn;
+  if (sibling !== undefined && (leadIn === undefined || sibling.at >= leadIn.at)) return sibling.entry.leadIns;
+  return leadIn === undefined ? [] : [leadIn.entry.sentence, ...leadIn.entry.leadIns];
+};
+
+/**
+ * 箇条書きの項目の文（listItem）ごとの、導入の文。近い順で、導入が項目なら、その導入も続ける。
+ * 導入は、並びの最初の項目のすぐ前の文で、「—」「:」「：」で終わるもの。同じ段落（空行を挟まない）の中で、同じ形の項目どうしは
+ * 同じ導入の下にある。
+ * sentences は文書の順。source は sentences の span の座標の文字列。
+ */
+export const listLeadIns = (source: string, sentences: readonly Sentence[]): Map<Sentence, readonly Sentence[]> => {
+  const found = new Map<Sentence, readonly Sentence[]>();
+  let block = newBlock();
+  sentences.forEach((sentence, at) => {
+    const previous = sentences[at - 1];
+    if (previous !== undefined && BLANK_LINE.test(source.slice(previous.span.end, sentence.span.start))) block = newBlock();
+    const marker = sentence.listItem === true ? markerShape(sentence.text, block.lastLetters) : undefined;
+    const entry: Entry = { sentence, leadIns: marker === undefined ? [] : leadInsOf(block, marker.shape) };
+    if (marker !== undefined) {
+      found.set(sentence, entry.leadIns);
+      block.lastByShape.set(marker.shape, { at, entry });
+      if (marker.letter !== undefined) block.lastLetters.set(marker.shape, marker.letter.at(-1) ?? "");
+    }
+    block.leadIn = LEAD_IN_END.test(sentence.text) ? { at, entry } : undefined;
+  });
+  return found;
+};

package/src/structure/modal-conflict.ts

@@ -1,4 +1,6 @@
+import { isMarkedNegation, negatedWords } from "./negated-act.ts";
 import type { Sentence, Span, Token } from "../plugin.ts";
+import { itemMarkerSpan } from "./list-lead-in.ts";
 
 // 同じ主語と行為に、逆の様相（しなければならない と してはならない、may と must not）を書いた二つの文。
 // 主語と行為は、文の中身の語（名詞・固有名詞・動詞・形容詞）の集まりで近似する。様相の語そのものは数えない。
@@ -24,13 +26,21 @@ const OPPOSITE: Readonly<Record<string, readonly string[]>> = {
 
 const overlaps = (token: Token, spans: readonly Span[]): boolean => spans.some((span) => token.span.start < span.end && span.start < token.span.end);
 
-/** 文の中身の語を、原形の小文字で、重ねずに並べたもの。様相の語の範囲にかかる語は外す。 */
+/**
+ * 文の中身の語を、原形の小文字で、重ねずに並べたもの。様相の語の範囲にかかる語は外す。
+ * 打ち消しの印の付いた機能語（negationsMarked）は、近くの中身の語に印を付ける（negatedWords）。様相の語の中の打ち消し（must not）は数えない。
+ */
 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()),
+      negatedWords(
+        tokens
+          .filter((token) => (CONTENT.has(token.pos) || isMarkedNegation(token)) && !overlaps(token, markers))
+          .map((token) => ({
+            word: (token.lemma !== undefined && token.lemma !== "" ? token.lemma : token.surface).toLowerCase(),
+            negation: !CONTENT.has(token.pos),
+          })),
+      ),
     ),
   ]
     .toSorted((left, right) => left.localeCompare(right, "en"))
@@ -51,11 +61,21 @@ const sentenceAt = (sentences: readonly Sentence[], offset: number): Sentence |
   return undefined;
 };
 
+/** 中身の語の集まりを足し合わせたもの。並べ方は contentKey と同じ。 */
+const joinedKey = (keys: readonly string[]): string =>
+  [...new Set(keys.flatMap((key) => (key === "" ? [] : key.split(" "))))].toSorted((left, right) => left.localeCompare(right, "en")).join(" ");
+
 /**
  * 様相の語を一つだけ持つ文の、様相と中身。二つ以上持つ文（shall do A and shall not do B）は、どの語がどの行為にかかるかが
  * 中身の語の集まりからは分からないので外す。品詞の無い文も外す。
+ * leadIns は箇条書きの項目の文の導入の文（listLeadIns）。項目の中身には導入の中身の語を足す。導入の条件（"If … is made—"）は
+ * 項目の行為の条件なので、違う導入の下の項目どうしは、同じ行為を決めていない。
  */
-export const modalStatements = (obligations: readonly Obligation[], sentences: readonly Sentence[]): ModalStatement[] => {
+export const modalStatements = (
+  obligations: readonly Obligation[],
+  sentences: readonly Sentence[],
+  leadIns: ReadonlyMap<Sentence, readonly Sentence[]> = new Map(),
+): ModalStatement[] => {
   const bySentence = new Map<Sentence, Obligation[]>();
   obligations.forEach((obligation) => {
     const sentence = sentenceAt(sentences, obligation.start);
@@ -64,11 +84,26 @@ export const modalStatements = (obligations: readonly Obligation[], sentences: r
     if (found === undefined) bySentence.set(sentence, [obligation]);
     else found.push(obligation);
   });
+  /** 様相の語と項目の印を除いた中身。 */
+  const keyOf = (sentence: Sentence, tokens: readonly Token[], markers: readonly Span[]): string => {
+    const item = itemMarkerSpan(sentence);
+    return contentKey(tokens, item === undefined ? markers : [...markers, item]);
+  };
+  const leadInKeys = new Map<Sentence, string>();
+  const leadInKey = (sentence: Sentence): string => {
+    const known = leadInKeys.get(sentence);
+    if (known !== undefined) return known;
+    const key = sentence.tokens === undefined ? "" : keyOf(sentence, sentence.tokens, bySentence.get(sentence) ?? []);
+    leadInKeys.set(sentence, key);
+    return key;
+  };
   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 }];
+    const own = keyOf(sentence, sentence.tokens, [only]);
+    if (own.split(" ").length < MIN_CONTENT_WORDS) return [];
+    const key = joinedKey([own, ...(leadIns.get(sentence) ?? []).map(leadInKey)]);
+    return [{ offset: sentence.span.start, type: only.type, marker: only.marker, key }];
   });
 };
 

package/src/structure/negated-act.ts

@@ -0,0 +1,49 @@
+import type { Lexicon, Sentence, Token } from "../plugin.ts";
+
+// 行為や条件の中の打ち消し（"goods that do not conform"、「承認しなかった場合」）。打ち消しの語は中身の語ではないが、
+// 打ち消しだけが違う二つの文は、違うことを決めている。
+
+/** 打ち消しの語に付ける印（Token.features の名前）。 */
+const NEGATION_FEATURE = "negation";
+
+/** 打ち消しを受けた語の印。語の後ろに付ける。 */
+export const NEGATED = "¬";
+
+/** 語彙表の打ち消しの語（group の無いもの。接頭の「不」「未」は語の一部なので見ない）。英語は小文字で照らす。 */
+export const negationWords = (lexicon: Lexicon | undefined): ReadonlySet<string> =>
+  new Set((lexicon ?? []).filter((entry) => entry.group === undefined).map((entry) => entry.pattern.toLowerCase()));
+
+const isNegation = (token: Token, words: ReadonlySet<string>): boolean =>
+  words.has(token.surface.toLowerCase()) || (token.lemma !== undefined && words.has(token.lemma.toLowerCase()));
+
+export const isMarkedNegation = (token: Token): boolean => token.features?.[NEGATION_FEATURE] !== undefined;
+
+/** 打ち消しの語に印を付けた文。品詞の無い文はそのまま。 */
+export const negationsMarked = (sentences: readonly Sentence[], words: ReadonlySet<string>): Sentence[] =>
+  sentences.map((sentence) =>
+    sentence.tokens === undefined
+      ? sentence
+      : {
+          ...sentence,
+          tokens: sentence.tokens.map((token) => (isNegation(token, words) ? { ...token, features: { ...token.features, [NEGATION_FEATURE]: "yes" } } : token)),
+        },
+  );
+
+type Placed = { readonly out: readonly string[]; readonly pending: boolean };
+
+/**
+ * 語の並びの打ち消しを、すぐ前の語（文頭なら次の語）に NEGATED として付けたもの。どの語にかかるかは読まない。
+ * 打ち消しのある文と無い文を分けるための印で、二つ重なっても一つにする。
+ */
+export const negatedWords = (words: readonly { readonly word: string; readonly negation: boolean }[]): string[] =>
+  words
+    .reduce<Placed>(
+      ({ out, pending }, { word, negation }) => {
+        if (!negation) return { out: [...out, pending ? `${word}${NEGATED}` : word], pending: false };
+        const last = out.at(-1);
+        if (last === undefined) return { out, pending: true };
+        return { out: last.endsWith(NEGATED) ? out : [...out.slice(0, -1), `${last}${NEGATED}`], pending: false };
+      },
+      { out: [], pending: false },
+    )
+    .out.slice();