chaffjs 0.8.0 → 0.9.0

package/src/profile/for-file.ts

@@ -0,0 +1,11 @@
+import { applyByPath } from "../config/by-path.ts";
+import type { Config } from "../config/load.ts";
+import type { DocumentProfile } from "../plugin.ts";
+import { loadProfiles } from "./load.ts";
+import { chooseProfile } from "./select.ts";
+
+type ProfileSettings = Pick<Config, "profile" | "byPath" | "baseDir">;
+
+/** 1 ファイルの文書の種類。by_path、chaff.yaml、内容の順に選ぶ。 */
+export const profileFor = (config: ProfileSettings, path: string, source: string, language: string): DocumentProfile | undefined =>
+  chooseProfile(loadProfiles(), { byPath: applyByPath(config.byPath, config.baseDir, path).profile, config: config.profile, source, language })?.profile;

package/src/profile/load.ts

@@ -0,0 +1,26 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
+import { parseProfile, type ProfileDefinition } from "./parse.ts";
+
+const PROFILES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "profiles");
+
+const loaded: { value: readonly ProfileDefinition[] | undefined } = { value: undefined };
+
+/** 同梱の profiles/*.yaml。一度だけ読む。 */
+export const loadProfiles = (): readonly ProfileDefinition[] => {
+  loaded.value ??= readdirSync(PROFILES_DIR)
+    .filter((file) => file.endsWith(".yaml"))
+    .sort((left, right) => left.localeCompare(right))
+    .flatMap((file) => {
+      const path = join(PROFILES_DIR, file);
+      try {
+        const definition = parseProfile(parse(readFileSync(path, "utf8")));
+        return definition === undefined ? [] : [definition];
+      } catch (error) {
+        throw new Error(`cannot read the profile ${path}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+      }
+    });
+  return loaded.value;
+};

package/src/profile/parse.ts

@@ -0,0 +1,106 @@
+import type { DocumentProfile, RelativeVocabulary } from "../plugin.ts";
+
+/** profiles/*.yaml を一つ読んだもの。言語ごとの中身と、内容から選ぶための形を持つ。 */
+export type ProfileDefinition = {
+  readonly id: string;
+  readonly name: Readonly<Record<string, string>>;
+  readonly detect: Readonly<Record<string, ProfileDetect>>;
+  readonly languages: Readonly<Record<string, DocumentProfile>>;
+};
+
+/** この形の行が minLines 行以上あれば、その種類の文書として読む。 */
+type ProfileDetect = { readonly line: string; readonly minLines: number };
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const strings = (value: unknown): string[] => (Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === "string" && entry !== "") : []);
+
+const texts = (value: unknown): Record<string, string> =>
+  isRecord(value) ? Object.fromEntries(Object.entries(value).filter((entry): entry is [string, string] => typeof entry[1] === "string")) : {};
+
+/** 空でない文字列だけ。空の正規表現は何にでも当たる。 */
+const text = (value: unknown): string | undefined => (typeof value === "string" && value !== "" ? value : undefined);
+
+const detectOf = (value: unknown): ProfileDetect | undefined => {
+  if (!isRecord(value) || typeof value["line"] !== "string") return undefined;
+  const minLines = value["min_lines"];
+  return { line: value["line"], minLines: typeof minLines === "number" && minLines > 0 ? minLines : 1 };
+};
+
+const unitsOf = (value: unknown): Record<string, number> =>
+  isRecord(value) ? Object.fromEntries(Object.entries(value).filter((entry): entry is [string, number] => entry[0] !== "" && Number.isInteger(entry[1]))) : {};
+
+const asideOf = (value: unknown): RelativeVocabulary["aside"] => {
+  if (!isRecord(value)) return undefined;
+  const [open, close] = [text(value["open"]), text(value["close"])];
+  return open === undefined || close === undefined ? undefined : { open, close };
+};
+
+/** 括弧の開き・閉じと、目印が一つも無ければ読まない。 */
+const substitutionOf = (value: unknown): RelativeVocabulary["substitution"] => {
+  if (!isRecord(value)) return undefined;
+  const [open, close] = [text(value["open"]), text(value["close"])];
+  const [after, before] = [strings(value["after"]), strings(value["before"])];
+  return open === undefined || close === undefined || after.length + before.length === 0 ? undefined : { open, close, after, before };
+};
+
+/** 単位が一つも無ければ読まない。何を指すのか決められない。 */
+const relativeOf = (value: unknown): RelativeVocabulary | undefined => {
+  if (!isRecord(value)) return undefined;
+  const units = unitsOf(value["units"]);
+  if (Object.keys(units).length === 0) return undefined;
+  return {
+    before: strings(value["before"]),
+    after: strings(value["after"]),
+    same: strings(value["same"]),
+    current: strings(value["current"]),
+    every: strings(value["every"]),
+    count: text(value["count"]) ?? "(?!)",
+    units,
+    suffixPrefix: text(value["suffix_prefix"]) ?? "",
+    implicitFirst: typeof value["implicit_first"] === "string" ? units[value["implicit_first"]] : undefined,
+    notAfter: text(value["not_after"]),
+    substitution: substitutionOf(value["substitution"]),
+    inside: strings(value["inside"]).filter((unit) => units[unit] !== undefined),
+    joiners: strings(value["joiners"]),
+    aside: asideOf(value["aside"]),
+  };
+};
+
+const LANGUAGE_KEYS = new Set(["id", "name", "why", "detect"]);
+
+const languagesOf = (id: string, raw: Record<string, unknown>): Record<string, DocumentProfile> =>
+  Object.fromEntries(
+    Object.entries(raw)
+      .filter(([key, value]) => !LANGUAGE_KEYS.has(key) && isRecord(value))
+      .map(([language, value]) => {
+        const section = isRecord(value) ? value : {};
+        const addressEnd = text(section["address_end"]);
+        const caption = text(section["caption"]);
+        const relative = relativeOf(section["relative"]);
+        return [language, { id, addresses: strings(section["addresses"]), connectives: strings(section["connectives"]), addressEnd, caption, relative }];
+      }),
+  );
+
+/** id の無いものは読まない。どの設定から選ばれたのか言えなくなるため。 */
+export const parseProfile = (raw: unknown): ProfileDefinition | undefined => {
+  if (!isRecord(raw) || typeof raw["id"] !== "string" || raw["id"] === "") return undefined;
+  const id = raw["id"];
+  const detect = isRecord(raw["detect"])
+    ? Object.fromEntries(
+        Object.entries(raw["detect"]).flatMap(([language, value]) => {
+          const found = detectOf(value);
+          return found === undefined ? [] : [[language, found] as const];
+        }),
+      )
+    : {};
+  return { id, name: texts(raw["name"]), detect, languages: languagesOf(id, raw) };
+};
+
+/** 行頭から数える。source 全体に m フラグで当てれば、行ごとに分けずに数えられる。 */
+export const detected = (definition: ProfileDefinition, source: string, language: string): boolean => {
+  const detect = definition.detect[language];
+  if (detect === undefined) return false;
+  const count = [...source.matchAll(new RegExp(detect.line, "gmu"))].length;
+  return count >= detect.minLines;
+};

package/src/profile/select.ts

@@ -0,0 +1,35 @@
+import type { DocumentProfile } from "../plugin.ts";
+import { detected, type ProfileDefinition } from "./parse.ts";
+
+/** 設定で書いた「使わない」。内容から選ぶのも止める。 */
+export const NO_PROFILE = "none";
+
+type ProfileSource = "by-path" | "config" | "content";
+
+export type ChosenProfile = { readonly profile: DocumentProfile; readonly from: ProfileSource };
+
+export type ProfileRequest = {
+  readonly byPath: string | undefined;
+  readonly config: string | undefined;
+  readonly source: string;
+  readonly language: string;
+};
+
+const named = (definitions: readonly ProfileDefinition[], id: string, language: string): DocumentProfile | undefined =>
+  definitions.find((definition) => definition.id === id)?.languages[language];
+
+/**
+ * 強いものから: by_path、chaff.yaml の profile、内容。どれかが none と書けばそこで止め、内容からも選ばない。
+ * 名前で選んだ種類にその言語の中身が無ければ選ばない。黙って別の種類にしない。
+ */
+export const chooseProfile = (definitions: readonly ProfileDefinition[], request: ProfileRequest): ChosenProfile | undefined => {
+  const written = request.byPath ?? request.config;
+  if (written === NO_PROFILE) return undefined;
+  if (written !== undefined) {
+    const profile = named(definitions, written, request.language);
+    return profile === undefined ? undefined : { profile, from: request.byPath === undefined ? "config" : "by-path" };
+  }
+  const found = definitions.find((definition) => detected(definition, request.source, request.language));
+  const profile = found?.languages[request.language];
+  return profile === undefined ? undefined : { profile, from: "content" };
+};

package/src/reasons.ts

@@ -9,6 +9,7 @@ export type Reasons = {
   readonly experimental: string;
   readonly turnedOff: string;
   readonly noStructure: (language: string) => string;
+  readonly unreadStructure: (clauses: number, units: number) => string;
   readonly noDetector: (name: string) => string;
   readonly noLexicon: (language: string, list: string) => string;
 };
@@ -27,6 +28,8 @@ export const REASONS: Texts<Reasons> = {
     experimental: "まだ試験中のため",
     turnedOff: "設定で止めているため",
     noStructure: (language) => `${language} のパッケージは文書の構造を読めないため`,
+    unreadStructure: (clauses, units) =>
+      `条項の番号が本文に ${String(clauses)} 個あるのに、番号として読めたのは ${String(units)} 個のため（深い字下げや、行が本文につながった文書）`,
     noDetector: (name) => `検出器 ${name} がないため`,
     noLexicon: (language, list) => `${language} の語彙表 ${list} が無いため`,
   },
@@ -38,6 +41,8 @@ export const REASONS: Texts<Reasons> = {
     experimental: "still experimental",
     turnedOff: "turned off in the settings",
     noStructure: (language) => `the ${language} package cannot read a document's structure`,
+    unreadStructure: (clauses, units) =>
+      `the text has ${String(clauses)} clause numbers but only ${String(units)} were read as numbered lines (deep indents, or lines run into the text)`,
     noDetector: (name) => `no detector named ${name}`,
     noLexicon: (language, list) => `the ${language} package has no word list ${list}`,
   },

package/src/run.ts

@@ -3,6 +3,8 @@ import { resolve } from "./levels.ts";
 import type { AdapterNeeds, Finding, Level, ProseDocument, RuleDefinition } from "./plugin.ts";
 import { lineStarts, placeOf } from "./position.ts";
 import { REASONS, type Reasons } from "./reasons.ts";
+import { unreadStructure, type Unread } from "./structure/unread.ts";
+import { isMarkdownPath } from "./structure/markdown-path.ts";
 import { uiLanguageOf } from "./ui.ts";
 
 export type Skipped = { readonly rule: string; readonly why: string };
@@ -26,6 +28,27 @@ const levelFor = (rule: RuleDefinition, settings: Settings, experimental: boolea
 
 const reasonsFor = (doc: ProseDocument): Reasons => REASONS[uiLanguageOf(doc.language)];
 
+/**
+ * 構造の rule が動けない理由。木を作れない言語か、番号の行を読めなかった文書。
+ * 読めなかった文書で「参照先が無い」が 0 件なのは、確かめた結果ではないので、読めなかったと言う。
+ */
+const treeProblem = (doc: ProseDocument): string | undefined => {
+  if (doc.structure === undefined) return reasonsFor(doc).noStructure(doc.language);
+  const unread = unreadOf(doc);
+  return unread === undefined ? undefined : reasonsFor(doc).unreadStructure(unread.clauses, unread.units);
+};
+
+/** 木が読んだのと同じ本文。Markdown はコードを覆ったもの、.txt はそのまま（.txt の字下げはコードではない）。 */
+const textTheTreeRead = (doc: ProseDocument): string => (isMarkdownPath(doc.path) ? (doc.prose ?? doc.source) : doc.source);
+
+const unreadByDocument = new WeakMap<ProseDocument, Unread | undefined>();
+
+/** 文書ごとに一度だけ数える。構造の rule が三つあっても、本文を三度なめない。 */
+const unreadOf = (doc: ProseDocument): Unread | undefined => {
+  if (!unreadByDocument.has(doc)) unreadByDocument.set(doc, doc.structure === undefined ? undefined : unreadStructure(textTheTreeRead(doc), doc.structure));
+  return unreadByDocument.get(doc);
+};
+
 /** 知らない要求は満たされていないものとして扱う。黙って無視すると、要求なしで動いてしまう。 */
 const has = (capabilities: ProseDocument["capabilities"], need: string): boolean => {
   if (need === "pos") return capabilities.pos;
@@ -135,9 +158,8 @@ export const runRules = (
       if (noTags !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTags }] };
       // 木は capability ではなく、adapter が structure を持つかで決まる。持たない言語で動かすと「参照先が無い」が 0 件に見える。
       // 段階を見た後で聞く。doc.structure は触れたときに木を作るので、止めている rule のために作らない。
-      if (rule.requires.includes("structure") && doc.structure === undefined) {
-        return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: reasonsFor(doc).noStructure(doc.language) }] };
-      }
+      const noTree = rule.requires.includes("structure") ? treeProblem(doc) : undefined;
+      if (noTree !== undefined) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: noTree }] };
       // 複合シグナルは二段目で扱う。一段目では「検出器が無い」と言わせない。
       if (rule.from.length > 0) return acc;
       const detector = DETECTORS[rule.how_to_find];

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";
 
@@ -17,6 +20,7 @@ type Draft = {
   readonly ordinal?: number | undefined;
   readonly level?: number | undefined;
   readonly ordinalTo?: number | undefined;
+  readonly numbering?: string | undefined;
 };
 
 /** 開いている節点。rank の大きいものほど内側。 */
@@ -32,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 => ({
@@ -95,6 +106,7 @@ 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 });
 };
@@ -104,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) ?? [] },
 ];
 
@@ -119,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: [],
+    }),
   );
 };
 
@@ -145,6 +217,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 +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> =>
@@ -175,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);
@@ -201,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/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,
   );