chaffjs 0.8.0 → 0.10.0

package/src/structure/build.ts

@@ -1,9 +1,13 @@
 import type { Heading } from "../document.ts";
 import { atxHeadingText, headingText } from "../heading-text.ts";
+import { addressSpans } from "../address-chain.ts";
+import { relativeMentions, substitutedDocuments } 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";
+import { unnumberedUnit, type OpenUnit } from "./unnumbered.ts";
 
 /** 組み立て中の節点。できあがったら StructureNode に固める。 */
 type Draft = {
@@ -17,10 +21,11 @@ type Draft = {
   readonly ordinal?: number | undefined;
   readonly level?: number | undefined;
   readonly ordinalTo?: number | undefined;
+  readonly numbering?: string | undefined;
 };
 
 /** 開いている節点。rank の大きいものほど内側。 */
-type Frame = { readonly draft: Draft; readonly rank: number; readonly numbered?: NumberedLine | undefined };
+type Frame = { readonly draft: Draft; readonly rank: number; readonly numbered?: NumberedLine | undefined; readonly bodyOnLine?: boolean };
 
 /**
  * 見出しは深さ 1〜6 を rank にする。番号のまとまりは必ず見出しの内側に入るので、
@@ -32,6 +37,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 => ({
@@ -85,7 +97,7 @@ const headingAddress = (state: State, depth: number): string => {
  * 見出しに書いた番号（「## 第3条」）は、見出しの深さで入れ子にする。本文の番号は見出しの内側に入る。
  * 見出しの深さを捨てると、「## 第3条」の下の「### 詳細」が条の外に出てしまう。
  */
-const openNumbered = (state: State, line: Line, numbered: NumberedLine, headingDepth: number | undefined): void => {
+const openNumbered = (state: State, line: Line, numbered: NumberedLine, headingDepth: number | undefined, bodyOnLine: boolean): void => {
   const attrs = { label: numbered.label, ...(numbered.heading === "" ? {} : { heading: numbered.heading }) };
   const rank = headingDepth ?? NUMBERED_RANK + numbered.depth;
   // 番地は、自分と同じか内側を閉じてから決める。閉じる前だと、同じ深さの前の条を親と取り違える。
@@ -95,8 +107,9 @@ const openNumbered = (state: State, line: Line, numbered: NumberedLine, headingD
     ordinal: numbered.ordinal,
     level: numbered.depth,
     ordinalTo: numbered.ordinalTo,
+    numbering: numbered.numbering,
   };
-  open(state, { draft, rank, numbered });
+  open(state, { draft, rank, numbered, bodyOnLine });
 };
 
 const openSection = (state: State, line: Line, heading: Heading): void => {
@@ -104,11 +117,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) => substitutedDocuments(patterns.references(text), text, profile) },
+  {
+    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) ?? [] },
 ];
 
@@ -119,13 +151,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: [],
+    }),
   );
 };
 
