chaffjs 0.34.0 → 0.36.0

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/modal-conflict.ts

@@ -1,4 +1,6 @@
+import { isMarkedNegation, negatedWords } from "./negated-act.ts";
 import type { Sentence, Span, Token } from "../plugin.ts";
+import { itemMarkerSpan } from "./list-lead-in.ts";
 
 // 同じ主語と行為に、逆の様相（しなければならない と してはならない、may と must not）を書いた二つの文。
 // 主語と行為は、文の中身の語（名詞・固有名詞・動詞・形容詞）の集まりで近似する。様相の語そのものは数えない。
@@ -24,13 +26,21 @@ const OPPOSITE: Readonly<Record<string, readonly string[]>> = {
 
 const overlaps = (token: Token, spans: readonly Span[]): boolean => spans.some((span) => token.span.start < span.end && span.start < token.span.end);
 
-/** 文の中身の語を、原形の小文字で、重ねずに並べたもの。様相の語の範囲にかかる語は外す。 */
+/**
+ * 文の中身の語を、原形の小文字で、重ねずに並べたもの。様相の語の範囲にかかる語は外す。
+ * 打ち消しの印の付いた機能語（negationsMarked）は、近くの中身の語に印を付ける（negatedWords）。様相の語の中の打ち消し（must not）は数えない。
+ */
 export const contentKey = (tokens: readonly Token[], markers: readonly Span[]): string =>
   [
     ...new Set(
-      tokens
-        .filter((token) => CONTENT.has(token.pos) && !overlaps(token, markers))
-        .map((token) => (token.lemma !== undefined && token.lemma !== "" ? token.lemma : token.surface).toLowerCase()),
+      negatedWords(
+        tokens
+          .filter((token) => (CONTENT.has(token.pos) || isMarkedNegation(token)) && !overlaps(token, markers))
+          .map((token) => ({
+            word: (token.lemma !== undefined && token.lemma !== "" ? token.lemma : token.surface).toLowerCase(),
+            negation: !CONTENT.has(token.pos),
+          })),
+      ),
     ),
   ]
     .toSorted((left, right) => left.localeCompare(right, "en"))
@@ -51,11 +61,21 @@ const sentenceAt = (sentences: readonly Sentence[], offset: number): Sentence |
   return undefined;
 };
 
+/** 中身の語の集まりを足し合わせたもの。並べ方は contentKey と同じ。 */
+const joinedKey = (keys: readonly string[]): string =>
+  [...new Set(keys.flatMap((key) => (key === "" ? [] : key.split(" "))))].toSorted((left, right) => left.localeCompare(right, "en")).join(" ");
+
 /**
  * 様相の語を一つだけ持つ文の、様相と中身。二つ以上持つ文（shall do A and shall not do B）は、どの語がどの行為にかかるかが
  * 中身の語の集まりからは分からないので外す。品詞の無い文も外す。
+ * leadIns は箇条書きの項目の文の導入の文（listLeadIns）。項目の中身には導入の中身の語を足す。導入の条件（"If … is made—"）は
+ * 項目の行為の条件なので、違う導入の下の項目どうしは、同じ行為を決めていない。
  */
