chaffjs 0.30.0 → 0.32.0

package/src/structure/total-line.ts

@@ -0,0 +1,232 @@
+import { isTotalLabel, leadingText } from "./total.ts";
+import { CELL_SEPARATOR } from "./bare-numbers.ts";
+import { outsideBrackets } from "./connection-times.ts";
+
+/** 合計の語に添える語。position が before なら合計の語の前だけ、after なら後ろだけ、無ければどちらにも置ける。 */
+export type TotalQualifier = { readonly pattern: string; readonly position?: "before" | "after" | undefined };
+
+/**
+ * labels: 合計の語（total-label）。qualifiers: 合計の語の前後に置いても合計の行のままの語（total-label-qualifier）。
+ * nounQualifiers: 合計に付けた名詞の前後に置いても、数える物を変えない語（total-noun-qualifier。修得単位の修得、credits earned の earned）。
+ * unsummedNouns: 上の行の和とは限らない量の名詞（total-noun-unsummed。部屋を並べた表の Total area は、廊下も含みうる）。
+ */
+export type TotalLineWords = {
+  readonly labels: readonly string[];
+  readonly qualifiers: readonly TotalQualifier[];
+  readonly nounQualifiers?: readonly TotalQualifier[] | undefined;
+  readonly unsummedNouns?: readonly string[] | undefined;
+  /** 合計が足す期間の語（total-period-qualifier。年間合計の年間、Total for the year の for the year）。見出しの頭か尻から除いて読む。 */
+  readonly periodQualifiers?: readonly TotalQualifier[] | undefined;
+  /** それだけで一年の合計を言う合計の語（total-label の group period。年額）。期間の語を付けた合計と同じに読む。 */
+  readonly periodLabels?: readonly string[] | undefined;
+  /** 見出しが名指さなくても上の行の和と読める合計の名詞（total-noun-listed。差引合計の差引、Total deductions の deductions）。 */
+  readonly listedNouns?: readonly string[] | undefined;
+  /** 差し引きで決まる金額の名前（net-amount-label。総支給額、Gross pay）。表の行がこの名前なら、表は一つの和の内訳ではない。 */
+  readonly amountNames?: readonly string[] | undefined;
+};
+
+/** 見出しの終わり。区切り（: |）があればそこまで、無ければ金額の始まりまで。 */
+const SEPARATOR = /[:：|]/u;
+const AMOUNT_START = /[$€£¥￥\p{N}]/u;
+const EMPHASIS = /[*_]/gu;
+const SPACES = /\s+/u;
+
+const wordsOf = (text: string): string[] =>
+  text
+    .toLowerCase()
+    .split(SPACES)
+    .filter((word) => word.length > 0);
+
+const labelText = (lead: string): string => {
+  const separator = lead.search(SEPARATOR);
+  if (separator !== -1) return lead.slice(0, separator);
+  const amount = lead.search(AMOUNT_START);
+  return amount === -1 ? lead : lead.slice(0, amount);
+};
+
+/** 行頭の見出しを語に分ける。括弧の注記（(incl. tax)）と強調の印は除く。 */
+const labelWords = (text: string): string[] => wordsOf(outsideBrackets(labelText(leadingText(text))).replace(EMPHASIS, ""));
+
+const startsAt = (words: readonly string[], label: readonly string[], index: number): boolean => label.every((word, offset) => words[index + offset] === word);
+
+const allowedOn = (side: "before" | "after", qualifiers: readonly TotalQualifier[]): ReadonlySet<string> =>
+  new Set(
+    qualifiers.filter((qualifier) => qualifier.position !== (side === "before" ? "after" : "before")).map((qualifier) => qualifier.pattern.toLowerCase()),
+  );
+
+/** 見出しの語のどこかに合計の語が一つ続けてあり、その前と後ろの語がどれも、そちら側に置ける添える語か。 */
+const isQualifiedLabel = (words: readonly string[], label: readonly string[], qualifiers: readonly TotalQualifier[]): boolean => {
+  const before = allowedOn("before", qualifiers);
+  const after = allowedOn("after", qualifiers);
+  return (
+    label.length > 0 &&
+    words.some(
+      (_, index) =>
+        startsAt(words, label, index) &&
+        words.slice(0, index).every((word) => before.has(word)) &&
+        words.slice(index + label.length).every((word) => after.has(word)),
+    )
+  );
+};
+
+/** 語の変化（deduction と deductions、控除と控除項目）とみなす、長い方の語の終わりの文字数の上限。 */
+const INFLECTION_SLACK = 2;
+/** 見出しが名指す語の短さの下限。一文字の語（設計の「設」）は名指しとみなさない。 */
+const MIN_NOUN_LENGTH = 2;
+/** 英字と数字。合計の語がこの字で始まる・終わるなら、隣の字が同じ種類でないときだけ語の切れ目とみなす。 */
+const WORD_CHAR = /[a-z0-9]/u;
+
+/** 同じ語か。どちらかがもう一方で始まり、残りが二文字まで（deduction と deductions、控除と控除項目）なら同じ語と読む。 */
+const sameWord = (left: string, right: string): boolean => {
+  const [shorter, longer] = left.length <= right.length ? [left, right] : [right, left];
+  return shorter.length >= MIN_NOUN_LENGTH && longer.startsWith(shorter) && longer.length - shorter.length <= INFLECTION_SLACK;
+};
+
+/** 名詞と見出しの語が一つずつ対応するか。見出しに名詞の無い語（Tax deduction の deduction）があれば、別の種類の量と読む。 */
+const namesEachOther = (nouns: readonly string[], headerWords: readonly string[]): boolean =>
+  nouns.length > 0 &&
+  nouns.every((noun) => headerWords.some((word) => sameWord(noun, word))) &&
+  headerWords.every((word) => nouns.some((noun) => sameWord(noun, word)));
+
+/** 二つの字が続けて一つの英数字の語になるか。 */
+const joinsWord = (left: string | undefined, right: string | undefined): boolean => WORD_CHAR.test(left ?? "") && WORD_CHAR.test(right ?? "");
+
+const boundedAt = (text: string, total: string, index: number): boolean =>
+  !joinsWord(text[index - 1], total[0]) && !joinsWord(total.at(-1), text[index + total.length]);
+
+/** 名詞に添える語を、語の頭（修得単位の修得）と尻から除く。英数字の語の途中（earnedincome）では切らない。 */
+const withoutNounQualifiers = (word: string, before: ReadonlySet<string>, after: ReadonlySet<string>): string => {
+  const prefix = [...before].find((qualifier) => qualifier.length > 0 && word.startsWith(qualifier) && !joinsWord(qualifier.at(-1), word[qualifier.length]));
+  const rest = prefix === undefined ? word : word.slice(prefix.length);
+  const suffix = [...after].find(
+    (qualifier) => qualifier.length > 0 && rest.endsWith(qualifier) && !joinsWord(rest[rest.length - qualifier.length - 1], qualifier[0]),
+  );
+  return suffix === undefined ? rest : rest.slice(0, rest.length - suffix.length);
+};
+
+/** 数を書いた升。強調の印と負の印（-、▲）と通貨の記号は、数の前に置ける。 */
+const NUMBER_CELL = /^[*_]*[-−▲△]?[ \t]?[$€£¥￥]?[ \t]?[-−]?\p{N}/u;
+
+/** 表の行の升。行頭の区切り（|）の前は升にしない。 */
+const cellsOf = (row: string): string[] => row.trim().replace(/^\|/u, "").split(CELL_SEPARATOR);
+
+/** 合計の行が数を書いた列の見出し。最初の列（合計の語を書いた列）は除く。 */
+const summedColumnHeaders = (row: string, header: string): string[] => {
+  const headers = cellsOf(header);
+  return cellsOf(row)
+    .map((cell, column) => ({ cell: cell.trim(), column }))
+    .filter(({ cell, column }) => column > 0 && NUMBER_CELL.test(cell))
+    .map(({ column }) => headers[column] ?? "");
+};
+
+type Split = { readonly before: readonly string[]; readonly after: readonly string[] };
+
+/** 見出しの中の合計の語の位置ごとに、その前と後ろの語。日本語の「控除合計」は、合計の語の前の「控除」を一語にする。 */
+const splitsAround = (text: string, total: string): Split[] =>
+  Array.from({ length: text.length }, (_, index) => index)
+    .filter((index) => total.length > 0 && text.startsWith(total, index) && boundedAt(text, total, index))
+    .map((index) => ({ before: wordsOf(text.slice(0, index)), after: wordsOf(text.slice(index + total.length)) }));
+
+/**
+ * 合計の語に、添える語のほかに名詞（控除、deductions）を付けた見出しが、表の見出しが名指す項目の合計か。名指すのは、最初の列の
+ * 見出し（控除項目の表の控除合計）か、合計の行が数を書いたどの列の見出し（単位数の列の修得単位合計）でもよい。名詞が見出しに
+ * 無ければ、別の種類の量（Total tax、Total area）かもしれないので読まない。
+ */
+/** 合計の語の前後の語から、合計の語に添える語を除き、残った名詞から名詞に添える語（修得、earned）を除く。 */
+const nounsOf = (split: Split, words: TotalLineWords): string[] => {
+  const before = allowedOn("before", words.qualifiers);
+  const after = allowedOn("after", words.qualifiers);
+  const nounBefore = allowedOn("before", words.nounQualifiers ?? []);
+  const nounAfter = allowedOn("after", words.nounQualifiers ?? []);
+  return [...split.before.filter((word) => !before.has(word)), ...split.after.filter((word) => !after.has(word))]
+    .map((word) => withoutNounQualifiers(word, nounBefore, nounAfter))
+    .filter((word) => word.length > 0);
+};
+
+const isUnsummed = (nouns: readonly string[], unsummedNouns: readonly string[]): boolean =>
+  nouns.some((noun) => unsummedNouns.some((word) => sameWord(noun, word.toLowerCase())));
+
+/**
+ * 合計の語に、添える語のほかに名詞（控除、deductions）を付けた見出しが、表の見出しが名指す項目の合計か。名指すのは、最初の列の
+ * 見出し（控除項目の表の控除合計）か、合計の行が数を書いたどの列の見出し（単位数の列の修得単位合計）でもよい。名詞が見出しに
+ * 無ければ、別の種類の量（Total tax、Total area）かもしれないので読まない。
+ */
+const isNamedTotal = (text: string, words: TotalLineWords, header: string): boolean => {
+  const label = labelWords(text).join(" ");
+  const firstColumn = labelWords(header);
+  const columns = summedColumnHeaders(text, header).map(labelWords);
+  const namesTotal = (nouns: readonly string[]): boolean =>
+    !isUnsummed(nouns, words.unsummedNouns ?? []) &&
+    (namesEachOther(nouns, firstColumn) || (columns.length > 0 && columns.every((headerWords) => namesEachOther(nouns, headerWords))));
+  return words.labels.some((total) => splitsAround(label, total.toLowerCase()).some((split) => namesTotal(nounsOf(split, words))));
+};
+
+/** 合計の語だけか、合計の語に添える語だけを前後に置いた見出しか。 */
+const isPlainTotal = (text: string, words: TotalLineWords): boolean => {
+  if (isTotalLabel(text, words.labels)) return true;
+  if (words.qualifiers.length === 0) return false;
+  const label = labelWords(text);
+  return words.labels.some((total) => isQualifiedLabel(label, wordsOf(total), words.qualifiers));
+};
+
+/** 期間の語の端の英数字（inner）が、その外の字（outer）へ続くか。空白でない字（year-to-date の -）なら続くとみなす。 */
+const continuesWord = (inner: string | undefined, outer: string | undefined): boolean =>
+  WORD_CHAR.test(inner ?? "") && outer !== undefined && !SPACES.test(outer);
+
+/** 見出しの頭（before）か尻（after）から期間の語を除いた残り。語の途中（yearly の year、year-to-date の year）では切らない。 */
+export const withoutPeriod = (label: string, qualifier: TotalQualifier): string | undefined => {
+  const pattern = qualifier.pattern.toLowerCase();
+  if (pattern.length === 0) return undefined;
+  if (qualifier.position !== "after" && label.startsWith(pattern) && !continuesWord(pattern.at(-1), label[pattern.length]))
+    return label.slice(pattern.length).trim();
+  if (qualifier.position !== "before" && label.endsWith(pattern) && !continuesWord(pattern[0], label[label.length - pattern.length - 1]))
+    return label.slice(0, label.length - pattern.length).trim();
+  return undefined;
+};
+
+/**
+ * 合計が足す期間の語（年間、for the year）を見出しの頭か尻から除くと合計の行になるか（年間合計、年計、Total for the year、Year total）。
+ * 前の年の合計（前年合計、Prior-year total）は、期間の語が頭にも尻にも無いので読まない。
+ */
+export const isPeriodTotalLine = (text: string, words: TotalLineWords): boolean => {
+  if (isTotalLabel(text, words.periodLabels ?? [])) return true;
+  const label = labelWords(text).join(" ");
+  return (words.periodQualifiers ?? []).some((qualifier) => {
+    const rest = withoutPeriod(label, qualifier);
+    return rest !== undefined && rest.length > 0 && isPlainTotal(rest, words);
+  });
+};
+
+/**
+ * 合計の行か。合計の語で始まる行（Total、合計（月額））に加えて、合計の語に添える語だけを前後に置いた見出し
+ * （Total per month、Monthly total、Total due）も合計の行と読む。添える語でない語（Total area）が入れば読まない。
+ * 合計が足す期間の語を付けた見出し（年間合計、Total for the year）も合計の行と読む。
+ * 表の見出しの行（header）を渡せば、その見出しが名指す名詞を付けた見出し（控除項目の表の控除合計、単位数の列の修得単位合計）も合計の行と読む。
+ */
+export const isTotalLine = (text: string, words: TotalLineWords, header?: string): boolean =>
+  isPlainTotal(text, words) || isPeriodTotalLine(text, words) || (header !== undefined && isNamedTotal(text, words, header));
+
+/** 見出しの合計の語の位置ごとに、合計の語に添える語を除いた名詞。 */
+const nounSplitsOf = (text: string, words: TotalLineWords): string[][] => {
+  const label = labelWords(text).join(" ");
+  return words.labels.flatMap((total) => splitsAround(label, total.toLowerCase()).map((split) => nounsOf(split, words)));
+};
+
+/**
+ * 合計の語に、見出しが名指さなくても上の行の和と読める名詞（total-noun-listed）だけを付けた見出しか（差引合計、Total deductions）。
+ * 名詞は一語のまま比べる（差引支給合計の差引支給は読まない）。
+ */
+export const isListedTotal = (text: string, words: TotalLineWords): boolean => {
+  const listed = new Set((words.listedNouns ?? []).map((noun) => noun.toLowerCase()));
+  return nounSplitsOf(text, words).some((nouns) => nouns.length > 0 && nouns.every((noun) => listed.has(noun)));
+};
+
+/** 見出しが差し引きで決まる金額の名前（総支給額、Gross pay）そのものか。 */
+export const isAmountNameLine = (text: string, words: TotalLineWords): boolean => {
+  const label = labelWords(text).join(" ");
+  return (words.amountNames ?? []).some((name) => wordsOf(name).join(" ") === label);
+};
+
+/** 合計のような行か。合計の行、見出しのどこかに合計の語がある行（支給合計、Total earnings）、差し引きの名前の行（総支給額、Gross pay）。 */
+export const isTotalLikeLine = (text: string, words: TotalLineWords, header?: string): boolean =>
+  isTotalLine(text, words, header) || nounSplitsOf(text, words).length > 0 || isAmountNameLine(text, words);