@@ -145,6 +218,7 @@ const freeze = (draft: Draft): StructureNode => ({
   ...(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 はどちらも空。 */
@@ -152,7 +226,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> =>
@@ -175,14 +255,44 @@ 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 openUnits = (state: State): OpenUnit[] =>
+  state.stack.flatMap((frame) => (frame.numbered === undefined ? [] : [{ numbered: frame.numbered, bodyOnLine: frame.bodyOnLine === true }]));
+
+/** 言語の番号の読み方、文書の種類の番号を書かない単位、言語を問わない通し番号の順に読む。 */
+const numberedLine = (state: State, patterns: StructurePatterns, text: string, context: NumberingContext): NumberedLine | undefined =>
+  patterns.numbered(text, context) ?? unnumberedUnit(text, openUnits(state), state.profile?.unnumbered) ?? universalNumber(patterns, text, context);
+
+/** 番号の後ろが見出しでなく本文か。前の行から見出しが付く前の、行そのもので決める。 */
+const carriesBody = (found: NumberedLine | undefined): boolean => found !== undefined && found.heading === "" && found.rest !== "";
+
+/** 見出しの無い条のすぐ前の行が見出しだけの行なら、それを条の見出しにする。 */
+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 found = numberedLine(state, patterns, text, context);
+  const numbered = withCaption(state, line, found);
+  const caption = numbered === undefined && heading === undefined ? captionOf(state.profile, text) : undefined;
+  if (caption !== undefined) state.captions.set(line.number, caption);
   // 番号付きの見出しも見出しの通し番号を進める。進めないと、その下の「### 詳細」が前の見出しの番地を名乗る。
   if (numbered !== undefined && heading !== undefined) headingAddress(state, heading.depth);
-  if (numbered !== undefined) openNumbered(state, line, numbered, heading?.depth);
+  if (numbered !== undefined) openNumbered(state, line, numbered, heading?.depth, carriesBody(found));
   else if (heading !== undefined) openSection(state, line, heading);
   extend(state, line.start + line.text.length);
   // 番号付きの行は番号の後ろだけを読む。「第3条（支払）」の「第3条」を自分への参照として拾わない。
@@ -201,13 +311,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/date-order.ts

@@ -0,0 +1,44 @@
+import type { StructureIssue } from "./issues.ts";
+import { runsOf, type Line } from "./runs.ts";
+
+/**
+ * 日程として並べた日付の順番。箇条書きの続いた項目か、表の続いた行で、日付をちょうど一つ持つものを並びとして読む。
+ * 並びの向き（古い順か新しい順か）は多いほうで決め、それに逆らう一歩だけを言う。新しい順に並べた履歴は正しい並び。
+ * 向きが決まらない並び（上がりと下がりが同じ数）は何も言わない。逆らう一歩を言えるのは、日付が 4 つ以上の並びだけになる。
+ */
+export type DatedPoint = { readonly offset: number; readonly value: string };
+
+/** 並びとして比べられる日付の書き方。年月日、年月、月日は、同じ書き方どうしでしか比べない。 */
+const PRECISIONS = [/^\d{4}-\d{2}-\d{2}$/u, /^\d{4}-\d{2}$/u, /^\d{2}-\d{2}$/u];
+
+/** 行ごとの日付。ちょうど一つの行だけを並びに入れる。二つある行（期間）はどちらを並べたのか決められない。 */
+const datedLines = (run: readonly Line[], points: readonly DatedPoint[]): DatedPoint[] =>
+  run.flatMap((line) => {
+    const inside = points.filter((point) => point.offset >= line.start && point.offset <= line.end);
+    return inside.length === 1 && inside[0] !== undefined ? [inside[0]] : [];
+  });
+
+const samePrecision = (dated: readonly DatedPoint[]): boolean => PRECISIONS.some((pattern) => dated.every((point) => pattern.test(point.value)));
+
+/** 上がりが多ければ 1、下がりが多ければ -1、同じ数なら 0（向きを決めない）。 */
+const majorityOf = (up: number, down: number): number => Math.sign(up - down);
+
+/** 多いほうの向きに逆らう一歩。後ろの項目の日付を指す。 */
+const againstMajority = (dated: readonly DatedPoint[]): StructureIssue[] => {
+  const steps = dated
+    .slice(1)
+    .map((point, index) => ({ point, previous: dated[index], sign: Math.sign(point.value.localeCompare(dated[index]?.value ?? "")) }));
+  const up = steps.filter((step) => step.sign > 0).length;
+  const down = steps.filter((step) => step.sign < 0).length;
+  const majority = majorityOf(up, down);
+  if (majority === 0) return [];
+  return steps
+    .filter((step) => step.sign === -majority)
+    .map((step) => ({ offset: step.point.offset, values: { date: step.point.value, previous: step.previous?.value ?? "" } }));
+};
+
+export const dateOrderBreaks = (source: string, points: readonly DatedPoint[]): StructureIssue[] =>
+  runsOf(source).flatMap((run) => {
+    const dated = datedLines(run, points);
+    return samePrecision(dated) ? againstMajority(dated) : [];
+  });

package/src/structure/issues.ts

@@ -41,8 +41,15 @@ export const danglingReferences = (tree: StructureNode): StructureIssue[] => {
   // 参照は条を指す。条を一つも持たない文書（契約書に付ける承諾書のひな形など）の「契約書第6条」は、別の文書の条。
   if (!nodes.some((node) => node.kind === "article")) return [];
   const addresses = new Set(nodes.filter((node) => NUMBERED.includes(node.kind)).map((node) => node.address));
+  // 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") } }));
 };
@@ -71,7 +78,8 @@ export const duplicateDefinitions = (tree: StructureNode): StructureIssue[] => {
   const first = new Map<string, StructureNode>();
   return definitionsInOrder(tree).flatMap(({ node, article }) => {
     const term = textOf(node, "term");
-    const key = node.attrs["scope"] === "local" ? `${article}\u0000${term}` : 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);

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,237 @@
+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)),
+      );
+
+/** 読み替えの括弧の中の、文書を名指ししていない参照に、読み替える先の文書の名前を付ける。 */
+export const substitutedDocuments = (mentions: readonly Mention[], text: string, profile: DocumentProfile | undefined): readonly Mention[] => {
+  const quote = profile?.relative?.substitution;
+  const document = quote?.document;
+  if (document === undefined) return mentions;
+  const spans = substitutionSpans(text, quote);
+  return mentions.map((mention) =>
+    mention.attrs["document"] === undefined && spans.some((span) => span.start <= mention.start && mention.start < span.end)
+      ? { ...mention, attrs: { ...mention.attrs, document } }
+      : mention,
+  );
+};
+
+/** 閉じた括弧書きを内側から外す。 */
+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);
+};