chaffjs 0.35.0 → 0.36.0

package/src/structure/numbering.ts

@@ -2,10 +2,12 @@ import type { Span, StructureNode } from "../plugin.ts";
 import { inDocumentOrder, type StructureIssue } from "./issues.ts";
 import { numbersQuotedInside } from "./quoted-number.ts";
 import { isVersionHistory } from "./version-order.ts";
+import { withRepeatsNamed } from "./repeated-number.ts";
 
 const labelOf = (node: StructureNode): string => String(node.attrs["label"] ?? node.address);
 
-type Ordered = { readonly node: StructureNode; readonly ordinal: number; readonly last: number };
+/** sideSteps は、この番号の直前にある番号の無い手順（GOV.UK の「and」）の数。それぞれが番号を一つ使っていてよい。 */
+type Ordered = { readonly node: StructureNode; readonly ordinal: number; readonly last: number; readonly sideSteps: number };
 
 const OPENING_BRACKET = /^[([{〔【〈《]/u;
 
@@ -17,15 +19,21 @@ const isBracketed = (label: string): boolean => OPENING_BRACKET.test(label.norma
  * 法令の第 1 項は番号が無いので、その号（一、二）と第 2 項（２）は同じ条の直下に並ぶ。深さで分けないと「二の次が２」に見える。
  * 社内規程は号の（1）（2）と第 2 項の「2」を同じ深さに読むことがあるので、括弧で囲んだ番号は囲まない番号と別の並びにする。
  */
-const sequencesOf = (parent: StructureNode, quoting: ReadonlySet<StructureNode>): Ordered[][] => {
+const sequencesOf = (parent: StructureNode, quoting: ReadonlySet<StructureNode>, isSideStep: (node: StructureNode) => boolean): Ordered[][] => {
   const groups = new Map<string, Ordered[]>();
+  let sideSteps = 0;
   parent.children.forEach((node) => {
-    if (node.ordinal === undefined || quoting.has(node)) return;
+    if (node.ordinal === undefined) {
+      if (isSideStep(node)) sideSteps += 1;
+      return;
+    }
+    if (quoting.has(node)) return;
     const key = `${node.kind}/${String(node.level ?? "")}/${isBracketed(labelOf(node)) ? "bracketed" : "bare"}`;
     // 配列を作り直さずに足す。条が何千もある法令で二乗にしない。
     const group = groups.get(key) ?? [];
-    group.push({ node, ordinal: node.ordinal, last: node.ordinalTo ?? node.ordinal });
+    group.push({ node, ordinal: node.ordinal, last: node.ordinalTo ?? node.ordinal, sideSteps });
     groups.set(key, group);
+    sideSteps = 0;
   });
   return [...groups.values()];
 };
@@ -59,6 +67,7 @@ const breaksIn =
       // 範囲をまとめた行（第四十三条から第五十五条まで）の次は、範囲の最後から数える。
       if (previous === undefined || current.ordinal === previous.last + 1 || current.ordinal === 1) return [];
       if (current.ordinal > previous.last + 1 && unreadBetween(unread, previous, current)) return [];
+      if (current.ordinal > previous.last + 1 && current.ordinal <= previous.last + 1 + current.sideSteps) return [];
       return [
         {
           offset: current.node.span.start,
@@ -73,13 +82,19 @@ const breaksIn =
  * 1 に戻った番号は新しい並びの始まりとして扱うので、「(a) の後の (a)」の重なりは見逃す。
  * 同じ番号の節を中に持つ節（ほかの文書の条を引いた手本の見出し）は、並びに入れない。
  * 変更履歴の版の見出し（## 3.1.0）は番号の並びではない。版の順番は version-order が見る。
+ * 同じ番号が二度続いて次が飛ぶ（4.1、4.1、4.3）ものは、重なりと抜けに分けず、二つ目で一度だけ言う（repeated-number.ts）。
  * unread は、読み手には見えるが木に入らない範囲（Markdown の HTML ブロックの中の文字）を、始まりの順に並べたもの。
+ * isSideStep は、番号の代わりに「and」と書いた手順（前の手順と並べて行う）。その数だけ、次の番号は飛んでよい。
  */
-export const numberingBreaks = (tree: StructureNode, unread: readonly Span[] = []): StructureIssue[] => {
+export const numberingBreaks = (
+  tree: StructureNode,
+  unread: readonly Span[] = [],
+  isSideStep: (node: StructureNode) => boolean = () => false,
+): StructureIssue[] => {
   const quoting = numbersQuotedInside(tree);
-  return inDocumentOrder(tree)
-    .flatMap((parent) => sequencesOf(parent, quoting))
+  const breaks = inDocumentOrder(tree)
+    .flatMap((parent) => sequencesOf(parent, quoting, isSideStep))
     .filter((sequence) => !isVersionHistory(sequence.map((ordered) => labelOf(ordered.node))))
-    .flatMap(breaksIn(unread))
-    .toSorted((left, right) => left.offset - right.offset);
+    .flatMap(breaksIn(unread));
+  return withRepeatsNamed(tree, quoting, breaks, unread);
 };

package/src/structure/prose-total.ts

@@ -1,4 +1,5 @@
 import type { StructureIssue } from "./issues.ts";
+import { coarsestStep, roundingAllowance } from "./rounded-amount.ts";
 import { shownTotal, type Amount } from "./total.ts";
 
 /**
@@ -22,6 +23,10 @@ export type TotalWords = {
   readonly leads: readonly string[];
   /** 合計と内訳のあいだにあれば、後ろの金額は合計の内訳のすべてとは限らないと読む語（including、うち、or）。 */
   readonly partials: readonly string[];
+  /** partials のうち、並べた金額が主なものだけだと言う語（主な、mainly）。合計の前に並べた内訳の前に書いても、内訳は合計のすべてではない。 */
+  readonly mainOnly: readonly string[];
+  /** 丸めた桁で書く金額の単位（百万円、千円、million）。どの金額もこの単位なら、丸めのずれ（内訳の数 − 1 桁まで）は合うとみなす。 */
+  readonly roundedUnits: readonly string[];
   /** 次の文で内訳の語の前に書いて、前の文の合計を指す語（This、It、その）。何も書かなくてもよい。 */
   readonly backReferences: readonly string[];
 };
@@ -85,13 +90,15 @@ const signedValues = (source: string, parts: readonly Amount[], from: number, di
 
 type Breakdown = { readonly total: Amount; readonly parts: readonly Amount[]; readonly from: number; readonly nearEnd: boolean };
 
-const mismatch = (source: string, breakdown: Breakdown, discounts: readonly string[]): StructureIssue[] => {
+const mismatch = (source: string, breakdown: Breakdown, words: TotalWords): StructureIssue[] => {
   const { total, from, nearEnd } = breakdown;
   const parts = breakdown.parts.filter((part) => part.unit === total.unit);
   if (parts.length < MIN_PARTS) return [];
-  const values = signedValues(source, parts, from, discounts);
+  const values = signedValues(source, parts, from, words.discounts);
   const written = centsOf(total);
-  if (nearRuns(values, nearEnd).some((run) => sumOf(run) === written)) return [];
+  const step = coarsestStep(source, [total, ...parts], words.roundedUnits) * CENTS;
+  const matches = (run: readonly number[]): boolean => Math.abs(sumOf(run) - written) <= Math.round(roundingAllowance(step, run.length));
+  if (nearRuns(values, nearEnd).some(matches)) return [];
   return [{ offset: total.offset, values: shownTotal(source, total, sumOf(values)) }];
 };
 
@@ -106,6 +113,10 @@ const breakdownEnd = (source: string, total: Amount, marker: Span, sentence: Spa
 
 const inside = (amounts: readonly Amount[], start: number, end: number): Amount[] => amounts.filter((amount) => amount.offset >= start && amount.end <= end);
 
+/** 内訳の前（start から end まで）に、主なものだけを並べると言う語があるか（「主な設備投資は、…」「主な内訳は」）。 */
+const saysMainOnly = (source: string, start: number, end: number, words: TotalWords): boolean =>
+  phraseSpans(source.slice(start, end), start, words.mainOnly).length > 0;
+
 /** 合計の語のすぐ後ろの金額を、その前の内訳と比べる。内訳は、前の合計の語か内訳の語より後ろから。 */
 const totalsAfterParts = (source: string, sentence: Span, amounts: readonly Amount[], words: TotalWords): StructureIssue[] => {
   const text = source.slice(sentence.start, sentence.end);
@@ -115,7 +126,9 @@ const totalsAfterParts = (source: string, sentence: Span, amounts: readonly Amou
     const total = amounts.find((amount) => amount.offset >= marker.end && isTotalGap(gapBefore(source, marker.end, amount)));
     if (total === undefined) return [];
     const from = Math.max(sentence.start, markers[index - 1]?.end ?? 0, ...breakdowns.filter((span) => span.end <= marker.start).map((span) => span.end));
-    return mismatch(source, { total, parts: inside(amounts, from, marker.start), from, nearEnd: true }, words.discounts);
+    const parts = inside(amounts, from, marker.start);
+    if (saysMainOnly(source, from, parts[0]?.offset ?? from, words)) return [];
+    return mismatch(source, { total, parts, from, nearEnd: true }, words);
   });
 };
 
@@ -126,9 +139,10 @@ const totalsBeforeParts = (source: string, sentence: Span, amounts: readonly Amo
   return phraseSpans(text, sentence.start, words.breakdowns).flatMap((marker) => {
     const total = amounts.findLast((amount) => amount.end <= marker.start);
     if (total === undefined || phraseSpans(source.slice(total.end, marker.start), total.end, words.joiners).length > 0) return [];
+    if (saysMainOnly(source, total.end, marker.start, words)) return [];
     const nextTotal = totalMarkers.find((span) => span.start >= marker.end)?.start ?? sentence.end;
     const parts = inside(amounts, marker.end, Math.min(nextTotal, breakdownEnd(source, total, marker, sentence)));
-    return mismatch(source, { total, parts, from: marker.end, nearEnd: false }, words.discounts);
+    return mismatch(source, { total, parts, from: marker.end, nearEnd: false }, words);
   });
 };
 
@@ -152,7 +166,7 @@ const fullBreakdown = (source: string, total: Amount, listed: readonly Amount[],
   if (last === undefined || listed.some((part) => part.unit !== total.unit)) return [];
   const between = source.slice(total.end, last.offset);
   if (PERCENT.test(between) || phraseSpans(between, total.end, words.partials).length > 0) return [];
-  return mismatch(source, { total, parts: listed, from, nearEnd: false }, words.discounts);
+  return mismatch(source, { total, parts: listed, from, nearEnd: false }, words);
 };
 
 /** 文の中で、合計の語の金額のすぐ後ろに内訳を始める記号や語（": "）があれば、その後ろから文の終わりか次の記号までが内訳。 */

package/src/structure/repeated-number.ts

@@ -0,0 +1,110 @@
+import type { Span, StructureNode } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import { isVersionHistory } from "./version-order.ts";
+
+type Placed = { readonly node: StructureNode; readonly parent: StructureNode; readonly ordinal: number };
+
+const labelOf = (node: StructureNode): string => String(node.attrs["label"] ?? node.address);
+
+/** 「4.1」「4．1」の、最後の番号より前（「4」）。点で区切った番号でなければ無い。 */
+const DOTTED = /^(.*\d)[.．](\d+)$/u;
+const dottedPrefixOf = (label: string): string | undefined => DOTTED.exec(label.normalize("NFKC").trim())?.[1];
+
+const OPENING_BRACKET = /^[([{〔【〈《]/u;
+
+/**
+ * 番号の並びの単位。点で区切った番号（4.1、4.3）は、前の番号（4）が同じものどうしを、親が違っても一つの並びに読む。
+ * 番号の無い見出し（## Approved Office Supplies List）が間に入ると、4.3 は 4.1 と別の親の下に入るが、読み手には 4 の続きに見える。
+ * それ以外の番号（第3条、(a)）は、同じ親の子どうしだけを並べる。
+ */
+const familyOf = (placed: Placed, parentIds: ReadonlyMap<StructureNode, number>): string => {
+  const label = labelOf(placed.node);
+  const shape = `${placed.node.kind}/${String(placed.node.level ?? "")}/${OPENING_BRACKET.test(label.normalize("NFKC")) ? "bracketed" : "bare"}`;
+  const prefix = dottedPrefixOf(label);
+  return prefix === undefined ? `${shape}/parent:${String(parentIds.get(placed.parent))}` : `${shape}/dotted:${prefix}`;
+};
+
+const placedNodes = (tree: StructureNode, quoting: ReadonlySet<StructureNode>): Placed[] => {
+  const placed: Placed[] = [];
+  const pending: StructureNode[] = [tree];
+  for (let parent = pending.pop(); parent !== undefined; parent = pending.pop()) {
+    parent.children.forEach((node) => {
+      pending.push(node);
+      if (node.ordinal !== undefined && node.ordinalTo === undefined && !quoting.has(node)) placed.push({ node, parent, ordinal: node.ordinal });
+    });
+  }
+  return placed.toSorted((left, right) => left.node.span.start - right.node.span.start);
+};
+
+const familiesOf = (placed: readonly Placed[]): Placed[][] => {
+  const parentIds = new Map<StructureNode, number>();
+  placed.forEach(({ parent }) => parentIds.set(parent, parentIds.get(parent) ?? parentIds.size));
+  const families = new Map<string, Placed[]>();
+  placed.forEach((entry) => {
+    const key = familyOf(entry, parentIds);
+    const family = families.get(key) ?? [];
+    family.push(entry);
+    families.set(key, family);
+  });
+  return [...families.values()];
+};
+
+/** 番号の最後の数字を一つ進めた書き方（4.1 → 4.2、Section 2 → Section 3）。数字で書いていなければ、進めた番号だけ。 */
+export const nextLabelOf = (label: string, ordinal: number): string => {
+  const normalized = label.normalize("NFKC");
+  const digits = [...normalized.matchAll(/\d+/gu)].at(-1);
+  if (digits === undefined || Number(digits[0]) !== ordinal) return String(ordinal + 1);
+  return `${normalized.slice(0, digits.index)}${String(ordinal + 1)}${normalized.slice(digits.index + digits[0].length)}`;
+};
+
+/** explains は、この誤りで説明がつく、並びの指摘の位置（二つ目、同じ親の下なら次の番号）。 */
+export type RepeatedNumber = { readonly explains: readonly number[]; readonly between: Span; readonly issue: StructureIssue };
+
+const repeatsIn = (family: readonly Placed[]): RepeatedNumber[] =>
+  family.flatMap((first, index) => {
+    const second = family[index + 1];
+    const next = family[index + 2];
+    if (second === undefined || next === undefined || second.parent !== first.parent) return [];
+    if (second.ordinal !== first.ordinal || next.ordinal !== first.ordinal + 2) return [];
+    const label = labelOf(second.node);
+    return [
+      {
+        between: { start: second.node.span.start, end: next.node.span.start },
+        explains: next.parent === second.parent ? [second.node.span.start, next.node.span.start] : [second.node.span.start],
+        issue: {
+          offset: second.node.span.start,
+          variant: "repeated",
+          values: { previous: labelOf(first.node), label, expected: first.ordinal + 1, found: second.ordinal, probably: nextLabelOf(label, second.ordinal) },
+        },
+      },
+    ];
+  });
+
+/**
+ * 同じ番号が二度続き、その次が一つ飛ぶ（4.1、4.1、4.3）。二つ目は、振り間違えた 4.2 である見込みが高い。
+ * 重なりと抜けの二つに見えるが、誤りは一つなので、二つ目の番号で一度だけ言う。
+ * 同じ親の下で隣り合う二つが同じ番号のときだけ。変更履歴の版の見出し（## 3.1.0）は番号の並びではないので見ない。
+ * 別の部の 1.1 から振り直した並び（1.1、1.2 の後の 1.1、1.2）は、次が飛ばないので言わない。
+ */
+export const repeatedNumbers = (tree: StructureNode, quoting: ReadonlySet<StructureNode>): RepeatedNumber[] =>
+  familiesOf(placedNodes(tree, quoting))
+    .filter((family) => !isVersionHistory(family.map(({ node }) => labelOf(node))))
+    .flatMap(repeatsIn);
+
+/**
+ * 並びの抜けと重なり（issues）のうち、同じ番号が二度続いたもの（repeatedNumbers）で説明がつくものを、その一つにまとめる。
+ * 二つ目と次の番号のあいだに読めなかった範囲（unread）があれば、飛んだ番号はそこにあるかもしれないので、まとめずに元の指摘を残す。
+ * 二つ目の番号への指摘は置き換え、次の番号への抜けの指摘は、二つ目と同じ親の下にあるときだけ（二つ目の次として数えたもの）消す。
+ */
+export const withRepeatsNamed = (
+  tree: StructureNode,
+  quoting: ReadonlySet<StructureNode>,
+  issues: readonly StructureIssue[],
+  unread: readonly Span[] = [],
+): StructureIssue[] => {
+  const repeats = repeatedNumbers(tree, quoting).filter(({ between }) => !unread.some((span) => span.start > between.start && span.start < between.end));
+  const explained = new Set(repeats.flatMap(({ explains }) => explains));
+  return [...issues.filter((issue) => !explained.has(issue.offset)), ...repeats.map(({ issue }) => issue)].toSorted(
+    (left, right) => left.offset - right.offset,
+  );
+};

package/src/structure/rounded-amount.ts

@@ -0,0 +1,55 @@
+import type { Amount } from "./total.ts";
+
+/**
+ * 丸めた単位（百万円、千円、億円、$3.1 million）で書いた金額の、最後の桁一つ分。丸めて書いた内訳と合計は、
+ * 四捨五入でも切り捨てでも切り上げでも、内訳の数 − 1 桁までずれる（3,074百万円 + 2,434百万円 + 1,146百万円 と 総額6,655百万円）。
+ * 有効数字が 3 桁以上の金額だけを丸めたと読む。最後の桁一つ分がその金額の 1% 以下になり、1億円 + 2億円 = 4億円 のような
+ * 金額と同じ大きさのずれを丸めとは読まない。
+ */
+
+/** 書いた数（6,655、3.1）。漢数字だけの金額は読まない。 */
+const NUMERAL = /\d[\d,，]*(?:[.．]\d+)?/u;
+/** 金額のすぐ後ろに書いた単位の語（$3.1 million の million）までのあいだ。 */
+const UNIT_AFTER = /^[ \t]?([A-Za-z]+)/u;
+const DECIMAL_BASE = 10;
+/** 金額の後ろで単位の語を探す長さ。 */
+const UNIT_REACH = 16;
+/** 丸めたと読む金額の、書いた数の有効数字の最小の桁数。 */
+const MIN_SIGNIFICANT_DIGITS = 3;
+
+/** 書いた数と、その小数の桁。 */
+type Numeral = { readonly value: number; readonly decimals: number; readonly significant: number };
+
+/** 書いた数と、その小数の桁と有効数字の桁数（頭の 0 を除いた数字の数。6,655 なら 4、3.1 なら 2、0.25 なら 2）。 */
+const numeralOf = (written: string): Numeral | undefined => {
+  const match = NUMERAL.exec(written.normalize("NFKC"));
+  if (match === null) return undefined;
+  const [whole = "", fraction = ""] = match[0].replace(/,/gu, "").split(".");
+  const significant = `${whole}${fraction}`.replace(/^0+/u, "").length;
+  return { value: Number(`${whole}.${fraction || "0"}`), decimals: fraction.length, significant };
+};
+
+/** 金額が丸めた単位で書いてあるか。和文の単位は金額の中に（6,655百万円）、英語の単位は金額のすぐ後ろに（$5.6 million）ある。 */
+const inRoundedUnit = (written: string, after: string, units: readonly string[]): boolean => {
+  const word = UNIT_AFTER.exec(after)?.[1]?.toLowerCase();
+  return units.some((unit) => written.includes(unit) || unit.toLowerCase() === word);
+};
+
+/** 丸めた単位で書いた金額の最後の桁一つ分を、金額の値の単位で。丸めた単位でないか、有効数字が 3 桁未満なら undefined。 */
+export const displayStep = (source: string, amount: Amount, units: readonly string[]): number | undefined => {
+  const written = source.slice(amount.offset, amount.end);
+  if (!inRoundedUnit(written, source.slice(amount.end, amount.end + UNIT_REACH), units)) return undefined;
+  const numeral = numeralOf(written);
+  if (numeral === undefined || numeral.value === 0 || numeral.significant < MIN_SIGNIFICANT_DIGITS) return undefined;
+  return (amount.value / numeral.value) * DECIMAL_BASE ** -numeral.decimals;
+};
+
+/** 金額のどれもが丸めた単位で書いてあれば、その一番粗い桁一つ分。一つでも丸めた単位でなければ 0（ずれを許さない）。 */
+export const coarsestStep = (source: string, amounts: readonly Amount[], units: readonly string[]): number => {
+  const steps = amounts.map((amount) => displayStep(source, amount, units));
+  const known = steps.filter((step) => step !== undefined);
+  return known.length === steps.length && known.length > 0 ? Math.max(...known) : 0;
+};
+
+/** 丸めた桁 step で書いた parts 個の内訳の和が、合計からずれてよい幅。 */
+export const roundingAllowance = (step: number, parts: number): number => step * Math.max(0, parts - 1);

package/src/structure/side-step.ts

@@ -0,0 +1,21 @@
+import type { StructureNode } from "../plugin.ts";
+
+/** The label, then a gap of two or more spaces or a tab (the label column of a step list), then the step's own text. */
+const LABEL_COLUMN = /^(?<word>\S+)(?: {2}|\t)/u;
+
+/**
+ * A heading labelled with a word (side-step-label: "and", "or") where a step list puts a number: a step done alongside
+ * the one before it (GOV.UK's step-by-step pages). The word is matched as written, and must stand in a label column
+ * like a step's number does: "and more details" is an ordinary heading.
+ */
+export const sideStepReader = (labels: readonly string[]): ((node: StructureNode) => boolean) => {
+  const words = new Set(labels);
+  return (node) => {
+    const heading = node.attrs["heading"];
+    if (typeof heading !== "string") return false;
+    const label = LABEL_COLUMN.exec(heading);
+    const word = label?.groups?.["word"];
+    if (label === null || word === undefined) return false;
+    return words.has(word) && heading.slice(label[0].length).trim() !== "";
+  };
+};

package/src/structure/spanned-label-blank.ts

@@ -0,0 +1,39 @@
+// A row label that spans two columns in the table it was converted from (| Total score |  | 5 |): Markdown has no column
+// span, so the cell right after the label is left blank and the value follows. Pure; the caller passes the total words.
+
+/** A note in parentheses at the end of a label (Total score (count of all "yes" answers above)), dropped before reading it. */
+const TRAILING_NOTE = /[(（][^()（）]*[)）]$/u;
+const EMPHASIS = /[*_]/gu;
+const COLON_END = /[:：]$/u;
+const LATIN_LETTER = /\p{Script=Latin}/u;
+
+const labelText = (cell: string): string => cell.replace(EMPHASIS, "").trim().replace(TRAILING_NOTE, "").trim();
+
+/**
+ * Whether `word` stands at the start or the end of `label` as a word of its own: no Latin letter runs on from it. A word of
+ * one character (計) must be the whole label, since it starts or ends many words (計画, 設計).
+ */
+const startsOrEndsWith = (label: string, word: string): boolean => {
+  const lower = label.toLowerCase();
+  const target = word.toLowerCase();
+  if (Array.from(target).length === 1) return lower === target;
+  const after = lower.charAt(target.length);
+  const before = lower.charAt(lower.length - target.length - 1);
+  return (lower.startsWith(target) && !LATIN_LETTER.test(after)) || (lower.endsWith(target) && !LATIN_LETTER.test(before));
+};
+
+/** A label: it ends in a colon (Total:), or a total word starts or ends it (Total score, 得点合計). */
+export const isSpanningLabel = (cell: string, totalWords: readonly string[]): boolean => {
+  const label = labelText(cell);
+  if (label === "") return false;
+  return COLON_END.test(label) || totalWords.some((word) => word !== "" && startsOrEndsWith(label, word));
+};
+
+/**
+ * Whether the blank at `column` is the second half of a label that spans two columns: the cell before it holds such a label
+ * and the cell after it is filled. Cells are undefined when blank.
+ */
+export const isSpannedLabelGap = (cells: readonly (string | undefined)[], column: number, totalWords: readonly string[]): boolean => {
+  const label = cells[column - 1];
+  return cells[column] === undefined && cells[column + 1] !== undefined && label !== undefined && isSpanningLabel(label, totalWords);
+};

package/src/structure/universal.ts

@@ -51,10 +51,19 @@ export const dottedNumber = (line: string, context: NumberingContext, plainText
 export const isAmount = (dotted: DottedLine, countedAfter: StructurePatterns["countedAfter"]): boolean =>
   !dotted.closedByDot && countedAfter?.(dotted.number, dotted.rest) === true;
 
-/** 言語を問わない通し番号。後ろが単位なら数量、本文の文の続きなら文の中の数なので、番号にしない。 */
+/** 年まで書いた日付の値（2022-12-08）。年の無い「2 May」は、番号 2 の題「May」とも読める。 */
+const WITH_YEAR = /^\d{4}-/u;
+
+/** 番号が年まで書いた日付の頭（「8 December 2022」の 8）か。日付を言語の dates が読む。年表の見出しの日は番号の並びではない。 */
+export const startsDate = (text: string, dates: StructurePatterns["dates"]): boolean => {
+  const at = text.length - text.trimStart().length;
+  return (dates?.(text) ?? []).some((date) => date.start <= at && at < date.end && WITH_YEAR.test(String(date.attrs["value"] ?? "")));
+};
+
+/** 言語を問わない通し番号。後ろが単位なら数量、日付なら日、本文の文の続きなら文の中の数なので、番号にしない。 */
 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;
+  if (dotted === undefined || isAmount(dotted, patterns.countedAfter) || startsDate(text, patterns.dates)) return undefined;
   const numbered = { number: dotted.number, rest: dotted.rest, isHeading: context.isHeading };
   return numberInSentence(numbered, patterns.continuesSentence) ? undefined : dotted;
 };

package/src/structure/unspaced-heading.ts

@@ -0,0 +1,27 @@
+import type { Heading } from "../document.ts";
+import type { NumberingContext, StructurePatterns } from "../plugin.ts";
+import type { Line } from "./lines.ts";
+
+/** Hashes with no space before the words: 「##第一四条 （存続条項）」. CommonMark reads the line as a paragraph. */
+const UNSPACED = /^ {0,3}(?<hashes>#{1,6})(?<words>[^#\s].*)$/u;
+
+const ON_HEADING: NumberingContext = { open: [], isHeading: true };
+
+/**
+ * Lines (by number) written as a heading without the space after the hashes, kept only when the language reads the words as an article or
+ * a chapter. The writer's neighbours are headings of the same shape, so reading this one as a paragraph puts a gap in the
+ * article numbers that is not in the document. 「#タグ」 and 「#1 の件」 stay text.
+ */
+export const unspacedHeadings = (lines: readonly Line[], headed: ReadonlyMap<number, Heading>, patterns: StructurePatterns): [number, Heading][] =>
+  lines.flatMap((line) => {
+    if (headed.has(line.number)) return [];
+    const groups = UNSPACED.exec(line.text)?.groups;
+    const hashes = groups?.["hashes"];
+    const words = groups?.["words"]?.trim();
+    if (hashes === undefined || words === undefined) return [];
+    const kind = patterns.numbered(words, ON_HEADING)?.kind;
+    if (kind !== "article" && kind !== "chapter") return [];
+    const heading: Heading = { depth: hashes.length, text: words, start: line.start, end: line.start + line.text.length };
+    const entry: [number, Heading] = [line.number, heading];
+    return [entry];
+  });

package/src/structure/written-list-path.ts

@@ -0,0 +1,46 @@
+// 箇条書きで書いた小見出し。「- (b) Composition: …」の下に字下げして「- i. one representative …」と書いた文書は、
+// 「Section 8(b)(i)」の (b) と i を本文の括弧ではなく行の頭の札で書く。札の入れ子は字下げで読む。
+
+/** 行の頭の札。indent は札の前の字下げの幅（タブは 4）。 */
+export type ListLabel = { readonly label: string; readonly indent: number };
+
+/** 字下げ、箇条書きの記号（-、*、+）、札、空白、本文。 */
+const LIST_LINE = /^(?<indent>[ \t]*)(?:[-*+][ \t]+)?(?<mark>\S+)[ \t]+\S/u;
+/** 札「(b)」「i.」「2)」。 */
+const MARK = /^\(?(?<label>[a-zA-Z]{1,4}|\d{1,3})[.)]$/u;
+
+/** 札の中身。開き括弧で始まる札は閉じ括弧で終わる（「(b.」は札ではない）。 */
+const labelOf = (mark: string): string | undefined => {
+  const label = MARK.exec(mark)?.groups?.["label"];
+  return mark.startsWith("(") && !mark.endsWith(")") ? undefined : label;
+};
+const TAB_WIDTH = 4;
+
+const widthOf = (indent: string): number => [...indent].reduce((width, char) => width + (char === "\t" ? TAB_WIDTH : 1), 0);
+
+/** 本文の行の頭に書かれた札を、文書の順に。Pure. */
+export const listLabels = (body: string): ListLabel[] =>
+  body.split("\n").flatMap((line) => {
+    const groups = LIST_LINE.exec(line)?.groups;
+    const label = labelOf(groups?.["mark"] ?? "");
+    return label === undefined ? [] : [{ label, indent: widthOf(groups?.["indent"] ?? "") }];
+  });
+
+/** 札 index の下（次に同じか浅い字下げの札が来るまで）の終わり。 */
+const scopeEnd = (items: readonly ListLabel[], index: number, end: number): number => {
+  const depth = items[index]?.indent ?? 0;
+  const next = items.findIndex((item, at) => at > index && at < end && item.indent <= depth);
+  return next === -1 ? end : next;
+};
+
+/** items[from, end) の一番浅い字下げの札（直下の札）から、labels を入れ子の順にたどれるか。深い札を飛ばして親にしない。 */
+const pathFrom = (items: readonly ListLabel[], labels: readonly string[], from: number, end: number): boolean => {
+  const [first, ...rest] = labels;
+  if (first === undefined) return true;
+  const scope = items.slice(from, end);
+  const top = Math.min(...scope.map((item) => item.indent));
+  return scope.some((item, at) => item.indent === top && item.label === first && pathFrom(items, rest, from + at + 1, scopeEnd(items, from + at, end)));
+};
+
+/** 札「b」「iv」が、行の頭の札として「(b)」の下に「iv.」と入れ子で書かれているか。札が無ければ false。Pure. */
+export const hasListPath = (items: readonly ListLabel[], labels: readonly string[]): boolean => labels.length > 0 && pathFrom(items, labels, 0, items.length);

package/src/structure/written-resolve.ts

@@ -1,5 +1,6 @@
 import type { StructureNode } from "../plugin.ts";
 import { headingRegions, parentAndLabels, writtenHeadings, writtenSubdivisions, type WrittenHeading } from "./written-headings.ts";
+import { hasListPath, listLabels } from "./written-list-path.ts";
 
 // 木が番地にしない平文の見出しと、本文の中に書いた括弧の小見出し（「6.1 … that (i) the Software …」）を、参照の行き先として引く。
 
@@ -31,27 +32,33 @@ const treeRegions = (nodes: readonly StructureNode[], headings: readonly Written
   return regions;
 };
 
+/** 範囲の本文を read で読んだ結果。範囲ごとに、要るときに一度だけ読む。 */
+const perRegion = <T>(source: string, read: (body: string) => T): ((region: Region) => T) => {
+  const cache = new Map<string, T>();
+  return ([start, end]) => {
+    const key = `${String(start)}:${String(end)}`;
+    const found = cache.get(key) ?? read(source.slice(start, end));
+    cache.set(key, found);
+    return found;
+  };
+};
+
 /**
  * 平文の見出しの番地と、参照（Section 6.1(i)）の親（6.1）が木の条か平文の見出しとしてあり、その範囲の本文に札「(i)」が
- * 書かれているかを引く関数。範囲ごとの札は、要るときに一度だけ読む。Pure.
+ * 書かれているか（札を行の頭に入れ子で書いた箇条書きも読む）を引く関数。Pure.
  */
 export const writtenReading = (nodes: readonly StructureNode[], source: string): WrittenReading => {
   const references = nodes.filter((node) => node.kind === "reference").map((node) => ({ start: node.span.start, end: node.span.end, target: targetOf(node) }));
   const headings = writtenHeadings(references, source);
   const written = headingRegions(headings, source.length);
   const tree = treeRegions(nodes, headings);
-  const labels = new Map<string, ReadonlySet<string>>();
-  const labelsIn = ([start, end]: Region): ReadonlySet<string> => {
-    const key = `${String(start)}:${String(end)}`;
-    const found = labels.get(key) ?? writtenSubdivisions(source.slice(start, end));
-    labels.set(key, found);
-    return found;
-  };
+  const labelsIn = perRegion(source, writtenSubdivisions);
+  const listIn = perRegion(source, listLabels);
   const regionsOf = (address: string): Region[] => [...(tree.get(address) ?? []), ...(written.get(address) ?? [])];
   const subdivision = (reference: StructureNode): boolean => {
     const wanted = parentAndLabels(targetOf(reference), String(reference.attrs["label"] ?? ""));
     if (wanted === undefined) return false;
-    return regionsOf(wanted.parent).some((region) => wanted.labels.every((label) => labelsIn(region).has(label)));
+    return regionsOf(wanted.parent).some((region) => wanted.labels.every((label) => labelsIn(region).has(label)) || hasListPath(listIn(region), wanted.labels));
   };
   return { addresses: headings.map((heading) => heading.address), subdivision };
 };

package/src/title-line.ts

@@ -0,0 +1,52 @@
+// A title written on a line of its own, as a plain-text heading (Exhibit A to Merger Agreement, ANNEX 1): a few words with
+// no full stop, and a blank line or the document's edge on both sides. Pure.
+
+/**
+ * How a reader tells a title from a sentence. dangling-figure-reference reads a caption of any labelled thing; duplicate-
+ * definition reads where an attached instrument starts. Their notions differ, so each says how.
+ */
+export type TitleNotion = {
+  /** A title ending in one of these is a sentence or runs on. duplicate-definition also refuses a trailing `: ; ,`. */
+  readonly sentenceEnd: RegExp;
+  /** Every word longer than three letters starts with a capital. dangling-figure-reference only: Figure 3 shows the trend. */
+  readonly capitalised: boolean;
+  /**
+   * "any-whitespace": the document's edge may be reached across any whitespace (a line of U+3000 or NBSP before the
+   * first line). "blank-line": only lines of spaces and tabs count. dangling-figure-reference takes the first.
+   */
+  readonly edge: "any-whitespace" | "blank-line";
+};
+
+/** A title runs at most this many words after its label and number. */
+const TITLE_MAX_WORDS = 6;
+/** A word this long or shorter may stay in lower case in a title (to, of, the, and). */
+const TITLE_SMALL_WORD = 3;
+const BLANK_LINE = /\n[ \t\r]*\n[ \t\r]*$/u;
+const ENDS_LINE = /^[ \t\r]*\n/u;
+const BLANK = /^[ \t\r]*$/u;
+const LOWER_START = /^\p{Ll}/u;
+
+const isShortTitle = (rest: string, notion: TitleNotion): boolean => {
+  const title = rest.trim();
+  const words = title.split(/\s+/u).filter((word) => word !== "");
+  return (
+    words.length <= TITLE_MAX_WORDS &&
+    !notion.sentenceEnd.test(title) &&
+    (!notion.capitalised || words.every((word) => word.length <= TITLE_SMALL_WORD || !LOWER_START.test(word)))
+  );
+};
+
+const isAloneBefore = (before: string, notion: TitleNotion): boolean =>
+  before === "" || BLANK_LINE.test(`\n${before}`) || (notion.edge === "any-whitespace" && before.trim() === "");
+
+const isAloneAfter = (after: string, isLastLine: boolean, notion: TitleNotion): boolean =>
+  isLastLine || ENDS_LINE.test(after) || BLANK.test(after) || (notion.edge === "any-whitespace" && after.trim() === "");
+
+/**
+ * The line from lineStart to lineEnd (-1: the last line) is a title: rest, the words after its label and number, are a
+ * short title, and a blank line or the document's edge is on both sides.
+ */
+export const isTitleLine = (source: string, lineStart: number, lineEnd: number, rest: string, notion: TitleNotion): boolean =>
+  isShortTitle(rest, notion) &&
+  isAloneBefore(source.slice(0, lineStart), notion) &&
+  isAloneAfter(lineEnd === -1 ? "" : source.slice(lineEnd + 1), lineEnd === -1, notion);