package/src/structure/total-row-blank.ts

@@ -0,0 +1,23 @@
+// A total, subtotal or tax row of a priced table fills only the amount: its quantity and unit-price cells are blank
+// because they have nothing to say (| 合計 | | | 48,400円 |). Pure; the caller decides which rows are total rows.
+
+/** One body row: whether its first cell is a total or tax label, and each cell's text (undefined when blank). */
+export type BodyRow = { readonly total: boolean; readonly cells: readonly (string | undefined)[] };
+
+const FIGURE = /\p{Nd}/u;
+
+/** Whether every filled cell of a column, in the rows that are not totals, holds a figure, and at least one is filled. */
+const isFigureColumn = (rows: readonly BodyRow[], column: number): boolean => {
+  const filled = rows.filter((row) => !row.total).flatMap((row) => row.cells[column] ?? []);
+  return filled.length > 0 && filled.every((text) => FIGURE.test(text));
+};
+
+/** The amount column: the rightmost column after the first whose item rows all give a figure. Undefined when none does. */
+export const amountColumnOf = (rows: readonly BodyRow[], columns: number): number | undefined =>
+  Array.from({ length: columns }, (_unused, column) => column)
+    .slice(1)
+    .findLast((column) => isFigureColumn(rows, column));
+
+/** A blank a total row may leave: any cell but the amount, and only in a table that has an amount column to fill. */
+export const isTotalRowGap = (row: BodyRow, column: number, amountColumn: number | undefined): boolean =>
+  row.total && amountColumn !== undefined && column !== amountColumn;

