chaffjs 0.34.0 → 0.35.0

package/src/structure/html-text-blocks.ts

@@ -0,0 +1,45 @@
+import { readMarkdown } from "../markdown-read.ts";
+import { spanOf, type MarkdownNode } from "../markdown-node.ts";
+import type { Span } from "../plugin.ts";
+
+const COMMENT = /<!--[\s\S]*?(?:-->|$)/gu;
+const INLINE_CONTAINERS = new Set(["paragraph", "heading", "tableCell"]);
+const ENTITY = /&(?:#\d+|#x[\da-f]+|[a-z]+\d*);/giu;
+
+type TagScan = { readonly kept: string[]; inTag: boolean; quote: string | undefined };
+
+/** Reads one character of HTML: text outside a tag is kept. A quoted attribute may hold `>` (`<div title=">">`). */
+const scanned = (scan: TagScan, char: string): TagScan => {
+  if (!scan.inTag) {
+    if (char === "<") scan.inTag = true;
+    else scan.kept.push(char);
+  } else if (scan.quote !== undefined) {
+    if (char === scan.quote) scan.quote = undefined;
+  } else if (char === '"' || char === "'") scan.quote = char;
+  else if (char === ">") scan.inTag = false;
+  return scan;
+};
+
+const withoutTags = (html: string): string => [...html].reduce<TagScan>(scanned, { kept: [], inTag: false, quote: undefined }).kept.join("");
+
+/** What an HTML block shows the reader: its text without tags, comments and character references such as `&nbsp;`. */
+const showsText = (html: string): boolean => withoutTags(html.replace(COMMENT, "")).replace(ENTITY, "").trim() !== "";
+
+/**
+ * Markdown's HTML blocks that show text. CommonMark runs a block that starts with a tag alone on its line (`<br/>`) to
+ * the next blank line, so a `第11条` written right under it is raw HTML: the reader sees it, chaff's structure does not.
+ * Only blocks are returned; an inline tag inside a paragraph (`text<br/>`) leaves the text beside it readable.
+ */
+export const htmlTextBlocks = (source: string): Span[] => {
+  if (!source.includes("<")) return [];
+  const blocks: Span[] = [];
+  const visit = (node: MarkdownNode, inParagraph: boolean): void => {
+    if (node.type === "html" && !inParagraph && showsText(node.value ?? "")) {
+      const span = spanOf(node);
+      if (span !== undefined) blocks.push(span);
+    }
+    (node.children ?? []).forEach((child) => visit(child, inParagraph || INLINE_CONTAINERS.has(node.type)));
+  };
+  visit(readMarkdown(source).root, false);
+  return blocks.toSorted((left, right) => left.start - right.start);
+};

package/src/structure/issues.ts

@@ -1,6 +1,10 @@
 import type { StructureNode } from "../plugin.ts";
+import { writtenReading } from "./written-resolve.ts";
+import { namedTargets, pointsToNamedSection } from "./section-names.ts";
 import { listedTags } from "./listed-tags.ts";
 import { namesAbsentUnit } from "./unit-word.ts";
+import { isListedParagraph, listedParagraphsByArticle } from "./listed-paragraph.ts";
+import { referencesInCitedDocuments } from "./cited-document-section.ts";
 
 // 木だけで決まる誤り。参照先が無い、番号が飛ぶ・重なる、同じ語を二度定義する。
 // 意味の食い違いは判定しない。書いてあることから機械で決まるものだけを出す。
@@ -111,7 +115,7 @@ const numbering = (node: StructureNode): unknown => node.attrs["numbering"];
  * 参照の番地が木に無い。他の文書の名前が付いた参照（民法第709条、Section 9 of the Master Agreement）は引かない。
  * 条を 1 つも持たない文書も見ない。他の文書を指しているだけかもしれない。
  */
-export const danglingReferences = (tree: StructureNode, source: string): StructureIssue[] => {
+export const danglingReferences = (tree: StructureNode, source: string, nameNouns: readonly string[] = []): StructureIssue[] => {
   const nodes = inDocumentOrder(tree);
   // 参照は条を指す。条を一つも持たない文書（契約書に付ける承諾書のひな形など）の「契約書第6条」は、別の文書の条。
   if (!nodes.some((node) => node.kind === "article")) return [];
@@ -127,10 +131,21 @@ export const danglingReferences = (tree: StructureNode, source: string): Structu
   const articleLabels = nodes.filter((node) => node.kind === "article").map((node) => textOf(node, "label"));
   const chapters = chaptersOf(nodes);
   const elsewhere = elsewhereReferences(nodes, source);
-  return nodes
-    .filter((node) => node.kind === "reference" && !citesOther(node) && !otherNumbering(node))
+  const quoted = referencesInCitedDocuments(tree);
+  const references = nodes.filter((node) => node.kind === "reference");
+  const named = namedTargets(references, source, nameNouns);
+  const unresolved = references
+    .filter((node) => !citesOther(node) && !otherNumbering(node) && !pointsToNamedSection(node, named))
     .filter((node) => !namesAbsentUnit(node, articleLabels) && !elsewhere.has(node))
-    .filter((node) => !resolves(node, addresses, chapters))
+    .filter((node) => !quoted.has(node) && !resolves(node, addresses, chapters));
+  // 規程は条の下の項を箇条書き（「1. 」「２．」）で書くことがあり、木はそれを項として読まない。条の本文は、要るときに一度だけ読む。
+  const listed = unresolved.length === 0 ? new Map() : listedParagraphsByArticle(nodes, source);
+  // 平文の契約は見出しを「9. Indemnification.」と本文の形で書き、木はそれを番地にしない。残った参照があるときだけ読む。
+  const written = unresolved.length === 0 ? undefined : writtenReading(nodes, source);
+  const writtenAddresses = new Set(written?.addresses);
+  return unresolved
+    .filter((node) => !isListedParagraph(textOf(node, "target"), listed))
+    .filter((node) => !writtenAddresses.has(textOf(node, "target")) && written?.subdivision(node) !== true)
     .map((node) => ({ offset: node.span.start, values: { label: textOf(node, "label"), target: textOf(node, "target") } }));
 };
 

package/src/structure/labelled-date-order.ts

@@ -4,6 +4,7 @@ import type { StructureIssue } from "./issues.ts";
 import type { Line } from "./lines.ts";
 import { labelPairsOf, pointsOutOfOrder, type OrderLabel, type PairWords, type PointOf } from "./labelled-order.ts";
 import { TABLE_ROW } from "./runs.ts";
+import type { VersionWords } from "./versioned-label.ts";
 import { isSignedDateLine } from "./signed-date-line.ts";
 import { statedPeriod, type DateMention, type PeriodWords } from "./stated-period.ts";
 
@@ -132,6 +133,8 @@ export type PairedReading = {
   readonly spans?: PairSpans | undefined;
   readonly whole?: string | undefined;
   readonly signers?: readonly OrderLabel[] | undefined;
+  /** The words that join a version to a label (End of support for 5.0.0, 3.0.0 のサポート終了日). */
+  readonly versions?: VersionWords | undefined;
 };
 
 const signersOf = (signers: readonly OrderLabel[], group: string): string[] =>
@@ -166,14 +169,14 @@ export const pairedDatesOutOfOrder = (
   labels: readonly OrderLabel[],
   passed: readonly string[],
   maxLineGap: number,
-  { spans, whole = source, signers = [] }: PairedReading = {},
+  { spans, whole = source, signers = [], versions }: PairedReading = {},
 ): PairedIssue[] =>
   withoutRepeats(
     labelPairsOf(labels).flatMap((pair) => {
       const context = contextOf(labels, pair.group);
       if (context.length > 0 && !namesDocumentKind(whole, context)) return [];
       const fromStart = spanStartsOf(spans?.entries ?? [], pair.group);
-      const words = { ...pair, passed, maxLineGap, spans, fromStart, signers: signersOf(signers, pair.group) };
+      const words = { ...pair, passed, maxLineGap, spans, fromStart, signers: signersOf(signers, pair.group), versions };
       return datesOutOfOrder(source, dates, words).map(({ earlier, later }) => ({
         offset: Math.max(later.date.offset, earlier.date.offset),
         values: { later: later.date.value, earlier: earlier.date.value, later_label: later.label, earlier_label: earlier.label },

package/src/structure/labelled-order.ts

@@ -2,6 +2,7 @@ import { linesOf, type Line } from "./lines.ts";
 import { tableAround } from "./key-value-row.ts";
 import { signerRoleOf } from "./signed-date-line.ts";
 import { isTotalLabel } from "./total.ts";
+import { withoutLabelVersion, type VersionWords } from "./versioned-label.ts";
 
 /**
  * Two labelled points that must come in order: a line (or a list item, or a table's first column) starting with an
@@ -24,6 +25,8 @@ export type PairWords = {
    * pointOf decides whether the line is one. A signature closes the whole document, so it is read at any distance.
    */
   readonly signers?: readonly string[] | undefined;
+  /** The words that join a version to a label (End of support for 5.0.0, 3.0.0 のサポート終了日). */
+  readonly versions?: VersionWords | undefined;
 };
 
 /** A labelled point: the word that labels it, as the lexicon writes it. span is set when the point ends a stated period. */
@@ -36,7 +39,13 @@ export type PointOf = (line: Line, label: string, tableOf: () => readonly string
 
 type Read = LabelledPoint & { readonly kind: "earlier" | "later"; readonly signed?: boolean | undefined };
 
-const labelOf = (text: string, words: readonly string[]): string | undefined => words.find((word) => isTotalLabel(text, [word]));
+const isVersionedLabel = (text: string, word: string, versions: VersionWords | undefined): boolean => {
+  const bare = versions === undefined ? undefined : withoutLabelVersion(text, word, versions);
+  return bare !== undefined && isTotalLabel(bare, [word]);
+};
+
+const labelOf = (text: string, words: readonly string[], versions?: VersionWords): string | undefined =>
+  words.find((word) => isTotalLabel(text, [word]) || isVersionedLabel(text, word, versions));
 
 const signerOf = (text: string, words: PairWords): Pick<Read, "kind" | "label" | "signed"> | undefined => {
   const role = signerRoleOf(text, words.signers ?? []);
@@ -44,9 +53,9 @@ const signerOf = (text: string, words: PairWords): Pick<Read, "kind" | "label" |
 };
 
 const kindOf = (text: string, words: PairWords): Pick<Read, "kind" | "label" | "signed"> | undefined => {
-  const earlier = labelOf(text, words.earlier);
+  const earlier = labelOf(text, words.earlier, words.versions);
   if (earlier !== undefined) return { kind: "earlier", label: earlier };
-  const later = labelOf(text, words.later);
+  const later = labelOf(text, words.later, words.versions);
   return later === undefined ? signerOf(text, words) : { kind: "later", label: later };
 };
 

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/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/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/versioned-label.ts

@@ -0,0 +1,52 @@
+/**
+ * A label naming the version it is about: the version after the label and a word (End of support for 5.0.0:), or before
+ * it with a word (3.0.0 のサポート終了日：). The words come from the language's lexicon; a version is digits joined by dots,
+ * with or without a leading v. Pure.
+ */
+
+/** The words that join a version to a label: after for the label, word, version order; before for version, word, label. */
+export type VersionWords = { readonly after: readonly string[]; readonly before: readonly string[] };
+
+/** A list marker, a table cell's bar and emphasis before the label. A numbered marker needs its space: 3.0.0 is a version, not item 3. */
+const LINE_LEAD = /^[ \t]*(?:(?:[-*+]|\d{1,3}[.)])[ \t]+)?(?:\|[ \t]*)?[*_]*/u;
+const VERSION = /^v?\d+(?:\.\d+)+/iu;
+/** After the label's version, only the label's end: a colon or a table cell's bar. */
+const VERSION_END = /^[ \t]*[:：|]/u;
+const SPACES = /^[ \t\u3000]*/u;
+
+const spacesAt = (text: string): number => SPACES.exec(text)?.[0].length ?? 0;
+
+const versionAt = (text: string): number => VERSION.exec(text)?.[0].length ?? 0;
+
+/** After the label: one word, spaces on both sides, a version and the label's end. Returns the label's end on. */
+const afterVersion = (rest: string, word: string): string | undefined => {
+  const gap = spacesAt(rest);
+  if (gap === 0 || !rest.slice(gap).toLowerCase().startsWith(`${word.toLowerCase()} `)) return undefined;
+  const from = gap + word.length + spacesAt(rest.slice(gap + word.length));
+  const version = versionAt(rest.slice(from));
+  const tail = rest.slice(from + version);
+  return version > 0 && VERSION_END.test(tail) ? tail : undefined;
+};
+
+/** Before the label: a version, the word and the label, spaces allowed between. Returns the text from the label on. */
+const beforeVersion = (lead: string, word: string, label: string): string | undefined => {
+  const version = versionAt(lead);
+  if (version === 0) return undefined;
+  const atWord = version + spacesAt(lead.slice(version));
+  if (!lead.slice(atWord).startsWith(word)) return undefined;
+  const atLabel = atWord + word.length + spacesAt(lead.slice(atWord + word.length));
+  return lead.slice(atLabel).toLowerCase().startsWith(label.toLowerCase()) ? lead.slice(atLabel) : undefined;
+};
+
+/**
+ * The line read as the bare label: "End of support for 5.0.0: …" as "End of support: …", "3.0.0 のサポート終了日：…" as
+ * "サポート終了日：…". undefined when the line does not start with the label carrying a version that way.
+ */
+export const withoutLabelVersion = (text: string, label: string, words: VersionWords): string | undefined => {
+  const lead = text.replace(LINE_LEAD, "");
+  const after = lead.toLowerCase().startsWith(label.toLowerCase())
+    ? words.after.map((word) => afterVersion(lead.slice(label.length), word)).find((tail) => tail !== undefined)
+    : undefined;
+  if (after !== undefined) return `${lead.slice(0, label.length)}${after}`;
+  return words.before.map((word) => beforeVersion(lead, word, label)).find((rest) => rest !== undefined);
+};