chaffjs 0.17.0 → 0.18.0

package/src/structure/relative-find.ts

@@ -1,4 +1,7 @@
 import type { DocumentProfile, Mention, RelativeVocabulary, Span } from "../plugin.ts";
+import { isOneCharacter, withoutClosedPairs } from "./closed-pairs.ts";
+import { asideDepth, characters, type AsideDepth } from "./aside-depth.ts";
+import { knownMentions, type KnownMentions } from "./known-mentions.ts";
 
 /**
  * 前条・次項・同号・本条・前各項・前二項・前条第二項、条を書かない「第一項」を行の中から探す。語は文書の種類（profiles/*.yaml）が決める。
@@ -74,17 +77,6 @@ const countOf = (count: string | undefined, vocabulary: RelativeVocabulary, numb
 
 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[] = [];
@@ -118,20 +110,23 @@ export const substitutedDocuments = (mentions: readonly Mention[], text: string,
   );
 };
 
-/** 閉じた括弧書きを内側から外す。 */
+/**
+ * 閉じた括弧書きを内側から外す。開きと閉じが 1 字ずつなら、組ごと 1 度で外す（深い入れ子でも本文を読み直さない）。
+ * 2 字以上の括弧は、内側の組を外すのを変わらなくなるまで繰り返す。
+ */
 const withoutAsides = (gap: string, aside: RelativeVocabulary["aside"]): string => {
   if (aside === undefined) return gap;
+  if (isOneCharacter(aside.open) && isOneCharacter(aside.close)) return withoutClosedPairs(gap, aside.open, aside.close);
   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);
+  let rest = gap;
+  for (let once = rest.replace(inner, ""); once !== rest; once = rest.replace(inner, "")) rest = once;
+  return rest;
 };
 
 /** あいだが、並びをつなぐもの・つなぎの語・閉じた括弧書き・空白だけか。 */
 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";
 
@@ -154,53 +149,45 @@ const bareCandidates = (text: string, patterns: Compiled, vocabulary: RelativeVo
 /** 並びの中での扱い: 前の参照の続きか、今いるところの中か、行き先を決められないか。 */
 type BareWay = { readonly way: string; readonly continues?: Mention | undefined };
 
-/** 並びの中での扱い: 前の参照の続きか、今いるところの中か、行き先を決められないか。続きなら、どの参照の続きか。 */
-const wayOfBare = (text: string, bare: Bare, known: readonly Mention[], patterns: Compiled, vocabulary: RelativeVocabulary): BareWay => {
+/** 本文と、その括弧書きの深さ。並びは同じ深さの参照どうしでつながる。 */
+type Line = { readonly text: string; readonly asides: AsideDepth };
+
+/**
+ * 並びの中での扱い: 前の参照の続きか、今いるところの中か、行き先を決められないか。続きなら、どの参照の続きか。
+ * 前の参照とつながらなくても、参照の直後に開いた括弧書きの中なら、その参照の続き。
+ * 「第二十七条（第四項を除き、第五項及び第六項の規定を…）」の番地は、どれも第二十七条の中。
+ */
+const wayOfBare = (line: Line, bare: Bare, known: KnownMentions, patterns: Compiled, vocabulary: RelativeVocabulary): BareWay => {
+  const { text, asides } = line;
   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 previous = known.previous(bare.start, asides.depth(bare.start));
   const joined = previous !== undefined && onlyJoins(text.slice(previous.end, bare.start), patterns, vocabulary) ? previous : undefined;
-  const continues = joined ?? ownerOfAside(text, bare.start, known, vocabulary);
+  const open = asides.innermost(bare.start);
+  const continues = joined ?? (open === undefined ? undefined : known.endingAt(open));
   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 candidates = bareCandidates(text, patterns, vocabulary, number);
+  if (candidates.length === 0) return [];
+  const line = { text, asides: asideDepth(text, vocabulary.aside) };
+  const known = knownMentions(before, line.asides.depth);
   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);
+  candidates.forEach((bare) => {
+    if (known.overlaps(bare.start, bare.end)) return;
+    const { way, continues } = wayOfBare(line, 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 });
+    const mention = { start: bare.start, end: bare.end, attrs };
+    found.push(mention);
+    known.add(mention, line.asides.depth(mention.end));
   });
   return found.filter((mention) => mention.attrs["relative"] !== OPAQUE);
 };