package/src/structure/total.ts

@@ -1,5 +1,5 @@
 import type { StructureIssue } from "./issues.ts";
-import { runsOf, type Line } from "./runs.ts";
+import { runsOf, TABLE_RULE, type Line } from "./runs.ts";
 import { bareNumbersIn, CELL_SEPARATOR, NO_UNIT } from "./bare-numbers.ts";
 
 /**
@@ -8,7 +8,14 @@ import { bareNumbersIn, CELL_SEPARATOR, NO_UNIT } from "./bare-numbers.ts";
  * 小計と税のあとの総計のように、足し方が何通りかある。どの足し方でも合わないときだけ言う。
  * 表の升に数だけを書いた列（単位は見出しにある）も足す。そのときは上の行の升がどれも数でなければ足さない。年や番号の列を足さないため。
  */
-export type Amount = { readonly offset: number; readonly end: number; readonly value: number; readonly unit: string };
+export type Amount = {
+  readonly offset: number;
+  readonly end: number;
+  readonly value: number;
+  readonly unit: string;
+  /** 単位の付いた量（0.5 g）は、量の種類の一番小さい単位（mg）に直して足す。scale は書いた単位一つがその単位いくつか（g なら 1,000）。 */
+  readonly scale?: number;
+};
 
 const CENTS = 100;
 
