chaffjs 0.7.0 → 0.9.0

package/src/structure/build.ts

@@ -1,7 +1,10 @@
 import type { Heading } from "../document.ts";
 import { atxHeadingText, headingText } from "../heading-text.ts";
+import { addressSpans } from "../address-chain.ts";
+import { relativeMentions } from "./relative-find.ts";
+import { resolveRelative } from "./relative-resolve.ts";
 import { maskSpans } from "../mask.ts";
-import type { Mention, NumberedLine, NumberingContext, Span, StructureKind, StructureNode, StructurePatterns } from "../plugin.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";
 
@@ -15,6 +18,9 @@ type Draft = {
   readonly attrs: Readonly<Record<string, string | number>>;
   readonly children: Draft[];
   readonly ordinal?: number | undefined;
+  readonly level?: number | undefined;
+  readonly ordinalTo?: number | undefined;
+  readonly numbering?: string | undefined;
 };
 
 /** 開いている節点。rank の大きいものほど内側。 */
@@ -30,6 +36,13 @@ type State = {
   readonly stack: Frame[];
   /** 見出しの深さごとの通し番号。番号の無い見出しの番地 h2.1 を作る。 */
   readonly headingCounts: number[];
+  /** opensDefinitionScope の行を含んだまとまり（ふつうは条）。ここに入る定義は範囲の中でだけ比べる。 */
+  readonly scopedArticles: Set<Draft>;
+  /** 範囲が条より広い（「In this Part—」）条と、その広いまとまり。その条の定義は、広いまとまりの中で比べる。 */
+  readonly widerScopes: Map<Draft, Draft>;
+  readonly profile: DocumentProfile | undefined;
+  /** 見出しだけの行（文書の種類の caption）の行番号と、その言葉。すぐ次の行の条が見出しに使う。 */
+  readonly captions: Map<number, string>;
 };
 
 const draftOf = (kind: StructureKind, address: string, line: Line, attrs: Readonly<Record<string, string | number>>): Draft => ({
@@ -88,7 +101,13 @@ const openNumbered = (state: State, line: Line, numbered: NumberedLine, headingD
   const rank = headingDepth ?? NUMBERED_RANK + numbered.depth;
   // 番地は、自分と同じか内側を閉じてから決める。閉じる前だと、同じ深さの前の条を親と取り違える。
   while (state.stack.length > 1 && top(state).rank >= rank) state.stack.pop();
-  const draft = { ...draftOf(numbered.kind, addressOf(state, numbered), line, attrs), ordinal: numbered.ordinal };
+  const draft = {
+    ...draftOf(numbered.kind, addressOf(state, numbered), line, attrs),
+    ordinal: numbered.ordinal,
+    level: numbered.depth,
+    ordinalTo: numbered.ordinalTo,
+    numbering: numbered.numbering,
+  };
   open(state, { draft, rank, numbered });
 };
 
@@ -97,11 +116,30 @@ const openSection = (state: State, line: Line, heading: Heading): void => {
   open(state, { draft: draftOf("section", headingAddress(state, heading.depth), line, { heading: heading.text }), rank: heading.depth });
 };
 
-const LEAVES: readonly { readonly kind: StructureKind; readonly find: (patterns: StructurePatterns, text: string) => readonly Mention[] }[] = [
+/** 番地（文書の種類が決める「前二項」など）の中の数は、数量ではない。 */
+const outsideAddresses = (mentions: readonly Mention[], text: string, profile: DocumentProfile | undefined): readonly Mention[] => {
+  const spans = addressSpans(text, profile);
+  return spans.length === 0 ? mentions : mentions.filter((mention) => !spans.some((span) => span.start <= mention.start && mention.end <= span.end));
+};
+
+/** 番地を名指しした参照（第百五十七条第一項）の一部は、相対の参照ではない。 */
+const withoutAbsolute = (relative: readonly Mention[], absolute: readonly Mention[]): readonly Mention[] =>
+  relative.filter((mention) => !absolute.some((other) => mention.start < other.end && other.start < mention.end));
+
+type LeafFinder = (patterns: StructurePatterns, text: string, profile: DocumentProfile | undefined) => readonly Mention[];
+
+const LEAVES: readonly { readonly kind: StructureKind; readonly find: LeafFinder }[] = [
   { kind: "definition", find: (patterns, text) => patterns.definitions(text) },
   { kind: "reference", find: (patterns, text) => patterns.references(text) },
+  {
+    kind: "reference",
+    find: (patterns, text, profile) => {
+      const absolute = patterns.references(text);
+      return withoutAbsolute(relativeMentions(text, profile, patterns.number, absolute), absolute);
+    },
+  },
   { kind: "obligation", find: (patterns, text) => patterns.obligations(text) },
-  { kind: "quantity", find: (patterns, text) => patterns.quantities(text) },
+  { kind: "quantity", find: (patterns, text, profile) => outsideAddresses(patterns.quantities(text), text, profile) },
   { kind: "date", find: (patterns, text) => patterns.dates?.(text) ?? [] },
 ];
 
@@ -112,13 +150,54 @@ const universalNumber = (patterns: StructurePatterns, text: string, context: Num
 };
 
 /** 行の中の定義・参照・義務・数量を、いま開いている最も内側の節点の子にする。 */
+const enclosingArticle = (state: State): Draft | undefined => [...state.stack].reverse().find((frame) => frame.draft.kind === "article")?.draft;
+
+/** 条より広い範囲（「In this Part」）なら、その深さの開いているまとまり。開いていなければ（Part の見出しの無い文書）無い。 */
+const widerScope = (state: State, patterns: StructurePatterns, text: string): Draft | undefined => {
+  const depth = patterns.definitionScopeDepth?.(text);
+  return depth === undefined ? undefined : [...state.stack].reverse().find((frame) => frame.numbered?.depth === depth)?.draft;
+};
+
+/** 範囲を宣言した行を持つまとまり。条の中なら条、条の外（Markdown の見出しの下、Part の直下）なら開いている一番内側のもの。 */
+const holderOf = (state: State): Draft => enclosingArticle(state) ?? top(state).draft;
+
+/**
+ * 定義の範囲。範囲を宣言した行（In this section— / In this Part—）を含むまとまりの定義が対象。宣言が Part なら、比べるのは
+ * その Part の中（within に番地を残す）。条の外で宣言したものは、そのまとまりの中。宣言の無いところの定義は、文書全体で比べる。
+ */
+const scopeOf = (state: State, patterns: StructurePatterns, text: string): Readonly<Record<string, string>> => {
+  const holder = holderOf(state);
+  if (patterns.opensDefinitionScope?.(text) === true) {
+    state.scopedArticles.add(holder);
+    const wider = widerScope(state, patterns, text);
+    if (wider !== undefined) state.widerScopes.set(holder, wider);
+  }
+  if (!state.scopedArticles.has(holder)) return {};
+  const within = state.widerScopes.get(holder) ?? (holder.kind === "article" ? undefined : holder);
+  return within === undefined ? { scope: "local" } : { scope: "local", within: within.address };
+};
+
 const addLeaves = (state: State, patterns: StructurePatterns, line: Line, text: string, offset: number): void => {
   const parent = top(state).draft;
+  const scope = scopeOf(state, patterns, text);
   const leaves = LEAVES.flatMap(({ kind, find }) =>
-    find(patterns, text).map((mention) => ({ kind, start: line.start + offset + mention.start, end: line.start + offset + mention.end, attrs: mention.attrs })),
+    find(patterns, text, state.profile).map((mention) => ({
+      kind,
+      start: line.start + offset + mention.start,
+      end: line.start + offset + mention.end,
+      attrs: mention.attrs,
+    })),
   ).sort((left, right) => left.start - right.start);
   leaves.forEach((leaf) =>
-    parent.children.push({ kind: leaf.kind, address: "", start: leaf.start, end: leaf.end, line: line.number, attrs: leaf.attrs, children: [] }),
+    parent.children.push({
+      kind: leaf.kind,
+      address: "",
+      start: leaf.start,
+      end: leaf.end,
+      line: line.number,
+      attrs: leaf.kind === "definition" ? { ...leaf.attrs, ...scope } : leaf.attrs,
+      children: [],
+    }),
   );
 };
 
@@ -136,6 +215,9 @@ const freeze = (draft: Draft): StructureNode => ({
   attrs: draft.attrs,
   children: draft.children.map(freeze),
   ...(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 はどちらも空。 */
@@ -143,7 +225,13 @@ export type Outline = { readonly headings: readonly Heading[]; readonly opaque:
 
 export const NO_OUTLINE: Outline = { headings: [], opaque: [] };
 
-export type StructureInput = { readonly path: string; readonly source: string; readonly language: string; readonly outline: Outline };
+export type StructureInput = {
+  readonly path: string;
+  readonly source: string;
+  readonly language: string;
+  readonly outline: Outline;
+  readonly profile?: DocumentProfile | undefined;
+};
 
 /** 見出しのある行を、行番号から引けるようにする。見出しごとに全行を探し直さない。 */
 const headingsByLine = (lines: readonly Line[], headings: readonly Heading[]): Map<number, Heading> =>
@@ -156,7 +244,6 @@ const headingsByLine = (lines: readonly Line[], headings: readonly Heading[]): M
     }),
   );
 
-/** 見出しの行から「#」の印を外した文字列。コードを覆った後の行から取るので、見出しの中のコードも読まない。 */
 /**
  * 見出しの行から見出しの言葉を取る。コードを覆った後の行から取るので、見出しの中のコードも読まない。
  * ATX（行頭が #）なら印と閉じの # を外す。setext（下線で書く見出し）の末尾の # は言葉なので残す。
@@ -167,11 +254,30 @@ const headingLineText = (text: string): string => {
   return atxHeadingText(line.replace(/^#{1,6}(?=[ \t]|$)/u, "").trim());
 };
 
+const captionPatterns = new WeakMap<DocumentProfile, RegExp | undefined>();
+
+/** 文書の種類が決めた見出しだけの行なら、その言葉（最初の括弧の中、括弧が無ければ行全体）。 */
+const captionOf = (profile: DocumentProfile | undefined, text: string): string | undefined => {
+  if (profile === undefined) return undefined;
+  if (!captionPatterns.has(profile)) captionPatterns.set(profile, profile.caption === undefined ? undefined : new RegExp(profile.caption, "u"));
+  const found = captionPatterns.get(profile)?.exec(text);
+  const words = (found?.[1] ?? found?.[0])?.trim();
+  return words === "" ? undefined : words;
+};
+
+/** 見出しの無い条のすぐ前の行が見出しだけの行なら、それを条の見出しにする。 */
+const withCaption = (state: State, line: Line, numbered: NumberedLine | undefined): NumberedLine | undefined => {
+  const caption = numbered?.kind === "article" && numbered.heading === "" ? state.captions.get(line.number - 1) : undefined;
+  return numbered === undefined || caption === undefined ? numbered : { ...numbered, heading: caption };
+};
+
 const readLine = (state: State, patterns: StructurePatterns, line: Line, heading: Heading | undefined): 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 numbered = patterns.numbered(text, context) ?? universalNumber(patterns, text, context);
+  const numbered = withCaption(state, line, patterns.numbered(text, context) ?? universalNumber(patterns, text, context));
+  const caption = numbered === undefined && heading === undefined ? captionOf(state.profile, text) : undefined;
+  if (caption !== undefined) state.captions.set(line.number, caption);
   // 番号付きの見出しも見出しの通し番号を進める。進めないと、その下の「### 詳細」が前の見出しの番地を名乗る。
   if (numbered !== undefined && heading !== undefined) headingAddress(state, heading.depth);
   if (numbered !== undefined) openNumbered(state, line, numbered, heading?.depth);
@@ -193,13 +299,23 @@ export const buildTree = (input: StructureInput, patterns: StructurePatterns): S
   // 文中の `第99条` は参照として拾われない。位置は元の文書のまま。
   const lines = linesOf(maskSpans(input.source, outline.opaque));
   const headings = headingsByLine(lines, outline.headings);
-  const doc = draftOf("doc", "", { text: "", start: 0, number: 1 }, { path: input.path, language: input.language });
+  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;
-  const state: State = { stack: [{ draft: doc, rank: 0 }], headingCounts: [] };
+  const state: State = {
+    stack: [{ draft: doc, rank: 0 }],
+    headingCounts: [],
+    scopedArticles: new Set(),
+    widerScopes: new Map(),
+    profile: input.profile,
+    captions: new Map(),
+  };
   lines.forEach((line) => {
     if (line.text.trim() !== "") readLine(state, patterns, line, headings.get(line.number));
     // コードの行は覆って読まないが、開いている節の中身ではある。節の最後にコードブロックがあっても、範囲をそこまで伸ばす。
     else if (input.source.slice(line.start, line.start + line.text.length).trim() !== "") extend(state, line.start + line.text.length);
   });
-  return freeze(doc);
+  const tree = freeze(doc);
+  const relative = input.profile?.relative;
+  return relative === undefined ? tree : resolveRelative(tree, relative.implicitFirst);
 };

package/src/structure/cite.ts

@@ -100,7 +100,9 @@ export const checkCitations = (source: string, tree: StructureNode, citations: r
   const whole = normalize(source);
   const starts = lineStarts(source);
   return citations.map((citation): CitationResult => {
-    const candidates = byAddress.get(citation.address) ?? [];
+    // 第 1 項に番号の無い書き方では、「12.1」は第12条そのもの。参照の fallback と同じに読む。
+    const firstParagraph = citation.address.endsWith(".1") ? byAddress.get(citation.address.slice(0, -2)) : undefined;
+    const candidates = byAddress.get(citation.address) ?? firstParagraph ?? [];
     const first = candidates[0];
     if (first === undefined) return { citation, status: "missing-address" };
     const key = normalize(citation.quote).text;

package/src/structure/issues.ts

@@ -34,30 +34,57 @@ const resolves = (node: StructureNode, addresses: ReadonlySet<string>): boolean
 
 /**
  * 参照の番地が木に無い。他の文書の名前が付いた参照（民法第709条、Section 9 of the Master Agreement）は引かない。
- * 番号付きのまとまりを 1 つも持たない文書も見ない。他の文書を指しているだけかもしれない。
+ * 条を 1 つも持たない文書も見ない。他の文書を指しているだけかもしれない。
  */
 export const danglingReferences = (tree: StructureNode): StructureIssue[] => {
   const nodes = inDocumentOrder(tree);
+  // 参照は条を指す。条を一つも持たない文書（契約書に付ける承諾書のひな形など）の「契約書第6条」は、別の文書の条。
+  if (!nodes.some((node) => node.kind === "article")) return [];
   const addresses = new Set(nodes.filter((node) => NUMBERED.includes(node.kind)).map((node) => node.address));
-  if (addresses.size === 0) return [];
+  // Section で組んだ法令が "Articles 13 to 21 of the UK GDPR" と別の文書の Article を名指ししていれば、名の無い "Article 6(3)" もそちら。
+  // 名指しがあれば、名の無い "Article 9" が書き間違いか向こうの条かは区別できないので黙る。名指しが無い文書では報告する。
+  const numbering = (node: StructureNode): unknown => node.attrs["numbering"];
+  const numberings = new Set(nodes.flatMap((node) => (node.kind === "article" && node.numbering !== undefined ? [node.numbering] : [])));
+  const citedElsewhere = new Set(nodes.filter((node) => node.kind === "reference" && node.attrs["document"] !== undefined).map(numbering));
+  const otherNumbering = (node: StructureNode): boolean =>
+    numberings.size > 0 && typeof numbering(node) === "string" && !numberings.has(String(numbering(node))) && citedElsewhere.has(numbering(node));
   return nodes
-    .filter((node) => node.kind === "reference" && node.attrs["document"] === undefined)
+    .filter((node) => node.kind === "reference" && node.attrs["document"] === undefined && !otherNumbering(node))
     .filter((node) => !resolves(node, addresses))
     .map((node) => ({ offset: node.span.start, values: { label: textOf(node, "label"), target: textOf(node, "target") } }));
 };
 
-/** 同じ語の二度目以降の定義。どちらが正しいかは決めず、両方の場所を示す。 */
+type Definition = { readonly node: StructureNode; readonly article: string };
+
+/** 定義を文書の順に、それが置かれた条の番地と一緒に並べる。範囲を限った定義は、その条の中でだけ比べるため。 */
+const definitionsInOrder = (tree: StructureNode): Definition[] => {
+  const found: Definition[] = [];
+  const pending: Definition[] = [{ node: tree, article: "" }];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current === undefined) break;
+    if (current.node.kind === "definition") found.push(current);
+    const article = current.node.kind === "article" ? current.node.address : current.article;
+    [...current.node.children].reverse().forEach((child) => pending.push({ node: child, article }));
+  }
+  return found;
+};
+
+/**
+ * 同じ語の二度目以降の定義。どちらが正しいかは決めず、両方の場所を示す。
+ * 範囲を限った定義（この条において「X」とは）は、同じ条の中でだけ比べる。別の条で定義し直すのは正しい書き方。
+ */
 export const duplicateDefinitions = (tree: StructureNode): StructureIssue[] => {
   const first = new Map<string, StructureNode>();
-  return inDocumentOrder(tree)
-    .filter((node) => node.kind === "definition")
-    .flatMap((node) => {
-      const term = textOf(node, "term");
-      const earlier = first.get(term);
-      if (earlier === undefined) {
-        first.set(term, node);
-        return [];
-      }
-      return [{ offset: node.span.start, values: { term, first: earlier.line } }];
-    });
+  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 earlier = first.get(key);
+    if (earlier === undefined) {
+      first.set(key, node);
+      return [];
+    }
+    return [{ offset: node.span.start, values: { term, first: earlier.line } }];
+  });
 };

package/src/structure/numbering.ts

@@ -3,17 +3,21 @@ import { inDocumentOrder, type StructureIssue } from "./issues.ts";
 
 const labelOf = (node: StructureNode): string => String(node.attrs["label"] ?? node.address);
 
-type Ordered = { readonly node: StructureNode; readonly ordinal: number };
+type Ordered = { readonly node: StructureNode; readonly ordinal: number; readonly last: number };
 
-/** 同じ親の子のうち、番号の付いたものを種類ごとに分ける。条と項は別の並び。 */
+/**
+ * 同じ親の子のうち、番号の付いたものを種類と深さごとに分ける。条と項は別の並び、項と号も別の並び。
+ * 法令の第 1 項は番号が無いので、その号（一、二）と第 2 項（２）は同じ条の直下に並ぶ。深さで分けないと「二の次が２」に見える。
+ */
 const sequencesOf = (parent: StructureNode): Ordered[][] => {
   const groups = new Map<string, Ordered[]>();
   parent.children.forEach((node) => {
     if (node.ordinal === undefined) return;
+    const key = `${node.kind}/${String(node.level ?? "")}`;
     // 配列を作り直さずに足す。条が何千もある法令で二乗にしない。
-    const group = groups.get(node.kind) ?? [];
-    group.push({ node, ordinal: node.ordinal });
-    groups.set(node.kind, group);
+    const group = groups.get(key) ?? [];
+    group.push({ node, ordinal: node.ordinal, last: node.ordinalTo ?? node.ordinal });
+    groups.set(key, group);
   });
   return [...groups.values()];
 };
@@ -23,11 +27,12 @@ const breaksIn = (sequence: readonly Ordered[]): StructureIssue[] =>
   sequence.flatMap((current, index) => {
     const previous = sequence[index - 1];
     // 1 に戻ったら新しい並び。一つの条に (a)(b) の箇条書きが二つある、附則が第1条から振り直す、のどちらも誤りではない。
-    if (previous === undefined || current.ordinal === previous.ordinal + 1 || current.ordinal === 1) return [];
+    // 範囲をまとめた行（第四十三条から第五十五条まで）の次は、範囲の最後から数える。
+    if (previous === undefined || current.ordinal === previous.last + 1 || current.ordinal === 1) return [];
     return [
       {
         offset: current.node.span.start,
-        values: { previous: labelOf(previous.node), label: labelOf(current.node), expected: previous.ordinal + 1, found: current.ordinal },
+        values: { previous: labelOf(previous.node), label: labelOf(current.node), expected: previous.last + 1, found: current.ordinal },
       },
     ];
   });

package/src/structure/of.ts

@@ -1,8 +1,14 @@
 import { markdownOutline } from "../document.ts";
-import type { StructureNode, StructurePatterns } from "../plugin.ts";
+import type { DocumentProfile, StructureNode, StructurePatterns } from "../plugin.ts";
 import { buildTree, NO_OUTLINE } from "./build.ts";
 
-export type SourceInput = { readonly path: string; readonly source: string; readonly language: string; readonly markdown: boolean };
+export type SourceInput = {
+  readonly path: string;
+  readonly source: string;
+  readonly language: string;
+  readonly markdown: boolean;
+  readonly profile?: DocumentProfile | undefined;
+};
 
 /**
  * 文字列から木を作る。Markdown なら見出しとコードの範囲を先に取る。
@@ -10,6 +16,12 @@ export type SourceInput = { readonly path: string; readonly source: string; read
  */
 export const buildStructure = (input: SourceInput, patterns: StructurePatterns): StructureNode =>
   buildTree(
-    { path: input.path, source: input.source, language: input.language, outline: input.markdown ? markdownOutline(input.source) : NO_OUTLINE },
+    {
+      path: input.path,
+      source: input.source,
+      language: input.language,
+      outline: input.markdown ? markdownOutline(input.source) : NO_OUTLINE,
+      profile: input.profile,
+    },
     patterns,
   );

package/src/structure/relative-find.ts

@@ -0,0 +1,224 @@
+import type { DocumentProfile, Mention, RelativeVocabulary, Span } from "../plugin.ts";
+
+/**
+ * 前条・次項・同号・本条・前各項・前二項・前条第二項、条を書かない「第一項」を行の中から探す。語は文書の種類（profiles/*.yaml）が決める。
+ * ここでは番地を決めず、何をどれだけ指すかだけを attrs に残す。番地は木ができてから relative-resolve.ts が決める。
+ */
+type RelativeWay = "before" | "after" | "same" | "current" | "continue";
+
+type NumberReader = (text: string) => number | undefined;
+
+const escape = (word: string): string => word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+const oneOf = (words: readonly string[]): string => (words.length === 0 ? "(?!)" : words.map(escape).join("|"));
+
+type Compiled = {
+  readonly named: RegExp;
+  readonly bare: RegExp | undefined;
+  readonly suffix: RegExp;
+  readonly notAfter: RegExp | undefined;
+  readonly joins: RegExp;
+  readonly ways: ReadonlyMap<string, RelativeWay>;
+};
+
+const waysOf = (vocabulary: RelativeVocabulary): Map<string, RelativeWay> =>
+  new Map<string, RelativeWay>([
+    ...vocabulary.before.map((word): [string, RelativeWay] => [word, "before"]),
+    ...vocabulary.after.map((word): [string, RelativeWay] => [word, "after"]),
+    ...vocabulary.same.map((word): [string, RelativeWay] => [word, "same"]),
+    ...vocabulary.current.map((word): [string, RelativeWay] => [word, "current"]),
+  ]);
+
+/** 後ろの決まり: 番地の並びと同じく、つなぎの語を挟んで address_end。「前条件」の「前条」を参照にしない。 */
+const endOf = (profile: DocumentProfile): string => {
+  const connectives = profile.connectives.length === 0 ? "" : `(?:${oneOf(profile.connectives)})*`;
+  return profile.addressEnd === undefined ? "" : `(?=${connectives}(?:${profile.addressEnd}))`;
+};
+
+const compile = (profile: DocumentProfile, vocabulary: RelativeVocabulary): Compiled => {
+  const units = oneOf(Object.keys(vocabulary.units));
+  const suffix = `${escape(vocabulary.suffixPrefix)}(?:${vocabulary.count})(?:${units})`;
+  const end = endOf(profile);
+  const start = vocabulary.notAfter === undefined ? "" : `(?<!${vocabulary.notAfter})`;
+  const way = oneOf([...vocabulary.before, ...vocabulary.after, ...vocabulary.same, ...vocabulary.current]);
+  const count = `${oneOf(vocabulary.every)}|${vocabulary.count}`;
+  const inside = `${escape(vocabulary.suffixPrefix)}(?:${vocabulary.count})(?:${oneOf(vocabulary.inside)})`;
+  return {
+    named: new RegExp(`${start}(?<way>${way})(?<count>${count})?(?<unit>${units})(?<suffix>(?:${suffix})*)${end}`, "gu"),
+    // 前の文字は見ない。語に続くもの（別表第一第一号）も見つけて、並びの続きを止めるのに使う。
+    bare: vocabulary.inside.length === 0 ? undefined : new RegExp(`(?<suffix>${inside}(?:${suffix})*)${end}`, "gu"),
+    suffix: new RegExp(`${escape(vocabulary.suffixPrefix)}(?<n>${vocabulary.count})(?<unit>${units})`, "gu"),
+    notAfter: vocabulary.notAfter === undefined ? undefined : new RegExp(`(?:${vocabulary.notAfter})$`, "u"),
+    joins: new RegExp(`(?:${[...vocabulary.joiners, ...profile.connectives.map(escape)].join("|") || "(?!)"})`, "gu"),
+    ways: waysOf(vocabulary),
+  };
+};
+
+const compiled = new WeakMap<DocumentProfile, Compiled>();
+
+/** 「第二項第三号」を「2:2,3:3」（深さ:番号）にする。読めない数があれば undefined。 */
+const suffixOf = (text: string, patterns: Compiled, vocabulary: RelativeVocabulary, number: NumberReader): string | undefined => {
+  const parts = [...text.matchAll(patterns.suffix)].map((match) => {
+    const value = number(match.groups?.["n"] ?? "");
+    const depth = vocabulary.units[match.groups?.["unit"] ?? ""];
+    return value === undefined || depth === undefined ? undefined : `${String(depth)}:${String(value)}`;
+  });
+  return parts.includes(undefined) ? undefined : parts.join(",");
+};
+
+/** 「各」は前の全部（0）、数が無ければ 1。 */
+const countOf = (count: string | undefined, vocabulary: RelativeVocabulary, number: NumberReader): number | undefined => {
+  if (count === undefined) return 1;
+  return vocabulary.every.includes(count) ? 0 : number(count);
+};
+
+type Substitution = NonNullable<RelativeVocabulary["substitution"]>;
+
+/** 文字と、その位置（UTF-16 の単位で）。絵文字のような 2 単位の文字も 1 文字として読む。 */
+const characters = (text: string): { readonly char: string; readonly at: number }[] => {
+  const found: { char: string; at: number }[] = [];
+  let at = 0;
+  for (const char of text) {
+    found.push({ char, at });
+    at += char.length;
+  }
+  return found;
+};
+
+/** 一番外側の括弧の範囲。閉じの無い開きは捨てる。 */
+const outerQuotes = (text: string, quote: Substitution): Span[] => {
+  const spans: Span[] = [];
+  const opens: number[] = [];
+  characters(text).forEach(({ char, at }) => {
+    if (char === quote.open) opens.push(at);
+    const start = char === quote.close ? opens.pop() : undefined;
+    if (start !== undefined && opens.length === 0) spans.push({ start, end: at + char.length });
+  });
+  return spans;
+};
+
+/** 読み替えの括弧（閉じの直後か開きの直前に目印があるもの）の範囲。 */
+const substitutionSpans = (text: string, quote: Substitution | undefined): Span[] =>
+  quote === undefined
+    ? []
+    : outerQuotes(text, quote).filter(
+        (span) => quote.after.some((marker) => text.startsWith(marker, span.end)) || quote.before.some((marker) => text.slice(0, span.start).endsWith(marker)),
+      );
+
+/** 閉じた括弧書きを内側から外す。 */
+const withoutAsides = (gap: string, aside: RelativeVocabulary["aside"]): string => {
+  if (aside === undefined) return gap;
+  const inner = new RegExp(`${escape(aside.open)}[^${escape(aside.open)}${escape(aside.close)}]*${escape(aside.close)}`, "gu");
+  const once = gap.replace(inner, "");
+  return once === gap ? gap : withoutAsides(once, aside);
+};
+
+/** あいだが、並びをつなぐもの・つなぎの語・閉じた括弧書き・空白だけか。 */
+const onlyJoins = (gap: string, patterns: Compiled, vocabulary: RelativeVocabulary): boolean =>
+  withoutAsides(gap, vocabulary.aside).replace(patterns.joins, "").trim() === "";
+
+const overlaps = (start: number, end: number, others: readonly Mention[]): boolean => others.some((other) => start < other.end && other.start < end);
+
+/** 行き先を決められない番地。並びの続きを止めるためだけに覚え、参照にはしない。 */
+const OPAQUE = "opaque";
+
+/** すぐ前が not_after に当たる（「別表第一」の「一」に続く「第一号」）。 */
+const glued = (text: string, start: number, patterns: Compiled): boolean => patterns.notAfter?.test(text.slice(0, start)) === true;
+
+type Bare = { readonly start: number; readonly end: number; readonly label: string; readonly suffix: string; readonly first: number };
+
+const bareCandidates = (text: string, patterns: Compiled, vocabulary: RelativeVocabulary, number: NumberReader): Bare[] =>
+  patterns.bare === undefined
+    ? []
+    : [...text.matchAll(patterns.bare)].flatMap((match) => {
+        const suffix = suffixOf(match.groups?.["suffix"] ?? "", patterns, vocabulary, number);
+        const first = Number(suffix?.split(":")[0]);
+        return suffix === undefined || !Number.isInteger(first)
+          ? []
+          : [{ start: match.index, end: match.index + match[0].length, label: match[0], suffix, first }];
+      });
+
+/** 並びの中での扱い: 前の参照の続きか、今いるところの中か、行き先を決められないか。 */
+type BareWay = { readonly way: string; readonly continues?: Mention | undefined };
+
+/** 並びの中での扱い: 前の参照の続きか、今いるところの中か、行き先を決められないか。続きなら、どの参照の続きか。 */
+const wayOfBare = (text: string, bare: Bare, known: readonly Mention[], patterns: Compiled, vocabulary: RelativeVocabulary): BareWay => {
+  if (glued(text, bare.start, patterns)) return { way: OPAQUE };
+  const depth = openAsides(text, bare.start, vocabulary).length;
+  const sameDepth = known.filter((other) => other.end <= bare.start && openAsides(text, other.end, vocabulary).length === depth);
+  const previous = sameDepth.toSorted((left, right) => left.end - right.end).at(-1);
+  const joined = previous !== undefined && onlyJoins(text.slice(previous.end, bare.start), patterns, vocabulary) ? previous : undefined;
+  const continues = joined ?? ownerOfAside(text, bare.start, known, vocabulary);
+  if (continues === undefined) return { way: "current" };
+  return continues.attrs["relative"] === OPAQUE ? { way: OPAQUE } : { way: "continue", continues };
+};
+
+/** at の位置で開いたままの括弧書きの開きの位置。並びは同じ深さの参照どうしでつながる。 */
+const openAsides = (text: string, at: number, vocabulary: RelativeVocabulary): number[] => {
+  const aside = vocabulary.aside;
+  const opens: number[] = [];
+  if (aside === undefined) return opens;
+  characters(text.slice(0, at)).forEach(({ char, at: position }) => {
+    if (char === aside.open) opens.push(position);
+    if (char === aside.close) opens.pop();
+  });
+  return opens;
+};
+
+/**
+ * 参照の直後に開いた括弧書きの中なら、その参照。「第二十七条（第四項を除き、第五項及び第六項の規定を…）」の番地は、どれも第二十七条の中。
+ */
+const ownerOfAside = (text: string, at: number, known: readonly Mention[], vocabulary: RelativeVocabulary): Mention | undefined => {
+  const open = openAsides(text, at, vocabulary).at(-1);
+  return open === undefined ? undefined : known.find((other) => other.end === open);
+};
+
+/**
+ * 条を書かない「第一項」。すぐ前の参照とのあいだがつなぎの語だけなら、その参照の続き（continue）。
+ * そうでなければ、書いた場所を含む一つ上のまとまり（current）の中。
+ */
+const bareMentions = (text: string, patterns: Compiled, vocabulary: RelativeVocabulary, number: NumberReader, before: readonly Mention[]): Mention[] => {
+  const found: Mention[] = [];
+  bareCandidates(text, patterns, vocabulary, number).forEach((bare) => {
+    const known = [...before, ...found];
+    if (overlaps(bare.start, bare.end, known)) return;
+    const { way, continues } = wayOfBare(text, bare, known, patterns, vocabulary);
+    // 条を書かない番地は、その一つ上（level）ではなく、書いた単位（level + 1）から名指しする。「第一項」は「同条」の行き先を変えない。
+    // continues は、続きの元の参照がどれだけ前から始まるか。木の中で、その参照を位置で引く。
+    const back = continues === undefined ? {} : { continues: bare.start - continues.start };
+    const attrs = { label: bare.label, relative: way, level: bare.first - 1, count: 1, suffix: bare.suffix, names: bare.first, ...back };
+    found.push({ start: bare.start, end: bare.end, attrs });
+  });
+  return found.filter((mention) => mention.attrs["relative"] !== OPAQUE);
+};
+
+const namedMentions = (text: string, patterns: Compiled, vocabulary: RelativeVocabulary, number: NumberReader): Mention[] =>
+  [...text.matchAll(patterns.named)].flatMap((match) => {
+    const groups = match.groups ?? {};
+    const way = patterns.ways.get(groups["way"] ?? "");
+    const level = vocabulary.units[groups["unit"] ?? ""];
+    const count = countOf(groups["count"], vocabulary, number);
+    const suffix = suffixOf(groups["suffix"] ?? "", patterns, vocabulary, number);
+    if (way === undefined || level === undefined || count === undefined || suffix === undefined) return [];
+    return [{ start: match.index, end: match.index + match[0].length, attrs: { label: match[0], relative: way, level, count, suffix } }];
+  });
+
+/** absolute は同じ行の番地を名指しした参照。条を書かない番地が、その続きかどうかを決めるのに使う。 */
+export const relativeMentions = (
+  text: string,
+  profile: DocumentProfile | undefined,
+  number: NumberReader | undefined,
+  absolute: readonly Mention[] = [],
+): Mention[] => {
+  const vocabulary = profile?.relative;
+  if (profile === undefined || vocabulary === undefined || number === undefined) return [];
+  if (!compiled.has(profile)) compiled.set(profile, compile(profile, vocabulary));
+  const patterns = compiled.get(profile);
+  if (patterns === undefined) return [];
+  const substituted = substitutionSpans(text, vocabulary.substitution);
+  const named = namedMentions(text, patterns, vocabulary, number);
+  const bare = bareMentions(text, patterns, vocabulary, number, [...absolute, ...named]);
+  return [...named, ...bare]
+    .filter((mention) => !substituted.some((span) => span.start <= mention.start && mention.start < span.end))
+    .sort((left, right) => left.start - right.start);
+};