chaffjs 0.34.0 → 0.36.0

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/html-text-blocks.ts

@@ -0,0 +1,45 @@
+import { readMarkdown } from "../markdown-read.ts";
+import { spanOf, type MarkdownNode } from "../markdown-node.ts";
+import type { Span } from "../plugin.ts";
+
+const COMMENT = /<!--[\s\S]*?(?:-->|$)/gu;
+const INLINE_CONTAINERS = new Set(["paragraph", "heading", "tableCell"]);
+const ENTITY = /&(?:#\d+|#x[\da-f]+|[a-z]+\d*);/giu;
+
+type TagScan = { readonly kept: string[]; inTag: boolean; quote: string | undefined };
+
+/** Reads one character of HTML: text outside a tag is kept. A quoted attribute may hold `>` (`<div title=">">`). */
+const scanned = (scan: TagScan, char: string): TagScan => {
+  if (!scan.inTag) {
+    if (char === "<") scan.inTag = true;
+    else scan.kept.push(char);
+  } else if (scan.quote !== undefined) {
+    if (char === scan.quote) scan.quote = undefined;
+  } else if (char === '"' || char === "'") scan.quote = char;
+  else if (char === ">") scan.inTag = false;
+  return scan;
+};
+
+const withoutTags = (html: string): string => [...html].reduce<TagScan>(scanned, { kept: [], inTag: false, quote: undefined }).kept.join("");
+
+/** What an HTML block shows the reader: its text without tags, comments and character references such as `&nbsp;`. */
+const showsText = (html: string): boolean => withoutTags(html.replace(COMMENT, "")).replace(ENTITY, "").trim() !== "";
+
+/**
+ * Markdown's HTML blocks that show text. CommonMark runs a block that starts with a tag alone on its line (`<br/>`) to
+ * the next blank line, so a `第11条` written right under it is raw HTML: the reader sees it, chaff's structure does not.
+ * Only blocks are returned; an inline tag inside a paragraph (`text<br/>`) leaves the text beside it readable.
+ */
+export const htmlTextBlocks = (source: string): Span[] => {
+  if (!source.includes("<")) return [];
+  const blocks: Span[] = [];
+  const visit = (node: MarkdownNode, inParagraph: boolean): void => {
+    if (node.type === "html" && !inParagraph && showsText(node.value ?? "")) {
+      const span = spanOf(node);
+      if (span !== undefined) blocks.push(span);
+    }
+    (node.children ?? []).forEach((child) => visit(child, inParagraph || INLINE_CONTAINERS.has(node.type)));
+  };
+  visit(readMarkdown(source).root, false);
+  return blocks.toSorted((left, right) => left.start - right.start);
+};

package/src/structure/issues.ts

@@ -1,11 +1,17 @@
 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";
+import { isListedParagraph, listedParagraphsByArticle } from "./listed-paragraph.ts";
+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"]);
 
@@ -111,7 +117,7 @@ const numbering = (node: StructureNode): unknown => node.attrs["numbering"];
  * 参照の番地が木に無い。他の文書の名前が付いた参照（民法第709条、Section 9 of the Master Agreement）は引かない。
  * 条を 1 つも持たない文書も見ない。他の文書を指しているだけかもしれない。
  */
-export const danglingReferences = (tree: StructureNode, source: string): StructureIssue[] => {
+export const danglingReferences = (tree: StructureNode, source: string, nameNouns: readonly string[] = []): StructureIssue[] => {
   const nodes = inDocumentOrder(tree);
   // 参照は条を指す。条を一つも持たない文書（契約書に付ける承諾書のひな形など）の「契約書第6条」は、別の文書の条。
   if (!nodes.some((node) => node.kind === "article")) return [];
@@ -127,10 +133,21 @@ export const danglingReferences = (tree: StructureNode, source: string): Structu
   const articleLabels = nodes.filter((node) => node.kind === "article").map((node) => textOf(node, "label"));
   const chapters = chaptersOf(nodes);
   const elsewhere = elsewhereReferences(nodes, source);
-  return nodes
-    .filter((node) => node.kind === "reference" && !citesOther(node) && !otherNumbering(node))
+  const quoted = referencesInCitedDocuments(tree);
+  const references = nodes.filter((node) => node.kind === "reference");
+  const named = namedTargets(references, source, nameNouns);
+  const unresolved = references
+    .filter((node) => !citesOther(node) && !otherNumbering(node) && !pointsToNamedSection(node, named))
     .filter((node) => !namesAbsentUnit(node, articleLabels) && !elsewhere.has(node))
-    .filter((node) => !resolves(node, addresses, chapters))
+    .filter((node) => !quoted.has(node) && !resolves(node, addresses, chapters));
+  // 規程は条の下の項を箇条書き（「1. 」「２．」）で書くことがあり、木はそれを項として読まない。条の本文は、要るときに一度だけ読む。
+  const listed = unresolved.length === 0 ? new Map() : listedParagraphsByArticle(nodes, source);
+  // 平文の契約は見出しを「9. Indemnification.」と本文の形で書き、木はそれを番地にしない。残った参照があるときだけ読む。
+  const written = unresolved.length === 0 ? undefined : writtenReading(nodes, source);
+  const writtenAddresses = new Set(written?.addresses);
+  return unresolved
+    .filter((node) => !isListedParagraph(textOf(node, "target"), listed))
+    .filter((node) => !writtenAddresses.has(textOf(node, "target")) && written?.subdivision(node) !== true)
     .map((node) => ({ offset: node.span.start, values: { label: textOf(node, "label"), target: textOf(node, "target") } }));
 };
 
@@ -180,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/labelled-date-order.ts

@@ -4,6 +4,7 @@ import type { StructureIssue } from "./issues.ts";
 import type { Line } from "./lines.ts";
 import { labelPairsOf, pointsOutOfOrder, type OrderLabel, type PairWords, type PointOf } from "./labelled-order.ts";
 import { TABLE_ROW } from "./runs.ts";
+import type { VersionWords } from "./versioned-label.ts";
 import { isSignedDateLine } from "./signed-date-line.ts";
 import { statedPeriod, type DateMention, type PeriodWords } from "./stated-period.ts";
 
@@ -132,6 +133,8 @@ export type PairedReading = {
   readonly spans?: PairSpans | undefined;
   readonly whole?: string | undefined;
   readonly signers?: readonly OrderLabel[] | undefined;
+  /** The words that join a version to a label (End of support for 5.0.0, 3.0.0 のサポート終了日). */
+  readonly versions?: VersionWords | undefined;
 };
 
 const signersOf = (signers: readonly OrderLabel[], group: string): string[] =>
@@ -166,14 +169,14 @@ export const pairedDatesOutOfOrder = (
   labels: readonly OrderLabel[],
   passed: readonly string[],
   maxLineGap: number,
-  { spans, whole = source, signers = [] }: PairedReading = {},
+  { spans, whole = source, signers = [], versions }: PairedReading = {},
 ): PairedIssue[] =>
   withoutRepeats(
     labelPairsOf(labels).flatMap((pair) => {
       const context = contextOf(labels, pair.group);
       if (context.length > 0 && !namesDocumentKind(whole, context)) return [];
       const fromStart = spanStartsOf(spans?.entries ?? [], pair.group);
-      const words = { ...pair, passed, maxLineGap, spans, fromStart, signers: signersOf(signers, pair.group) };
+      const words = { ...pair, passed, maxLineGap, spans, fromStart, signers: signersOf(signers, pair.group), versions };
       return datesOutOfOrder(source, dates, words).map(({ earlier, later }) => ({
         offset: Math.max(later.date.offset, earlier.date.offset),
         values: { later: later.date.value, earlier: earlier.date.value, later_label: later.label, earlier_label: earlier.label },

package/src/structure/labelled-order.ts

@@ -2,6 +2,7 @@ import { linesOf, type Line } from "./lines.ts";
 import { tableAround } from "./key-value-row.ts";
 import { signerRoleOf } from "./signed-date-line.ts";
 import { isTotalLabel } from "./total.ts";
+import { withoutLabelVersion, type VersionWords } from "./versioned-label.ts";
 
 /**
  * Two labelled points that must come in order: a line (or a list item, or a table's first column) starting with an
@@ -24,6 +25,8 @@ export type PairWords = {
    * pointOf decides whether the line is one. A signature closes the whole document, so it is read at any distance.
    */
   readonly signers?: readonly string[] | undefined;
+  /** The words that join a version to a label (End of support for 5.0.0, 3.0.0 のサポート終了日). */
+  readonly versions?: VersionWords | undefined;
 };
 
 /** A labelled point: the word that labels it, as the lexicon writes it. span is set when the point ends a stated period. */
@@ -36,7 +39,13 @@ export type PointOf = (line: Line, label: string, tableOf: () => readonly string
 
 type Read = LabelledPoint & { readonly kind: "earlier" | "later"; readonly signed?: boolean | undefined };
 
-const labelOf = (text: string, words: readonly string[]): string | undefined => words.find((word) => isTotalLabel(text, [word]));
+const isVersionedLabel = (text: string, word: string, versions: VersionWords | undefined): boolean => {
+  const bare = versions === undefined ? undefined : withoutLabelVersion(text, word, versions);
+  return bare !== undefined && isTotalLabel(bare, [word]);
+};
+
+const labelOf = (text: string, words: readonly string[], versions?: VersionWords): string | undefined =>
+  words.find((word) => isTotalLabel(text, [word]) || isVersionedLabel(text, word, versions));
 
 const signerOf = (text: string, words: PairWords): Pick<Read, "kind" | "label" | "signed"> | undefined => {
   const role = signerRoleOf(text, words.signers ?? []);
@@ -44,9 +53,9 @@ const signerOf = (text: string, words: PairWords): Pick<Read, "kind" | "label" |
 };
 
 const kindOf = (text: string, words: PairWords): Pick<Read, "kind" | "label" | "signed"> | undefined => {
-  const earlier = labelOf(text, words.earlier);
+  const earlier = labelOf(text, words.earlier, words.versions);
   if (earlier !== undefined) return { kind: "earlier", label: earlier };
-  const later = labelOf(text, words.later);
+  const later = labelOf(text, words.later, words.versions);
   return later === undefined ? signerOf(text, words) : { kind: "later", label: later };
 };
 

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

@@ -4,31 +4,120 @@ import type { Span } from "../plugin.ts";
 import type { StructureIssue } from "./issues.ts";
 
 const ITEM_NUMBER = /^(?<number>\d{1,9})(?<delimiter>[.)])[ \t]/u;
+const TAB_WIDTH = 4;
 
-/** One item's written number: where the item starts, the number and the number as written (「4.」). */
-export type WrittenNumber = { readonly offset: number; readonly number: number; readonly label: string };
+/** One item's written number: where the item starts and ends, its column, the number and the number as written (「4.」). */
+export type WrittenNumber = {
+  readonly offset: number;
+  readonly number: number;
+  readonly label: string;
+  readonly indent?: number;
+  readonly end?: number;
+};
+
+/** The column an offset sits at, a tab counted to the next stop of four as CommonMark counts it. */
+const columnAt = (source: string, offset: number): number =>
+  Array.from(source.slice(source.lastIndexOf("\n", offset - 1) + 1, offset)).reduce(
+    (column, char) => (char === "\t" ? column + TAB_WIDTH - (column % TAB_WIDTH) : column + 1),
+    0,
+  );
+
+const numberAt = (source: string, span: Span): { number: number; label: string } | undefined => {
+  const found = ITEM_NUMBER.exec(source.slice(span.start, span.end))?.groups;
+  return found === undefined ? undefined : { number: Number(found["number"]), label: `${found["number"] ?? ""}${found["delimiter"] ?? ""}` };
+};
 
 /** The number written at the start of each item, or undefined when an item has none (a bulleted list). */
 export const writtenNumbers = (source: string, itemSpans: readonly Span[]): WrittenNumber[] | undefined => {
   const numbers = itemSpans.map((span) => {
-    const found = ITEM_NUMBER.exec(source.slice(span.start, span.end))?.groups;
-    return found === undefined
-      ? undefined
-      : { offset: span.start, number: Number(found["number"]), label: `${found["number"] ?? ""}${found["delimiter"] ?? ""}` };
+    const found = numberAt(source, span);
+    return found === undefined ? undefined : { offset: span.start, end: span.end, ...found, indent: columnAt(source, span.start) };
   });
   return numbers.every((entry) => entry !== undefined) ? numbers : undefined;
 };
 
+/** The last number of an ordered list nested in an item, if there is one. */
+export type NestedLast = (item: WrittenNumber) => number | undefined;
+
+type OrderedList = { readonly start: number; readonly end: number; readonly last: number };
+
+const orderedListOf = (source: string, spans: readonly Span[]): OrderedList[] => {
+  const first = spans[0];
+  const last = writtenNumbers(source, spans)?.at(-1);
+  return first === undefined || last === undefined ? [] : [{ start: first.start, end: last.end ?? last.offset, last: last.number }];
+};
+
+/**
+ * For an item, the last number of the ordered list inside it that ends last (the outermost one, when lists nested in
+ * each other end together). lists are the item spans of every list in the document; bulleted lists are left out.
+ */
+export const nestedLastFinder = (source: string, lists: readonly (readonly Span[])[]): NestedLast => {
+  const ordered = lists.flatMap((spans) => orderedListOf(source, spans));
+  return (item) =>
+    ordered
+      .filter((list) => list.start > item.offset && list.end <= (item.end ?? item.offset))
+      .reduce<OrderedList | undefined>(
+        (best, list) => (best === undefined || list.end > best.end || (list.end === best.end && list.start < best.start) ? list : best),
+        undefined,
+      )?.last;
+};
+
+type Compared = { readonly item: WrittenNumber; readonly previous: WrittenNumber | undefined };
+
+const indentOf = (item: WrittenNumber): number => item.indent ?? 0;
+
 /**
- * Each item whose number is not one more than the item before it. A list that writes one number on every item (「1.」 on
- * each, which Markdown counts up) is numbered by the renderer, not by the writer, and is not read. An item numbered 1
+ * Which item each item's number follows. An item at the same indentation follows the last one there. An item indented
+ * deeper starts a nested count (CommonMark can still put it in the same list, when the indentation falls short of the
+ * parent's text), unless it carries on the count above it: the parent's number plus one (a slip of indentation), or
+ * one past the last number of the list nested in the parent (that list, carried on at a different indentation).
+ */
+const comparedPairs = (items: readonly WrittenNumber[], nestedLast: NestedLast): Compared[] => {
+  const open: WrittenNumber[] = [];
+  return items.map((item) => {
+    const popped: WrittenNumber[] = [];
+    for (let top = open.at(-1); top !== undefined && indentOf(top) > indentOf(item); top = open.at(-1)) {
+      popped.push(top);
+      open.pop();
+    }
+    const parent = open.at(-1);
+    if (parent !== undefined && indentOf(parent) === indentOf(item)) {
+      open[open.length - 1] = item;
+      return { item, previous: parent };
+    }
+    if (parent === undefined) {
+      open.push(item);
+      return { item, previous: popped.at(-1) };
+    }
+    if (item.number === parent.number + 1) {
+      open[open.length - 1] = { ...item, indent: indentOf(parent) };
+      return { item, previous: parent };
+    }
+    open.push(item);
+    return { item, previous: item.number === 1 || item.number === (nestedLast(parent) ?? 0) + 1 ? undefined : parent };
+  });
+};
+
+/**
+ * Each item whose number is not one more than the item it follows. A list that writes one number on every item (「1.」
+ * on each, which Markdown counts up) is numbered by the renderer, not by the writer, and is not read. An item numbered 1
  * starts a new count, as the structure rule reads a 1 that follows other items.
  */
-export const listNumberBreaks = (items: readonly WrittenNumber[]): StructureIssue[] => {
+export const listNumberBreaks = (items: readonly WrittenNumber[], nestedLast: NestedLast = () => undefined): StructureIssue[] => {
   if (new Set(items.map((item) => item.number)).size < 2) return [];
-  return items.flatMap((item, index) => {
-    const previous = items[index - 1];
+  return comparedPairs(items, nestedLast).flatMap(({ item, previous }) => {
     if (previous === undefined || item.number === previous.number + 1 || item.number === 1) return [];
     return [{ offset: item.offset, values: { previous: previous.label, label: item.label, expected: previous.number + 1, found: item.number } }];
   });
 };
+
+type ListSpans = { readonly span: Span; readonly itemSpans: readonly Span[] };
+
+/** The breaks in the document's lists that are checked; every list, checked or not, tells which ordered list sits inside an item. */
+export const listsNumberBreaks = (source: string, lists: readonly ListSpans[], isChecked: (list: ListSpans) => boolean): StructureIssue[] => {
+  const nestedLast = nestedLastFinder(
+    source,
+    lists.map((list) => list.itemSpans),
+  );
+  return lists.filter(isChecked).flatMap((list) => listNumberBreaks(writtenNumbers(source, list.itemSpans) ?? [], nestedLast));
+};