@@ -25,7 +32,11 @@ const OPEN_PAREN_BEFORE = /[(（][ \t]?(?:[$€£¥￥][ \t]?)?$/u;
 type Cell = { readonly column: number; readonly unit: string };
 /** cents が undefined の金額は、符号が決まらない。 */
 type Placed = Amount & Cell & { readonly cents: number | undefined };
-type Entry = { readonly label: boolean; readonly amounts: readonly Placed[] };
+/**
+ * spanTotal: 合計が足す期間の語を付けた合計の行（年間合計、Total for the year）。
+ * closing: 見出しが名指さない名詞を付けた、表を締める合計の行（項目の表の差引合計）。上の行の一部の和とも比べる。
+ */
+type Entry = { readonly label: boolean; readonly spanTotal: boolean; readonly closing?: boolean; readonly amounts: readonly Placed[] };
 
 export const columnOf = (source: string, line: Line, offset: number): number => source.slice(line.start, offset).split(CELL_SEPARATOR).length - 1;
 
@@ -36,7 +47,7 @@ const isNegative = (source: string, line: Line, amount: Amount): boolean => {
 };
 
 /** 行の最初の文字列（表なら最初の列）から、強調の印と箇条書きの印を除いたもの。 */
-const leadingText = (text: string): string =>
+export const leadingText = (text: string): string =>
   text
     .replace(/^[ \t]*(?:[-*+]|\d{1,3}[.)])?[ \t]*\|?[ \t]*/u, "")
     .replace(/^[*_]+/u, "")