package/src/structure/relative-resolve.ts

@@ -1,4 +1,5 @@
 import type { StructureNode } from "../plugin.ts";
+import { preOrder } from "../tree-walk.ts";
 
 /**
  * 相対の参照（relative-find.ts が見つけたもの）に番地を与える。木ができてからでないと「次条」は決まらないので、ここは木を読むだけの後段。
@@ -24,11 +25,18 @@ const placeOf = (node: StructureNode): Place | undefined =>
   NUMBERED.has(node.kind) && node.level !== undefined ? { address: node.address, level: node.level, range: node.ordinalTo !== undefined } : undefined;
 
 /** 番号の付いた子。Markdown の見出し（section）は番号の外なので、その中まで見る。 */
-const numberedChildren = (node: StructureNode, level: number): StructureNode[] =>
-  node.children.flatMap((child) => {
-    if (NUMBERED.has(child.kind)) return child.level === level ? [child] : [];
-    return child.kind === "section" ? numberedChildren(child, level) : [];
-  });
+const numberedChildren = (node: StructureNode, level: number): StructureNode[] => {
+  const found: StructureNode[] = [];
+  const pending = node.children.toReversed();
+  while (pending.length > 0) {
+    const child = pending.pop();
+    if (child === undefined) break;
+    if (NUMBERED.has(child.kind)) {
+      if (child.level === level) found.push(child);
+    } else if (child.kind === "section") child.children.toReversed().forEach((inner) => pending.push(inner));
+  }
+  return found;
+};
 
 type Context = {
   readonly articles: readonly Place[];
@@ -182,27 +190,65 @@ const resolveOne = (node: StructureNode, path: readonly StructureNode[], context
 
 const isRelative = (node: StructureNode): boolean => node.kind === "reference" && node.attrs["relative"] !== undefined;
 
-/** 文書の順に読み、参照ごとに「その前の参照」を覚える。 */
-const walk = (node: StructureNode, path: readonly StructureNode[], context: Context): StructureNode | undefined => {
-  if (isRelative(node)) {
-    const resolved = resolveOne(node, path, context);
-    if (resolved === undefined) return undefined;
-    const reference = lastOf(resolved);
-    context.byStart.set(node.span.start, reference);
-    remember(context, reference, Number(node.attrs["names"] ?? node.attrs["level"]));
-    return resolved;
-  }
-  if (node.kind === "reference") {
-    const reference = lastOf(node);
-    context.byStart.set(node.span.start, reference);
-    remember(context, reference, context.articleLevel ?? 0);
+/** 相対の参照に番地を決めて、その番地を覚える。決まらなければ木から外す（undefined）。 */
+const resolvedReference = (node: StructureNode, path: readonly StructureNode[], context: Context): StructureNode | undefined => {
+  const resolved = resolveOne(node, path, context);
+  if (resolved === undefined) return undefined;
+  const reference = lastOf(resolved);
+  context.byStart.set(node.span.start, reference);
+  remember(context, reference, Number(node.attrs["names"] ?? node.attrs["level"]));
+  return resolved;
+};
+
+/** 番地を名指した参照の番地を覚える。 */
+const noteReference = (node: StructureNode, context: Context): void => {
+  if (node.kind !== "reference") return;
+  const reference = lastOf(node);
+  context.byStart.set(node.span.start, reference);
+  remember(context, reference, context.articleLevel ?? 0);
+};
+
+/** 子を読んでいる節点。next は次に読む子。 */
+type Visit = { readonly node: StructureNode; readonly kept: StructureNode[]; next: number };
+
+/** 読み終えた節点を、残した子で作り直して親に渡す。親が無ければ（根なら）それを返す。 */
+const close = (visits: Visit[]): StructureNode | undefined => {
+  const visit = visits.pop();
+  if (visit === undefined) return undefined;
+  const rebuilt = { ...visit.node, children: visit.kept };
+  const parent = visits.at(-1);
+  if (parent === undefined) return rebuilt;
+  parent.kept.push(rebuilt);
+  return undefined;
+};
+
+/** 文書の順に読み、参照ごとに「その前の参照」を覚える。相対の参照は置き換えて、その中は読まない。 */
+const walk = (tree: StructureNode, context: Context): StructureNode | undefined => {
+  if (isRelative(tree)) return resolvedReference(tree, [], context);
+  noteReference(tree, context);
+  const visits: Visit[] = [{ node: tree, kept: [], next: 0 }];
+  while (visits.length > 0) {
+    const visit = visits.at(-1);
+    const child = visit?.node.children[visit.next];
+    if (visit === undefined || child === undefined) {
+      const root = close(visits);
+      if (root !== undefined) return root;
+      continue;
+    }
+    visit.next += 1;
+    if (isRelative(child)) {
+      const resolved = resolvedReference(
+        child,
+        visits.map((open) => open.node),
+        context,
+      );
+      if (resolved !== undefined) visit.kept.push(resolved);
+      continue;
+    }
+    noteReference(child, context);
+    visits.push({ node: child, kept: [], next: 0 });
   }
-  const inside = [...path, node];
-  const children = node.children.flatMap((child) => {
-    const kept = walk(child, inside, context);
-    return kept === undefined ? [] : [kept];
-  });
-  return { ...node, children };
+  return undefined;
 };
 
 const optional = (value: string | number | undefined): string | undefined => (value === undefined ? undefined : String(value));
@@ -213,12 +259,13 @@ const lastOf = (reference: StructureNode): Last => ({
   unitWord: optional(reference.attrs["unitWord"]),
 });
 
-const articlesOf = (node: StructureNode): Place[] => {
-  const place = node.kind === "article" ? placeOf(node) : undefined;
-  return [...(place === undefined ? [] : [place]), ...node.children.flatMap(articlesOf)];
-};
+const articlesOf = (root: StructureNode): Place[] =>
+  preOrder(root).flatMap((node) => {
+    const place = node.kind === "article" ? placeOf(node) : undefined;
+    return place === undefined ? [] : [place];
+  });
 
 export const resolveRelative = (tree: StructureNode, implicitLevel: number | undefined): StructureNode => {
   const articles = articlesOf(tree);
-  return walk(tree, [], { articles, articleLevel: articles[0]?.level, implicitLevel, last: new Map(), byStart: new Map() }) ?? tree;
+  return walk(tree, { articles, articleLevel: articles[0]?.level, implicitLevel, last: new Map(), byStart: new Map() }) ?? tree;
 };

package/src/structure/runs.ts

@@ -5,9 +5,9 @@
 type Kind = "list" | "table";
 
 const LIST_ITEM = /^[ \t]{0,12}(?:[-*+]|\d{1,3}[.)])[ \t]/u;
-const TABLE_ROW = /^[ \t]{0,12}\|/u;
+export const TABLE_ROW = /^[ \t]{0,12}\|/u;
 
-const TABLE_RULE = /^[ \t]{0,12}\|?[ \t]{0,4}:?-{3,}/u;
+export const TABLE_RULE = /^[ \t]{0,12}\|?[ \t]{0,4}:?-{3,}/u;
 const INDENT = /^[ \t]*/u;
 
 export type Line = { readonly start: number; readonly end: number; readonly kind: Kind | undefined; readonly indent: number; readonly rule: boolean };

package/src/structure/sexp.ts

@@ -20,9 +20,21 @@ const keywords = (node: StructureNode): string[] => [
  * 木を S 式にする。人と AI が読むための形で、JSON と同じ木から作る。
  * `(kind "番地" :key value ... 子)`。番地を持たない葉は番地を書かない。
  */
-export const toSexp = (node: StructureNode, indent = ""): string => {
-  const head = [node.kind, ...(node.address === "" ? [] : [quote(node.address)]), ...keywords(node)].join(" ");
-  if (node.children.length === 0) return `${indent}(${head})`;
-  const inner = node.children.map((child) => toSexp(child, `${indent}  `)).join("\n");
-  return `${indent}(${head}\n${inner})`;
+export const toSexp = (root: StructureNode, indent = ""): string => {
+  const lines: string[] = [];
+  // 1 行に 1 節点。節点を閉じる ")" は、その部分木の最後の行の後ろに付く。
+  const pending = [{ node: root, depth: 0, closing: false }];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    if (next === undefined) break;
+    if (next.closing) {
+      lines.push(`${lines.pop() ?? ""})`);
+      continue;
+    }
+    const head = [next.node.kind, ...(next.node.address === "" ? [] : [quote(next.node.address)]), ...keywords(next.node)].join(" ");
+    lines.push(`${indent}${"  ".repeat(next.depth)}(${head}`);
+    pending.push({ ...next, closing: true });
+    next.node.children.toReversed().forEach((child) => pending.push({ node: child, depth: next.depth + 1, closing: false }));
+  }
+  return lines.join("\n");
 };

package/src/structure/total.ts

@@ -27,7 +27,7 @@ type Cell = { readonly column: number; readonly unit: string };
 type Placed = Amount & Cell & { readonly cents: number | undefined };
 type Entry = { readonly label: boolean; readonly amounts: readonly Placed[] };
 
-const columnOf = (source: string, line: Line, offset: number): number => source.slice(line.start, offset).split(CELL_SEPARATOR).length - 1;
+export const columnOf = (source: string, line: Line, offset: number): number => source.slice(line.start, offset).split(CELL_SEPARATOR).length - 1;
 
 const isNegative = (source: string, line: Line, amount: Amount): boolean => {
   const before = source.slice(line.start, amount.offset);
@@ -48,7 +48,7 @@ const leadingText = (text: string): string =>
  */
 const AFTER_LABEL = /^[*_]*[ \t\u3000]*(?:$|[:：|（(]|[-−▲△$€£¥￥\p{N}])/u;
 
-const isTotalLabel = (text: string, labels: readonly string[]): boolean => {
+export const isTotalLabel = (text: string, labels: readonly string[]): boolean => {
   const lead = leadingText(text).toLowerCase();
   return labels.some((label) => lead.startsWith(label.toLowerCase()) && AFTER_LABEL.test(lead.slice(label.length)));
 };

package/src/structure/universal.ts

@@ -1,10 +1,11 @@
-import type { NumberedLine, NumberingContext } from "../plugin.ts";
+import type { NumberedLine, NumberingContext, StructurePatterns } from "../plugin.ts";
+import { numberInSentence } from "./number-in-sentence.ts";
 
 /**
  * 「4.2 設定」「3.1.4 Scope」のような通し番号。数字と点だけで書くので言語を問わない。
  * 各部分を 3 桁・深さを 6 までに抑え、後戻りが爆発しない形にしてある。
  */
-const DOTTED = /^[ \t]{0,3}(?<number>\d{1,3}(?:\.\d{1,3}){0,5})\.?[ \t\u3000]+(?<rest>\S.*)$/u;
+const DOTTED = /^[ \t]{0,3}(?<number>\d{1,3}(?:\.\d{1,3}){0,5})(?<closing>\.)?[ \t\u3000]+(?<rest>\S.*)$/u;
 
 /**
  * RFC のようなテキストの仕様書（Markdown でないもの）の章見出し「5.  Security Considerations」。Markdown では、行内のコードを伏せた空白が
@@ -17,16 +18,35 @@ const MAX_TITLE = 80;
 
 const isTopSection = (line: string, rest: string): boolean => TOP_SECTION.test(line) && rest.length <= MAX_TITLE && !SENTENCE_END.test(rest);
 
+/** closedByDot: 番号を点で閉じたか（「5. 」）。「1.5 万人」の 1.5 は閉じていない。 */
+type DottedLine = NumberedLine & { readonly closedByDot: boolean };
+
 /**
  * 本文の「1. 」は箇条書きで、見出しの「1. 」は章番号。点を含まない番号は、見出しの行か、テキストの章見出しの形でだけ読む。
  * 「4.2 」のように点を含むものは、.txt の仕様書でも見出しとして書かれるので本文でも読む。
  */
-export const dottedNumber = (line: string, context: NumberingContext, plainText = false): NumberedLine | undefined => {
+export const dottedNumber = (line: string, context: NumberingContext, plainText = false): DottedLine | undefined => {
   const groups = DOTTED.exec(line)?.groups;
   const number = groups?.["number"];
   if (number === undefined) return undefined;
   const depth = number.split(".").length;
   const rest = groups?.["rest"]?.trim() ?? "";
   if (depth < 2 && !context.isHeading && !(plainText && isTopSection(line, rest))) return undefined;
-  return { kind: "article", depth, number, absolute: true, label: number, heading: rest, rest, ordinal: Number(number.split(".").at(-1)) };
+  const closedByDot = groups?.["closing"] !== undefined;
+  return { kind: "article", depth, number, absolute: true, label: number, heading: rest, rest, ordinal: Number(number.split(".").at(-1)), closedByDot };
+};
+
+/**
+ * 番号の後ろが単位なら数量（「1.5 万人」「2.5 days」）。点で閉じた番号（「5. ページ自身の通信」「2. Days off」）は札で、
+ * 数量はそう書かないので、後ろに単位の語が来ても数量にしない。
+ */
+export const isAmount = (dotted: DottedLine, countedAfter: StructurePatterns["countedAfter"]): boolean =>
+  !dotted.closedByDot && countedAfter?.(dotted.number, dotted.rest) === true;
+
+/** 言語を問わない通し番号。後ろが単位なら数量、本文の文の続きなら文の中の数なので、番号にしない。 */
+export const universalNumber = (patterns: StructurePatterns, text: string, context: NumberingContext, plainText: boolean): NumberedLine | undefined => {
+  const dotted = dottedNumber(text, context, plainText);
+  if (dotted === undefined || isAmount(dotted, patterns.countedAfter)) return undefined;
+  const numbered = { number: dotted.number, rest: dotted.rest, isHeading: context.isHeading };
+  return numberInSentence(numbered, patterns.continuesSentence) ? undefined : dotted;
 };

package/src/structure/wrapped-tail.ts

@@ -1,22 +1,47 @@
 import type { Mention } from "../plugin.ts";
 
 /**
- * 参照を読む行と、その後ろにつないだ次の行。
+ * 参照を読む行と、その前後につないだ行。
  *
- * 72 桁で折り返す RFC は「Section 16.3.2\n   of [HTTP]」のように、参照と「どの文書の」を別の行に書く。行だけを読むと
- * 自分の文書の 16.3.2 に見える。改行と字下げは読み手には空白一つなので、そうつないだ文字列を言語の読み手に渡す。
- * 拾った参照は行の中にあるものだけを残す。次の行の参照は、次の行を読むときに拾う。位置は行の上のまま。
+ * 72 桁で折り返す RFC は「Section 16.3.2\n   of [HTTP]」「RFC 7657\n   (Sections 5.1 …)」のように、参照と「どの文書の」を別の行に書く。
+ * 行だけを読むと自分の文書の 16.3.2 に見える。改行と字下げは読み手には空白一つなので、そうつないだ文字列を言語の読み手に渡す。
+ * 拾った参照は行の中にあるものだけを残す。前後の行の参照は、その行を読むときに拾う。位置は行の上のまま。
+ * leadLength は text の先頭につないだ前の行の長さ（つなぎの空白を含む）。前の行をつながなければ無い。
  */
-export type WrappedLine = { readonly line: string; readonly text: string; readonly lineLength: number };
+export type WrappedLine = { readonly line: string; readonly text: string; readonly lineLength: number; readonly leadLength?: number };
 
-/** 見出しは次の行へ続かない。見出しの行か、次の行が無い・空なら、行だけ。 */
-export const wrappedLine = (text: string, onHeading: boolean, next: string | undefined): WrappedLine => {
+/**
+ * 前の行は末尾のこれだけを読む。文書の名前（「35 CFR」「RFC 7657」）は数語なので足りる。長く読むと前の行の参照
+ * （「Article 58 of the UK GDPR (powers),」）まで入り、その文書が次の行の括弧の中の参照に移る。
+ */
+export const LEAD_REACH = 24;
+
+/** 前の行の末尾。長ければ LEAD_REACH の内側の最初の空白から後ろにして、語の途中から始めない。空白が無ければ読まない。 */
+const leadOf = (previous: string | undefined): string => {
+  const trimmed = previous?.trim() ?? "";
+  if (trimmed.length <= LEAD_REACH) return trimmed;
+  const end = trimmed.slice(-LEAD_REACH);
+  const space = end.search(/\s/u);
+  return space === -1 ? "" : end.slice(space).trimStart();
+};
+
+/** 見出しは前後の行へ続かない。見出しの行か、前後の行が無い・空なら、その側はつながない。 */
+export const wrappedLine = (text: string, onHeading: boolean, next: string | undefined, previous?: string): WrappedLine => {
   const tail = onHeading ? "" : (next?.trim() ?? "");
-  if (tail === "") return { line: text, text, lineLength: text.length };
-  const kept = text.trimEnd();
-  return { line: text, text: `${kept} ${tail}`, lineLength: kept.length };
+  const lead = onHeading ? "" : leadOf(previous);
+  const kept = tail === "" ? text : text.trimEnd();
+  const joined = tail === "" ? text : `${kept} ${tail}`;
+  if (lead === "") return { line: text, text: joined, lineLength: kept.length };
+  // 全角どうしでも空白でつなぐ。詰めると、前の行の宛名（「…担当課」）が次の行の法令名（「構造改革特別区域法」）に付く。
+  const joint = `${lead} `;
+  return { line: text, text: `${joint}${joined}`, lineLength: kept.length, leadLength: joint.length };
 };
 
-/** 行の中で終わる参照だけ。つないだ次の行に入り込んだもの（「Sections 1,\n 2」の 2）は捨てる。 */
-export const onLine = (mentions: readonly Mention[], wrapped: WrappedLine): readonly Mention[] =>
-  mentions.filter((mention) => mention.end <= wrapped.lineLength);
+/** 行の中で始まり、行の中で終わる参照だけを、行の上の位置で。つないだ前後の行に入り込んだもの（「Sections 1,\n 2」の 2）は捨てる。 */
+export const onLine = (mentions: readonly Mention[], wrapped: WrappedLine): readonly Mention[] => {
+  const lead = wrapped.leadLength ?? 0;
+  if (lead === 0) return mentions.filter((mention) => mention.end <= wrapped.lineLength);
+  return mentions
+    .filter((mention) => mention.start >= lead && mention.end <= lead + wrapped.lineLength)
+    .map((mention) => ({ ...mention, start: mention.start - lead, end: mention.end - lead }));
+};

package/src/style-load.ts

@@ -0,0 +1,28 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
+import { parseStyle, type StyleDefinition } from "./style-parse.ts";
+
+const STYLES_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "styles");
+
+const loaded: { value: readonly StyleDefinition[] | undefined } = { value: undefined };
+
+const readStyle = (dir: string, file: string): StyleDefinition => {
+  try {
+    return parseStyle(parse(readFileSync(join(dir, file), "utf8")), file);
+  } catch (error) {
+    throw new Error(`cannot read ${join(dir, file)}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+};
+
+/** The bundled house styles (styles/*.yaml), by file name. Read once. */
+export const loadStyles = (dir: string = STYLES_DIR): readonly StyleDefinition[] => {
+  if (dir === STYLES_DIR && loaded.value !== undefined) return loaded.value;
+  const styles = readdirSync(dir)
+    .filter((file) => file.endsWith(".yaml"))
+    .toSorted((left, right) => left.localeCompare(right, "en"))
+    .map((file) => readStyle(dir, file));
+  if (dir === STYLES_DIR) loaded.value = styles;
+  return styles;
+};

package/src/style-parse.ts

@@ -0,0 +1,77 @@
+import { isLevel } from "./levels.ts";
+import type { Level, Localized } from "./plugin.ts";
+
+// A house style (styles/*.yaml): a well-known guideline a team picks with style: in chaff.yaml. It sets rule levels and
+// options, and says where they come from. Pure: the YAML comes in already parsed.
+
+export type StyleSource = { readonly title: Localized; readonly url: string };
+
+export type StyleDefinition = {
+  readonly id: string;
+  readonly name: Localized;
+  /** What the style decides, in one or two plain sentences. */
+  readonly summary: Localized;
+  /** The guideline the style follows, so a reader can check it. */
+  readonly source: StyleSource;
+  readonly rules: Readonly<Record<string, Level>>;
+  /** { rule id: { option: value } }, checked against the rules' declared options by the tests. */
+  readonly options: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isLocalized = (value: unknown): value is Localized =>
+  isRecord(value) && typeof value["ja"] === "string" && typeof value["en"] === "string" && value["ja"] !== "" && value["en"] !== "";
+
+const localizedOf = (value: unknown, field: string, where: string): Localized => {
+  if (!isLocalized(value)) throw new Error(`${where}: ${field} needs a ja and an en text`);
+  return value;
+};
+
+const sourceOf = (value: unknown, where: string): StyleSource => {
+  if (!isRecord(value)) throw new Error(`${where}: source needs a title and a url`);
+  const url = value["url"];
+  if (typeof url !== "string" || !url.startsWith("https://")) throw new Error(`${where}: source.url must be an https:// address`);
+  return { title: localizedOf(value["title"], "source.title", where), url };
+};
+
+const levelsOf = (value: unknown, where: string): Record<string, Level> => {
+  if (value === undefined) return {};
+  if (!isRecord(value)) throw new Error(`${where}: rules must be a map of rule ids to levels`);
+  return Object.fromEntries(
+    Object.entries(value).map(([id, level]) => {
+      if (!isLevel(level)) throw new Error(`${where}: ${id} has the level ${String(level)}; use strict, normal, relaxed or off`);
+      return [id, level];
+    }),
+  );
+};
+
+const optionsOf = (value: unknown, where: string): Record<string, Readonly<Record<string, unknown>>> => {
+  if (value === undefined) return {};
+  if (!isRecord(value)) throw new Error(`${where}: options must be a map of rule ids`);
+  return Object.fromEntries(
+    Object.entries(value).map(([id, options]) => {
+      if (!isRecord(options)) throw new Error(`${where}: options.${id} must be a map of option names to values`);
+      return [id, options];
+    }),
+  );
+};
+
+/** One style file. Throws on anything it cannot read: the file ships with chaff, so a wrong entry is chaff's bug. */
+export const parseStyle = (raw: unknown, file: string): StyleDefinition => {
+  if (!isRecord(raw)) throw new Error(`${file}: a style must be a map`);
+  const id = raw["id"];
+  if (typeof id !== "string" || `${id}.yaml` !== file) throw new Error(`${file}: id must be the file's name without .yaml`);
+  const where = `${file}`;
+  const rules = levelsOf(raw["rules"], where);
+  const options = optionsOf(raw["options"], where);
+  if (Object.keys(rules).length === 0 && Object.keys(options).length === 0) throw new Error(`${where}: a style must set rules or options`);
+  return {
+    id,
+    name: localizedOf(raw["name"], "name", where),
+    summary: localizedOf(raw["summary"], "summary", where),
+    source: sourceOf(raw["source"], where),
+    rules,
+    options,
+  };
+};

package/src/subheading-line.ts

@@ -0,0 +1,68 @@
+import type { Span } from "./plugin.ts";
+
+/**
+ * 括弧でくくった短い句だけの行（「（経済再生）」「（目的）」）は、段落の中の小見出し。
+ * 改行だけで次の文へ続けて書かれると、分割器は次の文の頭に読み込み、その文の指摘が小見出しの行に出る。
+ * 小見出しは文を閉じないが、次の文へは続かないので、その行の後ろで段落を切って別々に分割する。
+ *
+ * かぎ括弧（「」『』）は引用で、後ろの文へ続くことがある（「…ますから」\n自分は…）ので含めない。
+ * 前の行が文の途中で終わるなら、括弧の行は文の中の挿入（折り返した文）なので切らない。
+ */
+const PAIRS: ReadonlyMap<string, string> = new Map([
+  ["（", "）"],
+  ["(", ")"],
+  ["【", "】"],
+  ["〔", "〕"],
+  ["［", "］"],
+  ["[", "]"],
+]);
+
+/** 小見出しとして読む括弧の中身の字数の上限。これより長い括弧の行は、括弧でくくった注記。 */
+const MAX_SUBHEADING_CHARS = 40;
+
+/** 中身の文が終わっている。「（ただし、例外を除く。）」は注記の文で、小見出しではない。 */
+const SENTENCE_END_INSIDE = /(?:[。！？!?])|(?:[.．]$)/u;
+/** 行が文で終わっている。句点の後に閉じ括弧・引用符が続いてよい。 */
+const ENDS_SENTENCE = /[。．！？.!?][」』"'”’)）\]］】〕]*$/u;
+
+const NEWLINE = /\r?\n/gu;
+
+type Line = { readonly start: number; readonly end: number; readonly next: number };
+
+const linesOf = (text: string): Line[] => {
+  const breaks = [...text.matchAll(NEWLINE)];
+  const starts = [0, ...breaks.map((match) => match.index + match[0].length)];
+  return starts.map((start, index) => {
+    const found = breaks[index];
+    return { start, end: found?.index ?? text.length, next: found === undefined ? text.length : found.index + found[0].length };
+  });
+};
+
+/** 行が、括弧一組とその中の短い句だけか。 */
+export const isSubheadingLine = (line: string): boolean => {
+  const trimmed = line.trim();
+  const close = PAIRS.get(trimmed[0] ?? "");
+  if (close === undefined || !trimmed.endsWith(close)) return false;
+  const inner = trimmed.slice(1, -1);
+  const chars = [...inner].length;
+  return chars > 0 && chars <= MAX_SUBHEADING_CHARS && !inner.includes(close) && !inner.includes(trimmed[0] ?? "") && !SENTENCE_END_INSIDE.test(inner);
+};
+
+const hasText = (text: string, line: Line | undefined): boolean => line !== undefined && text.slice(line.start, line.end).trim().length > 0;
+
+/** 前の行が無いか、文で終わっているか、それも小見出し。 */
+const startsFresh = (text: string, previous: Line | undefined): boolean => {
+  if (previous === undefined) return true;
+  const line = text.slice(previous.start, previous.end);
+  return ENDS_SENTENCE.test(line.trimEnd()) || isSubheadingLine(line);
+};
+
+/** 段落 text を、小見出しの行の後ろで切った片。切る所が無ければ text 全体の 1 片。片は改行を含まない端で終わる。 */
+export const subheadingPieces = (text: string): Span[] => {
+  const lines = linesOf(text);
+  const cuts = lines.filter(
+    (line, index) => isSubheadingLine(text.slice(line.start, line.end)) && startsFresh(text, lines[index - 1]) && hasText(text, lines[index + 1]),
+  );
+  const starts = [0, ...cuts.map((line) => line.next)];
+  return starts.map((start, index) => ({ start, end: cuts[index]?.end ?? text.length }));
+};