chaffjs 0.35.0 → 0.37.0

package/src/structure/list-lead-in.ts

@@ -0,0 +1,94 @@
+import type { Sentence, Span } from "../plugin.ts";
+
+// 箇条書きの項目の文が、どの導入の文の下にあるか。「(3) If … no such resolution is made—\n(a) the Commissioner must issue …」の
+// (a) は (3) の条件の下にあり、(a) だけを読むと条件が落ちる。
+
+/** 導入の文の終わり。この後に項目が並ぶ（"must include—"、"is made:"、「承認した場合：」）。 */
+const LEAD_IN_END = /[:：—–]\s*$/u;
+
+/** 空行。そこで段落が改まり、導入はそこを越えて探さない。 */
+const BLANK_LINE = /\n[^\S\n]*\n/u;
+
+/** 項目の頭の印: 開き括弧、番号か記号（囲み数字や仮名は 1 字）、閉じ括弧か点。 */
+const MARKER = /^\s*([(（［[]?)([0-9０-９]+|[a-zA-Zａ-ｚＡ-Ｚ]+|[一二三四五六七八九十]+|\S)([)）］\].．]?)/u;
+
+/** 1 字のローマ数字。英字の並び（(h) の次の (i)）でもありうる。 */
+const SINGLE_ROMAN = /^[ivxIVX]$/u;
+const ROMAN = /^(?:[ivxlc]{2,}|[IVXLC]{2,})$/u;
+
+const labelClass = (label: string): string => {
+  if (/^[0-9０-９]+$/u.test(label)) return "1";
+  if (ROMAN.test(label) || SINGLE_ROMAN.test(label)) return /[a-z]/u.test(label) ? "i" : "I";
+  if (/^[a-zａ-ｚ]+$/u.test(label)) return "a";
+  if (/^[A-ZＡ-Ｚ]+$/u.test(label)) return "A";
+  if (/^[一二三四五六七八九十]+$/u.test(label)) return "一";
+  if (/^[\p{Script=Katakana}\p{Script=Hiragana}]$/u.test(label)) return "イ";
+  if (/^[①-⑳㉑-㉟㊱-㊿]$/u.test(label)) return "①";
+  if (/^[⑴-⒇]$/u.test(label)) return "⑴";
+  return label;
+};
+
+/** 項目の文の頭の印の範囲（"(a)"、"①"）。番号は文の中身ではない。項目の文でなければ undefined。 */
+export const itemMarkerSpan = (sentence: Sentence): Span | undefined => {
+  const match = sentence.listItem === true ? MARKER.exec(sentence.text) : null;
+  return match === null ? undefined : { start: sentence.span.start, end: sentence.span.start + match[0].length };
+};
+
+const previousLetter = (label: string): string => String.fromCharCode(label.charCodeAt(0) - 1);
+
+/**
+ * 項目の印の形（"(1)"、"(a)"、"(i)"、"①"、"・"）。番号そのものは数えない。
+ * 1 字の i・v・x は、同じ括弧の英字の項目がその前の字（h・u・w）で終わっていれば英字、でなければローマ数字。
+ */
+export const markerShape = (text: string, lastLetters: ReadonlyMap<string, string>): { readonly shape: string; readonly letter?: string } | undefined => {
+  const match = MARKER.exec(text);
+  const [, open = "", label, close = ""] = match ?? [];
+  if (label === undefined) return undefined;
+  const letterShape = `${open}${/[a-z]/u.test(label) ? "a" : "A"}${close}`;
+  const continuesLetters = SINGLE_ROMAN.test(label) && lastLetters.get(letterShape) === previousLetter(label);
+  const shape = continuesLetters ? letterShape : `${open}${labelClass(label)}${close}`;
+  return shape === letterShape ? { shape, letter: label } : { shape };
+};
+
+type Entry = { readonly sentence: Sentence; readonly leadIns: readonly Sentence[] };
+
+/** 段落の中で、項目の形ごとの最後の項目と、すぐ前の文が導入ならその文。 */
+type Block = {
+  readonly lastByShape: Map<string, { readonly at: number; readonly entry: Entry }>;
+  readonly lastLetters: Map<string, string>;
+  leadIn: { readonly at: number; readonly entry: Entry } | undefined;
+};
+
+const newBlock = (): Block => ({ lastByShape: new Map(), lastLetters: new Map(), leadIn: undefined });
+
+/** 項目の導入の文: すぐ前の文が導入で、それより後に同じ形の項目（兄弟）が無ければその文とその導入、でなければ兄弟の導入。 */
+const leadInsOf = (block: Block, shape: string): readonly Sentence[] => {
+  const sibling = block.lastByShape.get(shape);
+  const leadIn = block.leadIn;
+  if (sibling !== undefined && (leadIn === undefined || sibling.at >= leadIn.at)) return sibling.entry.leadIns;
+  return leadIn === undefined ? [] : [leadIn.entry.sentence, ...leadIn.entry.leadIns];
+};
+
+/**
+ * 箇条書きの項目の文（listItem）ごとの、導入の文。近い順で、導入が項目なら、その導入も続ける。
+ * 導入は、並びの最初の項目のすぐ前の文で、「—」「:」「：」で終わるもの。同じ段落（空行を挟まない）の中で、同じ形の項目どうしは
+ * 同じ導入の下にある。
+ * sentences は文書の順。source は sentences の span の座標の文字列。
+ */
+export const listLeadIns = (source: string, sentences: readonly Sentence[]): Map<Sentence, readonly Sentence[]> => {
+  const found = new Map<Sentence, readonly Sentence[]>();
+  let block = newBlock();
+  sentences.forEach((sentence, at) => {
+    const previous = sentences[at - 1];
+    if (previous !== undefined && BLANK_LINE.test(source.slice(previous.span.end, sentence.span.start))) block = newBlock();
+    const marker = sentence.listItem === true ? markerShape(sentence.text, block.lastLetters) : undefined;
+    const entry: Entry = { sentence, leadIns: marker === undefined ? [] : leadInsOf(block, marker.shape) };
+    if (marker !== undefined) {
+      found.set(sentence, entry.leadIns);
+      block.lastByShape.set(marker.shape, { at, entry });
+      if (marker.letter !== undefined) block.lastLetters.set(marker.shape, marker.letter.at(-1) ?? "");
+    }
+    block.leadIn = LEAD_IN_END.test(sentence.text) ? { at, entry } : undefined;
+  });
+  return found;
+};

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

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

package/src/structure/prose-total.ts

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

package/src/structure/repeated-number.ts

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

package/src/structure/rounded-amount.ts

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

package/src/structure/side-step.ts

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

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

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