-export const modalStatements = (obligations: readonly Obligation[], sentences: readonly Sentence[]): ModalStatement[] => {
+export const modalStatements = (
+  obligations: readonly Obligation[],
+  sentences: readonly Sentence[],
+  leadIns: ReadonlyMap<Sentence, readonly Sentence[]> = new Map(),
+): ModalStatement[] => {
   const bySentence = new Map<Sentence, Obligation[]>();
   obligations.forEach((obligation) => {
     const sentence = sentenceAt(sentences, obligation.start);
@@ -64,11 +84,26 @@ export const modalStatements = (obligations: readonly Obligation[], sentences: r
     if (found === undefined) bySentence.set(sentence, [obligation]);
     else found.push(obligation);
   });
+  /** 様相の語と項目の印を除いた中身。 */
+  const keyOf = (sentence: Sentence, tokens: readonly Token[], markers: readonly Span[]): string => {
+    const item = itemMarkerSpan(sentence);
+    return contentKey(tokens, item === undefined ? markers : [...markers, item]);
+  };
+  const leadInKeys = new Map<Sentence, string>();
+  const leadInKey = (sentence: Sentence): string => {
+    const known = leadInKeys.get(sentence);
+    if (known !== undefined) return known;
+    const key = sentence.tokens === undefined ? "" : keyOf(sentence, sentence.tokens, bySentence.get(sentence) ?? []);
+    leadInKeys.set(sentence, key);
+    return key;
+  };
   return [...bySentence].flatMap(([sentence, found]) => {
     const [only] = found;
     if (found.length !== 1 || only === undefined || sentence.tokens === undefined) return [];
-    const key = contentKey(sentence.tokens, [only]);
-    return key.split(" ").length < MIN_CONTENT_WORDS ? [] : [{ offset: sentence.span.start, type: only.type, marker: only.marker, key }];
+    const own = keyOf(sentence, sentence.tokens, [only]);
+    if (own.split(" ").length < MIN_CONTENT_WORDS) return [];
+    const key = joinedKey([own, ...(leadIns.get(sentence) ?? []).map(leadInKey)]);
+    return [{ offset: sentence.span.start, type: only.type, marker: only.marker, key }];
   });
 };
 

package/src/structure/negated-act.ts

@@ -0,0 +1,49 @@
+import type { Lexicon, Sentence, Token } from "../plugin.ts";
+
+// 行為や条件の中の打ち消し（"goods that do not conform"、「承認しなかった場合」）。打ち消しの語は中身の語ではないが、
+// 打ち消しだけが違う二つの文は、違うことを決めている。
+
+/** 打ち消しの語に付ける印（Token.features の名前）。 */
+const NEGATION_FEATURE = "negation";
+
+/** 打ち消しを受けた語の印。語の後ろに付ける。 */
+export const NEGATED = "¬";
+
+/** 語彙表の打ち消しの語（group の無いもの。接頭の「不」「未」は語の一部なので見ない）。英語は小文字で照らす。 */
+export const negationWords = (lexicon: Lexicon | undefined): ReadonlySet<string> =>
+  new Set((lexicon ?? []).filter((entry) => entry.group === undefined).map((entry) => entry.pattern.toLowerCase()));
+
+const isNegation = (token: Token, words: ReadonlySet<string>): boolean =>
+  words.has(token.surface.toLowerCase()) || (token.lemma !== undefined && words.has(token.lemma.toLowerCase()));
+
+export const isMarkedNegation = (token: Token): boolean => token.features?.[NEGATION_FEATURE] !== undefined;
+
+/** 打ち消しの語に印を付けた文。品詞の無い文はそのまま。 */
+export const negationsMarked = (sentences: readonly Sentence[], words: ReadonlySet<string>): Sentence[] =>
+  sentences.map((sentence) =>
+    sentence.tokens === undefined
+      ? sentence
+      : {
+          ...sentence,
+          tokens: sentence.tokens.map((token) => (isNegation(token, words) ? { ...token, features: { ...token.features, [NEGATION_FEATURE]: "yes" } } : token)),
+        },
+  );
+
+type Placed = { readonly out: readonly string[]; readonly pending: boolean };
+
+/**
+ * 語の並びの打ち消しを、すぐ前の語（文頭なら次の語）に NEGATED として付けたもの。どの語にかかるかは読まない。
+ * 打ち消しのある文と無い文を分けるための印で、二つ重なっても一つにする。
+ */
+export const negatedWords = (words: readonly { readonly word: string; readonly negation: boolean }[]): string[] =>
+  words
+    .reduce<Placed>(
+      ({ out, pending }, { word, negation }) => {
+        if (!negation) return { out: [...out, pending ? `${word}${NEGATED}` : word], pending: false };
+        const last = out.at(-1);
+        if (last === undefined) return { out, pending: true };
+        return { out: last.endsWith(NEGATED) ? out : [...out.slice(0, -1), `${last}${NEGATED}`], pending: false };
+      },
+      { out: [], pending: false },
+    )
+    .out.slice();

package/src/structure/numbering.ts

@@ -1,43 +1,80 @@
-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";
+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;
+
+/** 括弧で囲んだ番号（（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 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;
-    const key = `${node.kind}/${String(node.level ?? "")}`;
+    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()];
 };
 
-/** 隣り合う二つの番号が、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 [];
+      if (current.ordinal > previous.last + 1 && current.ordinal <= previous.last + 1 + current.sideSteps) 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 +82,19 @@ const breaksIn = (sequence: readonly Ordered[]): StructureIssue[] =>
  * 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): 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)
-    .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/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/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/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"] ?? ""));