@@ -58,8 +69,41 @@ const centsOf = (source: string, line: Line, amount: Amount): number | undefined
   return Math.round(amount.value * CENTS) * (isNegative(source, line, amount) ? -1 : 1);
 };
 
-const entryOf = (source: string, line: Line, amounts: readonly Amount[], labels: readonly string[]): Entry => ({
-  label: isTotalLabel(source.slice(line.start, line.end), labels),
+/** 行が合計の行か。語彙で決める判定は呼ぶ側が渡す。header は表の見出しの行（無ければ undefined）。 */
+export type IsTotalLine = (text: string, header: string | undefined) => boolean;
+
+/** source の中で start から始まる行のすぐ前の行。 */
+const lineBefore = (source: string, start: number): { readonly start: number; readonly text: string } | undefined => {
+  if (start === 0) return undefined;
+  const begin = source.lastIndexOf("\n", start - 2) + 1;
+  return { start: begin, text: source.slice(begin, start - 1) };
+};
+
+/** 表の行のすぐ上が区切りの行（| --- |）なら、そのすぐ上の見出しの行。続けて書いた次の表の見出しも、ここで行ごとに拾う。 */
+const headerAbove = (source: string, line: Line): string | undefined => {
+  const rule = lineBefore(source, line.start);
+  if (line.kind !== "table" || rule === undefined || !TABLE_RULE.test(rule.text)) return undefined;
+  const header = lineBefore(source, rule.start);
+  return header?.text.includes("|") === true ? header.text : undefined;
+};
+
+/** 一つの並びに続けて書いた表を、見出しごとに分ける。下の表の合計に、上の表の行を足さないため。 */
+const tablesIn = (source: string, run: readonly Line[]): Line[][] =>
+  run.reduce<Line[][]>((tables, line, index) => {
+    const current = tables.at(-1);
+    if (current === undefined || (index > 0 && headerAbove(source, line) !== undefined)) tables.push([line]);
+    else current.push(line);
+    return tables;
+  }, []);
+
+/** 行が、合計が足す期間の語を付けた合計の行か（年間合計、Total for the year）。 */
+export type IsSpanTotal = (text: string) => boolean;
+
+type LineKinds = { readonly isTotal: (text: string) => boolean; readonly isSpanTotal: IsSpanTotal };
+
+const entryOf = (source: string, line: Line, amounts: readonly Amount[], kinds: LineKinds): Entry => ({
+  label: kinds.isTotal(source.slice(line.start, line.end)),
+  spanTotal: kinds.isSpanTotal(source.slice(line.start, line.end)),
   amounts: amounts
     .filter((amount) => amount.offset >= line.start && amount.offset <= line.end)
     .map((amount) => ({ ...amount, column: columnOf(source, line, amount.offset), cents: centsOf(source, line, amount) })),
@@ -114,6 +158,16 @@ const candidateSums = (above: RowsAbove): number[] => {
   return [sumOf(above.parts), sumOf(above.sinceLast), ...(last === undefined ? [] : [last + sumOf(above.sinceLast)])];
 };
 
+/**
+ * 表を締める合計の行の、ほかの足し方: 下から続けた項目の和（支給の行の下に控除の行を並べた表の控除合計）と、
+ * その上の項目の和からそれを引いた額（同じ表の差し引いた後の額）。
+ */
+const blockSums = (parts: readonly number[]): number[] =>
+  parts.flatMap((_, start) => {
+    const below = sumOf(parts.slice(start));
+    return start === 0 ? [below] : [below, sumOf(parts.slice(0, start)) - below];
+  });
+
 /** 項目が無く小計だけが並ぶ表は、小計の和。 */
 const reportedSum = (above: RowsAbove): number => (above.parts.length === 0 ? sumOf(above.totals) : (above.totals.at(-1) ?? 0) + sumOf(above.sinceLast));
 
@@ -169,6 +223,37 @@ export const shownTotal = (source: string, total: Amount, sumCents: number): Rec
 const readsAsSum = (cell: Cell, writtenCents: number, above: RowsAbove): boolean =>
   cell.unit !== NO_UNIT || above.parts.some((part) => part < 0) || above.parts.every((part) => part < writtenCents);
 
+/** 書いた数の小数の桁（0.25 g なら 2）。 */
+const decimalsOf = (written: string): number => /[.．](\d+)/u.exec(written.normalize("NFKC"))?.[1]?.length ?? 0;
+
+/** 見せる和の小数の桁の上限。合計より細かい単位の内訳（1 g の合計に 250 mg の内訳）の和を、合計の単位で見せるため。 */
+const MAX_SHOWN_DECIMALS = 3;
+
+/** 換算の倍率が割り切れない単位（8 oz + 8 oz = 1 lb）で、丸めの差を合うとみなす割合。 */
+const MEASURE_TOLERANCE = 1e-6;
+
+/** 単位の付いた量の合計。和は合計に書いた単位と書き方で見せる（1 g の合計に 300 mg と 0.6 g の内訳なら 0.9 g）。 */
+const measuredMismatch = (source: string, total: Placed, scale: number, sums: readonly number[], reported: number): StructureIssue[] => {
+  const number = source.slice(total.offset, total.end);
+  const digits = decimalsOf(number);
+  const written = total.value * CENTS;
+  if (sums.some((sum) => Math.abs(sum - written) <= Math.abs(written) * MEASURE_TOLERANCE)) return [];
+  const inTotalUnit = (cents: number): number => cents / CENTS / scale;
+  const sum = inTotalUnit(reported).toLocaleString("en-US", {
+    minimumFractionDigits: digits,
+    maximumFractionDigits: Math.max(digits, MAX_SHOWN_DECIMALS),
+    useGrouping: !UNGROUPED.test(number),
+  });
+  return [{ offset: total.offset, values: { written: number, sum: `${sum}${unitAfterNumber(number, total.unit)}` } }];
+};
+
+/** 一年の中の期間の数（四半期、月、週）。期間の合計が和のちょうどこの倍なら、内訳を一年に直した額と読む。二倍は書き誤りでも起きるので入れない。 */
+const SPAN_MULTIPLES: readonly number[] = [4, 12, 52];
+
+/** 書いた合計が、どれかの足し方の和を一年に直した額か（月額の内訳に年間合計）。 */
+const isSpanMultiple = (writtenCents: number, sums: readonly number[]): boolean =>
+  sums.some((sum) => SPAN_MULTIPLES.some((multiple) => sum !== 0 && writtenCents === sum * multiple));
+
 const mismatchesIn = (source: string, entries: readonly Entry[]): StructureIssue[] =>
   entries.flatMap((entry, index) => {
     if (!entry.label) return [];
@@ -176,16 +261,75 @@ const mismatchesIn = (source: string, entries: readonly Entry[]): StructureIssue
       const writtenCents = valueIn(entry, total);
       const above = windowAbove(entries.slice(0, index), total);
       if (typeof writtenCents !== "number" || above === undefined || !enoughRows(above) || !readsAsSum(total, writtenCents, above)) return [];
-      if (candidateSums(above).includes(writtenCents)) return [];
+      const sums = entry.closing === true ? [...candidateSums(above), ...blockSums(above.parts)] : candidateSums(above);
+      if (entry.spanTotal && isSpanMultiple(writtenCents, sums)) return [];
+      if (total.scale !== undefined) return measuredMismatch(source, total, total.scale, sums, reportedSum(above));
+      if (sums.includes(writtenCents)) return [];
       return [{ offset: total.offset, values: shownAmounts(source, total, reportedSum(above)) }];
     });
   });
 
-export const totalMismatches = (source: string, amounts: readonly Amount[], labels: readonly string[]): StructureIssue[] =>
+/**
+ * 表を締める合計の行を読む語彙。isListed: 見出しが名指さなくても上の行の和と読める合計か（差引合計、Total deductions）。
+ * isTotalLike: 合計のような行か（合計の行、支給合計、総支給額）。header は表の見出しの行。
+ */
+export type ClosingTotal = {
+  readonly isListed: (text: string) => boolean;
+  readonly isTotalLike: (text: string, header: string) => boolean;
+};
+
+/** 表の行の金額が、見出しの列（最初の升）のほかに一つの列だけにあり、どの行にも一つまでか。 */
+const oneAmountColumn = (source: string, table: readonly Line[], entries: readonly Entry[]): boolean => {
+  const valuesOf = (line: Line, entry: Entry): Placed[] => {
+    const labelColumn = source.slice(line.start, line.end).trimStart().startsWith("|") ? 1 : 0;
+    return entry.amounts.filter((amount) => amount.column > labelColumn);
+  };
+  const rows = table.map((line, index) => {
+    const entry = entries[index];
+    return entry === undefined ? [] : valuesOf(line, entry);
+  });
+  return rows.every((values) => values.length <= 1) && new Set(rows.flat().map((amount) => amount.column)).size === 1;
+};
+
+/**
+ * 表の最後の行が、表を締める合計の行か。見出しのある表で、最後の行が isListed の合計で、上に合計のような行が一つも無く、
+ * 金額の列が一つのときだけ。上に支給の合計や総支給額があれば、合計が表のどこからどこまでの和か決まらないので読まない。
+ */
+const closesTable = (source: string, table: readonly Line[], entries: readonly Entry[], header: string | undefined, closing: ClosingTotal): boolean => {
+  const texts = table.map((line) => source.slice(line.start, line.end));
+  const last = entries.at(-1);
+  const lastText = texts.at(-1);
+  if (header === undefined || last === undefined || lastText === undefined || last.label || !closing.isListed(lastText)) return false;
+  return !texts.slice(0, -1).some((text) => closing.isTotalLike(text, header)) && oneAmountColumn(source, table, entries);
+};
+
+/** 一つの表（見出しの下の行）の合計。名詞の付いた合計の行は、その表の見出しで読む。 */
+const tableMismatches = (
+  source: string,
+  table: readonly Line[],
+  amounts: readonly Amount[],
+  isTotal: IsTotalLine,
+  isSpanTotal: IsSpanTotal,
+  closing: ClosingTotal | undefined,
+): StructureIssue[] => {
+  const header = table[0] === undefined ? undefined : headerAbove(source, table[0]);
+  const kinds = { isTotal: (text: string): boolean => isTotal(text, header), isSpanTotal };
+  const entries = table.map((line) => entryOf(source, line, amounts, kinds));
+  if (closing === undefined || !closesTable(source, table, entries, header, closing)) return mismatchesIn(source, entries);
+  return mismatchesIn(
+    source,
+    entries.map((entry, index) => (index === entries.length - 1 ? { ...entry, label: true, closing: true } : entry)),
+  );
+};
+
+export const totalMismatches = (
+  source: string,
+  amounts: readonly Amount[],
+  isTotal: IsTotalLine,
+  isSpanTotal: IsSpanTotal = () => false,
+  closing?: ClosingTotal,
+): StructureIssue[] =>
   runsOf(source).flatMap((run) => {
     const inRun = [...amounts, ...bareNumbersIn(source, run)];
-    return mismatchesIn(
-      source,
-      run.map((line) => entryOf(source, line, inRun, labels)),
-    );
+    return tablesIn(source, run).flatMap((table) => tableMismatches(source, table, inRun, isTotal, isSpanTotal, closing));
   });