chaffjs 0.33.0 → 0.35.0

package/src/structure/list-numbering.ts

@@ -4,31 +4,120 @@ import type { Span } from "../plugin.ts";
 import type { StructureIssue } from "./issues.ts";
 
 const ITEM_NUMBER = /^(?<number>\d{1,9})(?<delimiter>[.)])[ \t]/u;
+const TAB_WIDTH = 4;
 
-/** One item's written number: where the item starts, the number and the number as written (「4.」). */
-export type WrittenNumber = { readonly offset: number; readonly number: number; readonly label: string };
+/** One item's written number: where the item starts and ends, its column, the number and the number as written (「4.」). */
+export type WrittenNumber = {
+  readonly offset: number;
+  readonly number: number;
+  readonly label: string;
+  readonly indent?: number;
+  readonly end?: number;
+};
+
+/** The column an offset sits at, a tab counted to the next stop of four as CommonMark counts it. */
+const columnAt = (source: string, offset: number): number =>
+  Array.from(source.slice(source.lastIndexOf("\n", offset - 1) + 1, offset)).reduce(
+    (column, char) => (char === "\t" ? column + TAB_WIDTH - (column % TAB_WIDTH) : column + 1),
+    0,
+  );
+
+const numberAt = (source: string, span: Span): { number: number; label: string } | undefined => {
+  const found = ITEM_NUMBER.exec(source.slice(span.start, span.end))?.groups;
+  return found === undefined ? undefined : { number: Number(found["number"]), label: `${found["number"] ?? ""}${found["delimiter"] ?? ""}` };
+};
 
 /** The number written at the start of each item, or undefined when an item has none (a bulleted list). */
 export const writtenNumbers = (source: string, itemSpans: readonly Span[]): WrittenNumber[] | undefined => {
   const numbers = itemSpans.map((span) => {
-    const found = ITEM_NUMBER.exec(source.slice(span.start, span.end))?.groups;
-    return found === undefined
-      ? undefined
-      : { offset: span.start, number: Number(found["number"]), label: `${found["number"] ?? ""}${found["delimiter"] ?? ""}` };
+    const found = numberAt(source, span);
+    return found === undefined ? undefined : { offset: span.start, end: span.end, ...found, indent: columnAt(source, span.start) };
   });
   return numbers.every((entry) => entry !== undefined) ? numbers : undefined;
 };
 
+/** The last number of an ordered list nested in an item, if there is one. */
+export type NestedLast = (item: WrittenNumber) => number | undefined;
+
+type OrderedList = { readonly start: number; readonly end: number; readonly last: number };
+
+const orderedListOf = (source: string, spans: readonly Span[]): OrderedList[] => {
+  const first = spans[0];
+  const last = writtenNumbers(source, spans)?.at(-1);
+  return first === undefined || last === undefined ? [] : [{ start: first.start, end: last.end ?? last.offset, last: last.number }];
+};
+
+/**
+ * For an item, the last number of the ordered list inside it that ends last (the outermost one, when lists nested in
+ * each other end together). lists are the item spans of every list in the document; bulleted lists are left out.
+ */
+export const nestedLastFinder = (source: string, lists: readonly (readonly Span[])[]): NestedLast => {
+  const ordered = lists.flatMap((spans) => orderedListOf(source, spans));
+  return (item) =>
+    ordered
+      .filter((list) => list.start > item.offset && list.end <= (item.end ?? item.offset))
+      .reduce<OrderedList | undefined>(
+        (best, list) => (best === undefined || list.end > best.end || (list.end === best.end && list.start < best.start) ? list : best),
+        undefined,
+      )?.last;
+};
+
+type Compared = { readonly item: WrittenNumber; readonly previous: WrittenNumber | undefined };
+
+const indentOf = (item: WrittenNumber): number => item.indent ?? 0;
+
 /**
- * Each item whose number is not one more than the item before it. A list that writes one number on every item (「1.」 on
- * each, which Markdown counts up) is numbered by the renderer, not by the writer, and is not read. An item numbered 1
+ * Which item each item's number follows. An item at the same indentation follows the last one there. An item indented
+ * deeper starts a nested count (CommonMark can still put it in the same list, when the indentation falls short of the
+ * parent's text), unless it carries on the count above it: the parent's number plus one (a slip of indentation), or
+ * one past the last number of the list nested in the parent (that list, carried on at a different indentation).
+ */
+const comparedPairs = (items: readonly WrittenNumber[], nestedLast: NestedLast): Compared[] => {
+  const open: WrittenNumber[] = [];
+  return items.map((item) => {
+    const popped: WrittenNumber[] = [];
+    for (let top = open.at(-1); top !== undefined && indentOf(top) > indentOf(item); top = open.at(-1)) {
+      popped.push(top);
+      open.pop();
+    }
+    const parent = open.at(-1);
+    if (parent !== undefined && indentOf(parent) === indentOf(item)) {
+      open[open.length - 1] = item;
+      return { item, previous: parent };
+    }
+    if (parent === undefined) {
+      open.push(item);
+      return { item, previous: popped.at(-1) };
+    }
+    if (item.number === parent.number + 1) {
+      open[open.length - 1] = { ...item, indent: indentOf(parent) };
+      return { item, previous: parent };
+    }
+    open.push(item);
+    return { item, previous: item.number === 1 || item.number === (nestedLast(parent) ?? 0) + 1 ? undefined : parent };
+  });
+};
+
+/**
+ * Each item whose number is not one more than the item it follows. A list that writes one number on every item (「1.」
+ * on each, which Markdown counts up) is numbered by the renderer, not by the writer, and is not read. An item numbered 1
  * starts a new count, as the structure rule reads a 1 that follows other items.
  */
-export const listNumberBreaks = (items: readonly WrittenNumber[]): StructureIssue[] => {
+export const listNumberBreaks = (items: readonly WrittenNumber[], nestedLast: NestedLast = () => undefined): StructureIssue[] => {
   if (new Set(items.map((item) => item.number)).size < 2) return [];
-  return items.flatMap((item, index) => {
-    const previous = items[index - 1];
+  return comparedPairs(items, nestedLast).flatMap(({ item, previous }) => {
     if (previous === undefined || item.number === previous.number + 1 || item.number === 1) return [];
     return [{ offset: item.offset, values: { previous: previous.label, label: item.label, expected: previous.number + 1, found: item.number } }];
   });
 };
+
+type ListSpans = { readonly span: Span; readonly itemSpans: readonly Span[] };
+
+/** The breaks in the document's lists that are checked; every list, checked or not, tells which ordered list sits inside an item. */
+export const listsNumberBreaks = (source: string, lists: readonly ListSpans[], isChecked: (list: ListSpans) => boolean): StructureIssue[] => {
+  const nestedLast = nestedLastFinder(
+    source,
+    lists.map((list) => list.itemSpans),
+  );
+  return lists.filter(isChecked).flatMap((list) => listNumberBreaks(writtenNumbers(source, list.itemSpans) ?? [], nestedLast));
+};

package/src/structure/listed-paragraph.ts

@@ -0,0 +1,45 @@
+import type { StructureNode } from "../plugin.ts";
+
+// 箇条書きで書いた項。規程は条の下の項を「1. 」「２．」の箇条書きで書くことがあり、木はそれを項として読まない。
+
+/** 行頭の箇条書きの番号（「1. 」「２．」）。前の空白（全角も）を飛ばし、全角の数字と点も読む。 */
+const LIST_MARK = /^[ \t\u3000]*(?<n>[0-9０-９]{1,3})[.．]/u;
+
+/** 本文の行頭に箇条書きで書かれた番号。全角は半角の数にする（「２．」は 2）。Pure. */
+export const listedNumbers = (body: string): ReadonlySet<number> =>
+  new Set(
+    body.split("\n").flatMap((line) => {
+      const written = LIST_MARK.exec(line)?.groups?.["n"];
+      return written === undefined ? [] : [Number(written.normalize("NFKC"))];
+    }),
+  );
+
+/** 「3.3」を条の番地「3」と項の番号 3 に分ける。項の先まで指す（3.3.1）か、項が数でなければ undefined。Pure. */
+export const articleParagraph = (target: string): { readonly article: string; readonly paragraph: number } | undefined => {
+  const parts = target.split(".");
+  const [article, paragraph] = parts;
+  if (parts.length !== 2 || article === undefined || paragraph === undefined || !/^\d{1,3}$/u.test(paragraph)) return undefined;
+  return { article, paragraph: Number(paragraph) };
+};
+
+/**
+ * 木が項を一つも読まなかった条ごとの、箇条書きの番号。条の本文は一度だけ読む。同じ番地の条が二つあれば、どちらかに書いてあればよい。
+ * nodes は木を平らにしたもの。Pure.
+ */
+export const listedParagraphsByArticle = (nodes: readonly StructureNode[], source: string): ReadonlyMap<string, ReadonlySet<number>> => {
+  const byArticle = new Map<string, Set<number>>();
+  nodes
+    .filter((node) => node.kind === "article" && !node.children.some((child) => child.kind === "item"))
+    .forEach((article) => {
+      const numbers = byArticle.get(article.address) ?? new Set<number>();
+      listedNumbers(source.slice(article.span.start, article.span.end)).forEach((number) => numbers.add(number));
+      byArticle.set(article.address, numbers);
+    });
+  return byArticle;
+};
+
+/** 参照（第3条第3項）の項を、その条の箇条書きが書いているか。Pure. */
+export const isListedParagraph = (target: string, listed: ReadonlyMap<string, ReadonlySet<number>>): boolean => {
+  const wanted = articleParagraph(target);
+  return wanted !== undefined && listed.get(wanted.article)?.has(wanted.paragraph) === true;
+};

package/src/structure/numbering.ts

@@ -1,4 +1,4 @@
-import type { StructureNode } from "../plugin.ts";
+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";
@@ -7,15 +7,21 @@ const labelOf = (node: StructureNode): string => String(node.attrs["label"] ?? n
 
 type Ordered = { readonly node: StructureNode; readonly ordinal: number; readonly last: number };
 
+const OPENING_BRACKET = /^[([{〔【〈《]/u;
+
+/** 括弧で囲んだ番号（（1）、(a)）か。全角と半角は同じに見る。 */
+const isBracketed = (label: string): boolean => OPENING_BRACKET.test(label.normalize("NFKC"));
+
 /**
- * 同じ親の子のうち、番号の付いたものを種類と深さごとに分ける。条と項は別の並び、項と号も別の並び。
+ * 同じ親の子のうち、番号の付いたものを種類と深さと書き方ごとに分ける。条と項は別の並び、項と号も別の並び。
  * 法令の第 1 項は番号が無いので、その号（一、二）と第 2 項（２）は同じ条の直下に並ぶ。深さで分けないと「二の次が２」に見える。
+ * 社内規程は号の（1）（2）と第 2 項の「2」を同じ深さに読むことがあるので、括弧で囲んだ番号は囲まない番号と別の並びにする。
  */
 const sequencesOf = (parent: StructureNode, quoting: ReadonlySet<StructureNode>): Ordered[][] => {
   const groups = new Map<string, Ordered[]>();
   parent.children.forEach((node) => {
     if (node.ordinal === undefined || quoting.has(node)) return;
-    const key = `${node.kind}/${String(node.level ?? "")}`;
+    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 });
@@ -24,20 +30,42 @@ const sequencesOf = (parent: StructureNode, quoting: ReadonlySet<StructureNode>)
   return [...groups.values()];
 };
 
-/** 隣り合う二つの番号が、1 つ進んでいなければ指摘する。同じ番号なら重なり、飛べば抜け。 */
-const breaksIn = (sequence: readonly Ordered[]): StructureIssue[] =>
-  sequence.flatMap((current, index) => {
-    const previous = sequence[index - 1];
-    // 1 に戻ったら新しい並び。一つの条に (a)(b) の箇条書きが二つある、附則が第1条から振り直す、のどちらも誤りではない。
-    // 範囲をまとめた行（第四十三条から第五十五条まで）の次は、範囲の最後から数える。
-    if (previous === undefined || current.ordinal === previous.last + 1 || current.ordinal === 1) return [];
-    return [
-      {
-        offset: current.node.span.start,
-        values: { previous: labelOf(previous.node), label: labelOf(current.node), expected: previous.last + 1, found: current.ordinal },
-      },
-    ];
-  });
+/** start が after より後ろの最初の範囲。unread は始まりの順に並ぶ。 */
+const firstStartingAfter = (unread: readonly Span[], after: number): number => {
+  let low = 0;
+  let high = unread.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if ((unread[middle]?.start ?? Infinity) > after) high = middle;
+    else low = middle + 1;
+  }
+  return low;
+};
+
+/** 二つの番号のあいだに、読めなかった範囲が始まるか。 */
+const unreadBetween = (unread: readonly Span[], previous: Ordered, current: Ordered): boolean =>
+  (unread[firstStartingAfter(unread, previous.node.span.start)]?.start ?? Infinity) < current.node.span.start;
+
+/**
+ * 隣り合う二つの番号が、1 つ進んでいなければ指摘する。同じ番号なら重なり、飛べば抜け。
+ * あいだに読めなかった範囲（unread）があれば、抜けた番号はそこにあるかもしれないので言わない。重なりは言う。
+ */
+const breaksIn =
+  (unread: readonly Span[]) =>
+  (sequence: readonly Ordered[]): StructureIssue[] =>
+    sequence.flatMap((current, index) => {
+      const previous = sequence[index - 1];
+      // 1 に戻ったら新しい並び。一つの条に (a)(b) の箇条書きが二つある、附則が第1条から振り直す、のどちらも誤りではない。
+      // 範囲をまとめた行（第四十三条から第五十五条まで）の次は、範囲の最後から数える。
+      if (previous === undefined || current.ordinal === previous.last + 1 || current.ordinal === 1) return [];
+      if (current.ordinal > previous.last + 1 && unreadBetween(unread, previous, current)) return [];
+      return [
+        {
+          offset: current.node.span.start,
+          values: { previous: labelOf(previous.node), label: labelOf(current.node), expected: previous.last + 1, found: current.ordinal },
+        },
+      ];
+    });
 
 /**
  * 番号の抜けと重なり。比べるのは同じ親の子どうしだけ。英米の法令は章ごとに Section 101、201 と百の位を変えるので、
@@ -45,12 +73,13 @@ const breaksIn = (sequence: readonly Ordered[]): StructureIssue[] =>
  * 1 に戻った番号は新しい並びの始まりとして扱うので、「(a) の後の (a)」の重なりは見逃す。
  * 同じ番号の節を中に持つ節（ほかの文書の条を引いた手本の見出し）は、並びに入れない。
  * 変更履歴の版の見出し（## 3.1.0）は番号の並びではない。版の順番は version-order が見る。
+ * unread は、読み手には見えるが木に入らない範囲（Markdown の HTML ブロックの中の文字）を、始まりの順に並べたもの。
  */
-export const numberingBreaks = (tree: StructureNode): StructureIssue[] => {
+export const numberingBreaks = (tree: StructureNode, unread: readonly Span[] = []): StructureIssue[] => {
   const quoting = numbersQuotedInside(tree);
   return inDocumentOrder(tree)
     .flatMap((parent) => sequencesOf(parent, quoting))
     .filter((sequence) => !isVersionHistory(sequence.map((ordered) => labelOf(ordered.node))))
-    .flatMap(breaksIn)
+    .flatMap(breaksIn(unread))
     .toSorted((left, right) => left.offset - right.offset);
 };

package/src/structure/prose-total.ts

@@ -5,6 +5,8 @@ import { shownTotal, type Amount } from "./total.ts";
  * 文の中で書いた合計と内訳。表や箇条書きでなく、一つの文に並べた金額を読む。二つの形がある。
  *   内訳のあとに合計:  「保守費60,000円、運用費30,000円とし、合計100,000円とする」 "$6,000 for hosting and $3,000 for support, for a total of $9,000"
  *   合計のあとに内訳:  「月額150,000円（内訳：保守費90,000円、運用費60,000円）」 "costs $8 per month, made up of a base fee of $6 and a storage fee of $2"
+ *   合計の語のあとに内訳:  「総額12,000円：設計5,000円、開発6,000円」 "a total of $12,000: $5,000 for design and $6,000 for development"
+ *     （内訳を始める記号や語 total-breakdown-lead が合計の金額のすぐ後ろにあるか、合計で終わる文の次の文が内訳の語で始まるとき）
  * 合計の語（total-phrase）はすぐ後ろに合計の金額が来る語、内訳の語（breakdown-phrase）はすぐ後ろから内訳が始まる語。
  * 内訳は合計と同じ単位の金額で、二つ以上。合計の語のすぐ前（内訳の語のすぐ後ろ）から続く並びのどれかの和が合計と合えば
  * 合っているとみなし、どれとも合わないときだけ言う。文の中のほかの金額（単価・上限・遅延損害金）を内訳に数えて誤って言わないため。
@@ -16,6 +18,12 @@ export type TotalWords = {
   readonly breakdowns: readonly string[];
   readonly discounts: readonly string[];
   readonly joiners: readonly string[];
+  /** 合計の金額のすぐ後ろに書いて、そこから内訳のすべてが続くことを言う記号や語（": $5,000 for design and …"）。 */
+  readonly leads: readonly string[];
+  /** 合計と内訳のあいだにあれば、後ろの金額は合計の内訳のすべてとは限らないと読む語（including、うち、or）。 */
+  readonly partials: readonly string[];
+  /** 次の文で内訳の語の前に書いて、前の文の合計を指す語（This、It、その）。何も書かなくてもよい。 */
+  readonly backReferences: readonly string[];
 };
 
 type Span = { readonly start: number; readonly end: number };
@@ -124,12 +132,83 @@ const totalsBeforeParts = (source: string, sentence: Span, amounts: readonly Amo
   });
 };
 
+/** 合計の金額と、後ろに続く内訳を始める記号や語のあいだに書いてよいもの: 空白と、読点一つ。 */
+const isLeadGap = (gap: string): boolean => /^[、,，]?$/u.test(gap.trim());
+/** 割合（40%）を並べた内訳は、金額が合計のどの部分かを言わないので比べない。 */
+const PERCENT = /[%％]/u;
+/** 合計の文と内訳の文のあいだに空行があれば、別の段落で、続く内訳とは読まない。 */
+const PARAGRAPH_BREAK = /\n\s*\n/u;
+
+/** 合計の語のすぐ後ろの金額。 */
+const totalsAt = (source: string, markers: readonly Span[], amounts: readonly Amount[]): Amount[] =>
+  markers.flatMap((marker) => amounts.find((amount) => amount.offset >= marker.end && isTotalGap(gapBefore(source, marker.end, amount))) ?? []);
+
+/**
+ * 合計の後ろから始まる内訳のすべてを合計と比べる。内訳の金額がどれも合計と同じ単位で、合計から内訳の終わりまでに
+ * 一部だけを言う語（including、うち）も割合も無いときだけ。
+ */
+const fullBreakdown = (source: string, total: Amount, listed: readonly Amount[], from: number, words: TotalWords): StructureIssue[] => {
+  const last = listed.at(-1);
+  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);
+};
+
+/** 文の中で、合計の語の金額のすぐ後ろに内訳を始める記号や語（": "）があれば、その後ろから文の終わりか次の記号までが内訳。 */
+const totalsThenLead = (source: string, sentence: Span, amounts: readonly Amount[], words: TotalWords): StructureIssue[] => {
+  const text = source.slice(sentence.start, sentence.end);
+  const markers = phraseSpans(text, sentence.start, words.totals);
+  const leads = phraseSpans(text, sentence.start, words.leads);
+  return totalsAt(source, markers, amounts).flatMap((total) => {
+    const lead = leads.find((span) => span.start >= total.end && isLeadGap(source.slice(total.end, span.start)));
+    if (lead === undefined) return [];
+    const end = Math.min(sentence.end, ...[...leads, ...markers].filter((span) => span.start >= lead.end).map((span) => span.start));
+    return fullBreakdown(source, total, inside(amounts, lead.end, end), lead.end, words);
+  });
+};
+
+/** 文の最後の金額が合計の語のすぐ後ろの金額なら、その金額。 */
+const closingTotal = (source: string, sentence: Span, amounts: readonly Amount[], words: TotalWords): Amount | undefined => {
+  const last = inside(amounts, sentence.start, sentence.end).at(-1);
+  const markers = phraseSpans(source.slice(sentence.start, sentence.end), sentence.start, words.totals);
+  return totalsAt(source, markers, amounts).find((total) => total === last);
+};
+
+/** 内訳の語の前に書いたものが、何も無いか前の合計を指す語だけ（"This consists of" 「内訳は」「その内訳は」）。 */
+const refersBack = (opening: string, backReferences: readonly string[]): boolean => {
+  const subject = opening.trim().toLowerCase();
+  return subject === "" || backReferences.some((word) => word.toLowerCase() === subject);
+};
+
+/** 合計で終わる文のすぐ次の文が、前の合計を指して内訳の語で始まれば（内訳は、This consists of）、その後ろの金額が内訳。 */
+const totalThenNextSentence = (source: string, pair: readonly [Span, Span], amounts: readonly Amount[], words: TotalWords): StructureIssue[] => {
+  const [previous, next] = pair;
+  const total = closingTotal(source, previous, amounts, words);
+  if (total === undefined || PARAGRAPH_BREAK.test(source.slice(previous.end, next.start))) return [];
+  const text = source.slice(next.start, next.end);
+  const marker = phraseSpans(text, next.start, words.breakdowns)[0];
+  if (marker === undefined || !refersBack(source.slice(next.start, marker.start), words.backReferences)) return [];
+  const inNext = inside(amounts, next.start, next.end);
+  const end = phraseSpans(text, next.start, words.totals).find((span) => span.start >= marker.end)?.start ?? next.end;
+  return fullBreakdown(source, total, inside(inNext, marker.end, end), marker.end, words);
+};
+
 /** 文ごとに、書いた合計が内訳の和と合わない所。一つの金額は一度だけ言う。 */
 export const proseTotalMismatches = (source: string, sentences: readonly Span[], amounts: readonly Amount[], words: TotalWords): StructureIssue[] => {
-  const issues = sentences.flatMap((sentence) => {
+  const inSentences = sentences.flatMap((sentence) => {
     const inSentence = inside(amounts, sentence.start, sentence.end);
     if (inSentence.length <= MIN_PARTS) return [];
-    return [...totalsAfterParts(source, sentence, inSentence, words), ...totalsBeforeParts(source, sentence, inSentence, words)];
+    return [
+      ...totalsAfterParts(source, sentence, inSentence, words),
+      ...totalsBeforeParts(source, sentence, inSentence, words),
+      ...totalsThenLead(source, sentence, inSentence, words),
+    ];
+  });
+  const acrossSentences = sentences.flatMap((previous, index) => {
+    const next = sentences[index + 1];
+    return next === undefined ? [] : totalThenNextSentence(source, [previous, next], amounts, words);
   });
+  const issues = [...inSentences, ...acrossSentences];
   return issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
 };

package/src/structure/reference-text.ts

@@ -16,6 +16,8 @@ export type ReferenceWords = {
   readonly topicLinks: readonly string[];
   /** 話題にならない語（詳細、内容、details）。どの節にも当てはまる。 */
   readonly vagueTopics: readonly string[];
+  /** 二つの参照を一つの並びにする語（及び、から、and、to）。並びの後ろの括弧は並び全体の名前。 */
+  readonly listJoints: readonly string[];
 };
 
 export type ReferenceInput = {
@@ -70,17 +72,37 @@ export const holdsAside = (name: string, aside: string): boolean => {
   return aside.trim() !== "" && words.includes(` ${aside.trim().toLowerCase()} `);
 };
 
+/** 句点で終わる括弧や引用符の中は名前でなく文（範囲の断り「…を除く。」、引いた条文）。見出しは句点で終わらない。 */
+const SENTENCE_STOP = /[。．]$/u;
+
+export const endsAsSentence = (name: string): boolean => SENTENCE_STOP.test(name);
+
 const isName = (name: string, words: ReferenceWords): boolean =>
-  LETTER.test(name) && !DIGIT.test(name) && !ITEM_LABEL.test(name.normalize("NFKC")) && !words.asides.some((aside) => holdsAside(name, aside));
+  LETTER.test(name) &&
+  !DIGIT.test(name) &&
+  !ITEM_LABEL.test(name.normalize("NFKC")) &&
+  !endsAsSentence(name) &&
+  !words.asides.some((aside) => holdsAside(name, aside));
 
 const agrees = (name: string, heading: string): boolean => {
   const [a, b] = [normalized(name), normalized(heading)];
   return a.includes(b) || b.includes(a);
 };
 
-/** 名前を添えた参照で、名前が参照先の見出しと合わない。 */
+/**
+ * The reference ends a list or range of references ("sections 162 and 164", "sections 9 to 11"): only a joint stands
+ * between it and the reference before it.
+ */
+export const endsList = (between: string, joints: readonly string[]): boolean => {
+  const joint = between.normalize("NFKC").trim().toLowerCase();
+  return joint !== "" && joints.some((candidate) => candidate.normalize("NFKC").trim().toLowerCase() === joint);
+};
+
+/** 名前を添えた参照で、名前が参照先の見出しと合わない。並びの後ろの括弧は並び全体の名前なので、どの見出しとも比べない。 */
 export const titleMismatches = (input: ReferenceInput): StructureIssue[] =>
-  input.references.flatMap((reference) => {
+  input.references.flatMap((reference, index) => {
+    const previous = input.references[index - 1];
+    if (previous !== undefined && endsList(input.source.slice(previous.span.end, reference.span.start), input.words.listJoints)) return [];
     const target = input.targetOf(reference);
     const heading = target === undefined ? "" : headingOf(target);
     const found = nameAfter(input.source, reference.span.end);

package/src/structure/runs.ts

@@ -1,3 +1,5 @@
+import { fencedLineIndexes } from "./fenced-lines.ts";
+
 /**
  * 箇条書きと表の行の並び。続いた箇条書きの同じ深さの項目か、続いた表の行を一つの並びとして読む。
  * 並びの中の値（日付、金額）を比べる rule が共通に使う。
@@ -29,14 +31,21 @@ const pipelessTableLines = (texts: readonly string[]): Set<number> => {
   return inTable;
 };
 
+/** コードブロックの中の箇条書きや表は例なので、並びにしない。 */
+const kindAt = (texts: readonly string[], index: number, pipeless: ReadonlySet<number>, fenced: ReadonlySet<number>): Kind | undefined => {
+  if (fenced.has(index)) return undefined;
+  return pipeless.has(index) ? "table" : kindOf(texts[index] ?? "");
+};
+
 const linesOf = (source: string): Line[] => {
   const texts = source.split("\n");
   const pipeless = pipelessTableLines(texts);
+  const fenced = fencedLineIndexes(texts);
   const found: Line[] = [];
   let start = 0;
   texts.forEach((text, index) => {
     const indent = INDENT.exec(text)?.[0].length ?? 0;
-    const kind = pipeless.has(index) ? "table" : kindOf(text);
+    const kind = kindAt(texts, index, pipeless, fenced);
     found.push({ start, end: start + text.length, kind, indent, rule: TABLE_RULE.test(text) });
     start += text.length + 1;
   });

package/src/structure/section-names.ts

@@ -0,0 +1,32 @@
+import type { StructureNode } from "../plugin.ts";
+
+// 番号で呼ぶ他の法律の手続き。英国の「section 21 notice」は Housing Act 1988 の section 21 の通知で、この文書の section 21 ではない。
+
+/** 参照のすぐ後ろの語。 */
+const NEXT_WORD = /^[ \t]+(?<word>\p{L}+)/u;
+const LOWER_START = /^\p{Ll}/u;
+/** 後ろの語を読む長さ。名前を作る語は短い。 */
+const NEXT_WORD_LENGTH = 24;
+
+/**
+ * 名前の一部として書かれた番号（「section 21 notice」）の行き先。小文字で書いた参照の後ろに、名前を作る語（語彙表）が続くもの。
+ * 大文字の「Section 5 notice」は契約が自分の条を指す書き方なので当たらない。Pure.
+ */
+export const namedTargets = (references: readonly StructureNode[], source: string, nouns: readonly string[]): ReadonlySet<string> => {
+  if (nouns.length === 0) return new Set();
+  const names = new Set(nouns);
+  return new Set(
+    references.flatMap((reference) => {
+      const label = String(reference.attrs["label"] ?? "");
+      const word = NEXT_WORD.exec(source.slice(reference.span.end, reference.span.end + NEXT_WORD_LENGTH))?.groups?.["word"];
+      return LOWER_START.test(label) && word !== undefined && names.has(word) ? [String(reference.attrs["target"] ?? "")] : [];
+    }),
+  );
+};
+
+/**
+ * 名前として書かれた番号を指す参照か。小文字で書いた参照（「under section 21」）だけ。同じ文書の大文字の「Section 21」は、
+ * 文書が自分の section を指す書き方なので、名前があっても探す。Pure.
+ */
+export const pointsToNamedSection = (reference: StructureNode, named: ReadonlySet<string>): boolean =>
+  LOWER_START.test(String(reference.attrs["label"] ?? "")) && named.has(String(reference.attrs["target"] ?? ""));

package/src/structure/signed-date-line.ts

@@ -0,0 +1,78 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * A signature line that dates what its signer did: one date, one role word and the signer's name, and nothing else
+ * (2026年4月12日 会計監査 戸川 隆; Jane Doe, Honorary Auditor, April 12, 2026). A sentence (2026年3月26日の定期総会で承認),
+ * a line without a name, or a line naming two people is not one. Pure.
+ */
+
+const SEPARATOR = /[\s,、，:：]/u;
+const MARK = /[,、，:：]/u;
+const SPACES = /\s+/u;
+/** A Japanese name is one or two parts (戸川 隆, 戸川隆); an English one two or three (Jane Doe, Jane Q. Doe). */
+const MAX_JA_NAME_PARTS = 2;
+const MIN_EN_NAME_PARTS = 2;
+const MAX_EN_NAME_PARTS = 3;
+/** A Japanese name part is kanji or katakana: hiragana is a particle or a verb (田中が確認, に監査を受け). */
+const JA_NAME_PART = /^[\p{Script=Han}\p{Script=Katakana}ー]{1,5}$/u;
+/** An English name part is capitalised, or an initial with its full stop. */
+const EN_NAME_PART = /^\p{Lu}(?:\.|[\p{L}'’-]+)$/u;
+
+/** Where a date sits on the line: from start to end, counted from the line's start. */
+export type LineSpan = { readonly start: number; readonly end: number };
+
+const isEdge = (text: string, index: number): boolean => index < 0 || index >= text.length || SEPARATOR.test(text.charAt(index));
+
+const standsAlone = (text: string, start: number, end: number): boolean => isEdge(text, start - 1) && isEdge(text, end);
+
+const occurrences = (text: string, word: string): number[] => [...text.matchAll(new RegExp(escapeRegExp(word), "gu"))].map((match) => match.index);
+
+/** The role word of roles standing alone on the line (between separators or at an edge), the longest first. */
+export const signerRoleOf = (text: string, roles: readonly string[]): string | undefined =>
+  [...roles]
+    .sort((one, other) => other.length - one.length)
+    .find((role) => occurrences(text, role).some((start) => standsAlone(text, start, start + role.length)));
+
+const isJaName = (parts: readonly string[]): boolean => parts.length <= MAX_JA_NAME_PARTS && parts.every((part) => JA_NAME_PART.test(part));
+
+const isEnName = (parts: readonly string[]): boolean =>
+  parts.length >= MIN_EN_NAME_PARTS && parts.length <= MAX_EN_NAME_PARTS && parts.every((part) => EN_NAME_PART.test(part));
+
+const blanked = (text: string, span: LineSpan): string => `${text.slice(0, span.start)}${" ".repeat(span.end - span.start)}${text.slice(span.end)}`;
+
+/** Where the text that is not a separator starts and ends; undefined when there is none. */
+const contentOf = (text: string): LineSpan | undefined => {
+  const units = text.split("");
+  const start = units.findIndex((unit) => !SEPARATOR.test(unit));
+  if (start < 0) return undefined;
+  const end = units.findLastIndex((unit) => !SEPARATOR.test(unit)) + 1;
+  return { start, end };
+};
+
+/** The text between the role and the name: the name sits wholly on one side of the role. */
+const gapOf = (text: string, role: LineSpan, name: LineSpan): string | undefined => {
+  if (name.end <= role.start) return text.slice(name.end, role.start);
+  return name.start >= role.end ? text.slice(role.end, name.start) : undefined;
+};
+
+/**
+ * The line is a signature: the date and the role each stand alone, and what is left is one name, in one piece on one side
+ * of the role (山田太郎、佐藤花子 is two). An English name is set off from its role by a comma or a colon (Jane Doe, Auditor),
+ * so a title (Auditor Annual Report) is not one. The role is found once the date is blanked out, so a role word inside the
+ * date's text is not read.
+ */
+export const isSignedDateLine = (text: string, role: string, date: LineSpan): boolean => {
+  if (!standsAlone(text, date.start, date.end)) return false;
+  const withoutDate = blanked(text, date);
+  const roleStart = occurrences(withoutDate, role).find((start) => standsAlone(withoutDate, start, start + role.length));
+  if (roleStart === undefined) return false;
+  const roleSpan = { start: roleStart, end: roleStart + role.length };
+  const rest = blanked(withoutDate, roleSpan);
+  const name = contentOf(rest);
+  const gap = name === undefined ? undefined : gapOf(withoutDate, roleSpan, name);
+  if (name === undefined || gap === undefined) return false;
+  const nameText = rest.slice(name.start, name.end);
+  if (MARK.test(nameText)) return false;
+  const parts = nameText.split(SPACES);
+  return isJaName(parts) || (isEnName(parts) && MARK.test(gap));
+};

package/src/structure/tax.ts

@@ -1,6 +1,6 @@
 import type { StructureIssue } from "./issues.ts";
 import { runsOf, type Line } from "./runs.ts";
-import { columnOf, isTotalLabel, shownTotal, type Amount } from "./total.ts";
+import { columnOf, isTotalLabel, shownTotal, withoutLeadingBlankCells, type Amount } from "./total.ts";
 
 /**
  * 税の行と、その上の金額に率を掛けた額。表か箇条書きの並びで、税の語（消費税・Sales tax）で始まり率（10%）を書いた行の
@@ -42,8 +42,11 @@ const rateOf = (text: string): number | undefined => {
   return Number.isFinite(rate) && rate > 0 && rate < MAX_RATE ? rate : undefined;
 };
 
+/** A tax or total row may leave its first cells blank and put its word in the first cell that is not (| | 小計 | 12,000円 |). */
+const startsWithLabel = (row: Row, labels: readonly string[]): boolean => isTotalLabel(withoutLeadingBlankCells(row.text), labels);
+
 const isTaxRow = (row: Row, words: TaxWords): boolean =>
-  isTotalLabel(row.text, words.labels) && !words.included.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
+  startsWithLabel(row, words.labels) && !words.included.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
 
 const isChargeRow = (row: Row, words: TaxWords): boolean => isTotalLabel(row.text, words.charges) && rateOf(row.text) !== undefined;
 
@@ -89,7 +92,7 @@ const basesOf = (source: string, above: readonly Row[], tax: Amount, column: num
   const charges = valuesAt(source, above.slice(chargeStart), column, tax.unit);
   if (charges === undefined) return [];
   const before = above.slice(0, chargeStart);
-  const lastTotalIndex = before.findLastIndex((row) => isTotalLabel(row.text, words.totals));
+  const lastTotalIndex = before.findLastIndex((row) => startsWithLabel(row, words.totals));
   const lastTotal = before[lastTotalIndex];
   if (lastTotal !== undefined) {
     const total = amountAt(source, lastTotal, column, tax.unit);