chaffjs 0.31.0 → 0.33.0

package/src/structure/meter-usage-read.ts

@@ -0,0 +1,139 @@
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { withoutTrailingNote, type MeterEntry, type MeterGroup, type MeterKind, type MeterUnitWord } from "./meter-usage.ts";
+
+/**
+ * 検針票の名前の付いた値を、まとまりごとに集める。まとまりは見出しから次の見出しまで。値は三つの書き方から読む。
+ * 「今回指示数：12,640」の行、行の見出しが名前の表（| 今回指示数 | 12,640 |）、列の見出しが名前の表
+ * （| 今回指示数 | 前回指示数 | ご使用量 |）。列の見出しが名前の表で本体が二行以上なら、行ごとに別のメーターとして一つの
+ * まとまりにする。名前は語彙表 meter-reading-label から、列の見出しの単位は meter-unit から来る。Pure.
+ */
+export type MeterLabel = { readonly pattern: string; readonly kind: MeterKind };
+
+export type MeterReadWords = { readonly labels: readonly MeterLabel[]; readonly units: readonly MeterUnitWord[] };
+
+const LIST_MARK = /^[-*+]\s/u;
+const DIGIT = /\d/u;
+
+const keyOf = (text: string): string => withoutEdgeMarks(text).normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
+
+const kindOf = (label: string, words: MeterReadWords): MeterKind | undefined => {
+  const key = withoutTrailingNote(keyOf(label));
+  return words.labels.find((word) => keyOf(word.pattern) === key)?.kind;
+};
+
+/** The unit a column heading names: the heading itself ("kWh") or its bracket ("指示数（kWh）"). */
+const headerUnitOf = (heading: string, words: MeterReadWords): string | undefined => {
+  const key = keyOf(heading);
+  const bracket = withoutTrailingNote(key);
+  const named = bracket === key ? key : key.slice(bracket.length).trim().slice(1, -1).trim();
+  return words.units.find((unit) => keyOf(unit.pattern) === named)?.unit;
+};
+
+/** "- 今回指示数：12,640" → the label and the value with where the value starts in the line; undefined without a colon. */
+const labelAndValue = (text: string): { label: string; value: string; at: number } | undefined => {
+  const colon = [text.indexOf(":"), text.indexOf("：")].filter((index) => index > 0).reduce((first, index) => Math.min(first, index), Infinity);
+  if (colon === Infinity) return undefined;
+  const label = text.slice(0, colon).trim().replace(LIST_MARK, "");
+  const rest = text.slice(colon + 1);
+  const value = rest.trim();
+  return value === "" ? undefined : { label, value, at: colon + 1 + rest.indexOf(value) };
+};
+
+const valueStart = (cell: Cell): number => cell.start + (cell.text.length - cell.text.trimStart().length);
+
+const entryOf = (kind: MeterKind, cell: Cell, headerUnit: string | undefined): MeterEntry => ({
+  kind,
+  value: cell.text.trim(),
+  offset: valueStart(cell),
+  ...(headerUnit === undefined ? {} : { headerUnit }),
+});
+
+/** | 今回指示数 | 12,640 |: the row's one cell with a figure in it is the value. */
+const rowEntry = (row: Line, headings: readonly string[], words: MeterReadWords): MeterEntry[] => {
+  const [label, ...rest] = cellsOf(row);
+  const kind = label === undefined ? undefined : kindOf(label.text, words);
+  if (kind === undefined) return [];
+  const withFigure = rest.flatMap((cell, index) => (DIGIT.test(cell.text) ? [{ cell, heading: headings[index + 1] ?? "" }] : []));
+  const [only, ...more] = withFigure;
+  if (only === undefined || more.length > 0) return [];
+  return [entryOf(kind, only.cell, headerUnitOf(only.heading, words))];
+};
+
+/** | 今回指示数 | 前回指示数 | ご使用量 | over one row of values: each named column gives the value under it. */
+const columnEntries = (row: Line, headings: readonly string[], words: MeterReadWords): MeterEntry[] =>
+  cellsOf(row).flatMap((cell, index) => {
+    const kind = kindOf(headings[index] ?? "", words);
+    return kind === undefined ? [] : [entryOf(kind, cell, headerUnitOf(headings[index] ?? "", words))];
+  });
+
+/** alone: a row of a table with one meter per row, a group by itself; only its own text says what happened to its meter. */
+type Placed = { readonly line: number; readonly entries: readonly MeterEntry[]; readonly alone: boolean; readonly text: string };
+
+const MIN_NAMED_COLUMNS = 2;
+
+const tableEntries = (table: { header: Line; rows: Line[] }, words: MeterReadWords): Placed[] => {
+  const headings = cellsOf(table.header).map((cell) => cell.text);
+  const named = headings.filter((heading) => kindOf(heading, words) !== undefined).length;
+  if (named >= MIN_NAMED_COLUMNS) {
+    const alone = table.rows.length > 1;
+    return table.rows.map((row) => ({ line: row.number, entries: columnEntries(row, headings, words), alone, text: row.text }));
+  }
+  return table.rows.map((row) => ({ line: row.number, entries: rowEntry(row, headings, words), alone: false, text: row.text }));
+};
+
+const lineEntry = (line: Line, words: MeterReadWords): Placed[] => {
+  if (line.text.includes("|")) return [];
+  const parts = labelAndValue(line.text);
+  const kind = parts === undefined ? undefined : kindOf(parts.label, words);
+  if (parts === undefined || kind === undefined) return [];
+  return [{ line: line.number, entries: [{ kind, value: parts.value, offset: line.start + parts.at }], alone: false, text: line.text }];
+};
+
+/** Each line's section: how many headings start at or before it. Index 0 is unused (lines count from 1). */
+const sectionsOf = (lines: readonly Line[], headingLines: readonly number[]): number[] => {
+  const headings = new Set(headingLines);
+  const sections = [0];
+  lines.forEach((line) => sections.push((sections.at(-1) ?? 0) + (headings.has(line.number) ? 1 : 0)));
+  return sections;
+};
+
+/**
+ * The groups of a document. text is the prose with its tables (headings blanked, offsets kept); headingLines are the line
+ * numbers of its headings, which split it into sections.
+ */
+export const meterGroups = (text: string, headingLines: readonly number[], words: MeterReadWords): MeterGroup[] => {
+  const lines = linesOf(text);
+  const tables = tablesOf(lines);
+  const inTable = new Set(tables.flatMap((table) => [table.header.number, ...table.rows.map((row) => row.number)]));
+  const placed = [
+    ...tables.flatMap((table) => tableEntries(table, words)),
+    ...lines.filter((line) => !inTable.has(line.number)).flatMap((line) => lineEntry(line, words)),
+  ].filter((entry) => entry.entries.length > 0);
+  if (placed.length === 0) return [];
+  const sections = sectionsOf(lines, headingLines);
+  const sectionOf = (line: number): number => sections[line] ?? 0;
+  const sectionLines = groupedBy(lines, (line) => sectionOf(line.number));
+  const alone = placed.filter((entry) => entry.alone).map((entry) => ({ entries: entry.entries, text: entry.text }));
+  const bySection = groupedBy(
+    placed.filter((entry) => !entry.alone).toSorted((left, right) => left.line - right.line),
+    (entry) => sectionOf(entry.line),
+  );
+  const shared = [...bySection].map(([section, entries]) => ({
+    entries: entries.flatMap((entry) => entry.entries),
+    text: (sectionLines.get(section) ?? []).map((line) => line.text).join("\n"),
+  }));
+  return [...shared, ...alone];
+};
+
+const groupedBy = <T>(items: readonly T[], keyOf: (item: T) => number): Map<number, T[]> => {
+  const groups = new Map<number, T[]>();
+  items.forEach((item) => {
+    const key = keyOf(item);
+    const group = groups.get(key);
+    if (group === undefined) groups.set(key, [item]);
+    else group.push(item);
+  });
+  return groups;
+};

package/src/structure/meter-usage.ts

@@ -0,0 +1,224 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * 検針票で、今回の指示数 − 前回の指示数（乗率があれば × 乗率）が、書いた使用量と合わない所。読む側（meter-usage-read.ts）が
+ * 一つのまとまり（見出しから見出しまで、または表の一行）ごとに、語彙表 meter-reading-label の名前の付いた値を集めて渡す。
+ * 今回・前回・使用量が一つずつそろい、どれも単位が読めて食い違わないときだけ比べる。今回が前回より小さいのは、メーターが
+ * 一巡したと書いてあるとき（同じ節で打ち消していないとき）だけ、前回の桁数の上限を足して読む。乗率が書いてあって読めないとき、メーターを取り替えたと書いて
+ * あるときは比べない。使用量は書いた桁までの丸め（切り捨て・四捨五入・切り上げ）を認める。Pure.
+ */
+export type MeterKind = "current" | "previous" | "usage" | "multiplier";
+
+export type MeterEntry = {
+  readonly kind: MeterKind;
+  /** The value as written after its label, or the cell's text. */
+  readonly value: string;
+  /** Where the value starts in the document. */
+  readonly offset: number;
+  /** The unit a table heading gives its column ("kWh"), when it gives one. */
+  readonly headerUnit?: string;
+};
+
+/** One bill's readings: the named values of a section or a table row, and the section's text (for a stated rollover). */
+export type MeterGroup = { readonly entries: readonly MeterEntry[]; readonly text: string };
+
+export type MeterUnitWord = { readonly pattern: string; readonly unit: string };
+
+export type MeterWords = {
+  /** Unit words and the unit they name (meter-unit): "m³" and "立方メートル" are both m3. */
+  readonly units: readonly MeterUnitWord[];
+  /** Words saying the meter went past its last figure (meter-event, group rollover). */
+  readonly rollover: readonly string[];
+  /** Words after a rollover word, in its clause, that deny it (「一巡していません」): meter-event, group rollover-negation-after. */
+  readonly rolloverNegationAfter: readonly string[];
+  /** Words before a rollover word, in its clause, that deny it ("has not rolled over"): group rollover-negation-before. */
+  readonly rolloverNegationBefore: readonly string[];
+  /** Words saying the meter was replaced (meter-event, group replaced): the two readings are of different meters. */
+  readonly replaced: readonly string[];
+};
+
+/** A number as written: its value in units of its last digit, and how many decimals it has. */
+type Reading = {
+  readonly scaled: bigint;
+  readonly decimals: number;
+  readonly digits: number;
+  readonly unit: string;
+  readonly grouped: boolean;
+  readonly written: string;
+};
+
+const LEADING_NUMBER = /^(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?(?![\d,])/u;
+const MULTIPLIER = /^[×x*]?\s*(\d+(?:\.\d+)?)\s*(?:倍|times)?$/u;
+const TEN = 10n;
+
+const normal = (text: string): string => text.normalize("NFKC").replace(/[*_`]/gu, "").trim();
+
+/** "36m3 (2か月分)" → "36m3": the bracket a value or a name ends with is a note. Brackets are ASCII once NFKC-normalised. */
+export const withoutTrailingNote = (text: string): string => {
+  const open = text.lastIndexOf("(");
+  return text.endsWith(")") && open >= 0 ? text.slice(0, open).trimEnd() : text;
+};
+
+const unitOf = (word: string, words: MeterWords): string | undefined => {
+  const wanted = word.toLowerCase();
+  if (wanted === "") return "";
+  return words.units.find((unit) => unit.pattern.normalize("NFKC").toLowerCase() === wanted)?.unit;
+};
+
+/** "12,640", "350kWh", "36m³（2か月分）". Undefined when the value is not one number, or its word is not a meter unit. */
+export const readingOf = (entry: MeterEntry, words: MeterWords): Reading | undefined => {
+  const written = normal(entry.value);
+  const number = withoutTrailingNote(written);
+  const match = LEADING_NUMBER.exec(number);
+  if (match === null) return undefined;
+  const [matched, whole = "", fraction = ""] = match;
+  const own = unitOf(number.slice(matched.length).trim(), words);
+  if (own === undefined) return undefined;
+  const digits = whole.replaceAll(",", "");
+  return {
+    scaled: BigInt(`${digits}${fraction}`),
+    decimals: fraction.length,
+    digits: digits.length,
+    unit: own === "" ? (entry.headerUnit ?? "") : own,
+    grouped: whole.includes(","),
+    written,
+  };
+};
+
+/** The multiplier as a scaled number ("×10" → 10, "1.5" → 15 with one decimal); undefined when it cannot be read. */
+export const multiplierOf = (value: string): { readonly scaled: bigint; readonly decimals: number } | undefined => {
+  const match = MULTIPLIER.exec(normal(value).toLowerCase());
+  if (match === null) return undefined;
+  const [whole = "", fraction = ""] = (match[1] ?? "").split(".");
+  return { scaled: BigInt(`${whole}${fraction}`), decimals: fraction.length };
+};
+
+const rescaled = (scaled: bigint, from: number, to: number): bigint => scaled * TEN ** BigInt(to - from);
+
+const ofKind = (entries: readonly MeterEntry[], kind: MeterKind): MeterEntry[] => entries.filter((entry) => entry.kind === kind);
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase().replaceAll("\u2019", "'");
+
+const mentions = (text: string, phrases: readonly string[]): boolean => {
+  const lowered = folded(text);
+  return phrases.some((phrase) => lowered.includes(folded(phrase)));
+};
+
+/** A negation across one of these is about something else: 「一巡しましたが、交換はしていません」. */
+const CLAUSE_END = /[、。,.;:!?\n]/u;
+const LATIN_LETTER = /\p{Script=Latin}/u;
+
+const startsOf = (text: string, phrase: string): number[] =>
+  phrase === "" ? [] : [...text.matchAll(new RegExp(escapeRegExp(phrase), "gu"))].map((match) => match.index);
+
+/** A Latin edge of the phrase must not run on into a letter: "not" is not in "notice", "never" not in "whenever". */
+const isWordAt = (text: string, phrase: string, start: number): boolean => {
+  const joins = (edge: string, neighbour: string): boolean => LATIN_LETTER.test(edge) && LATIN_LETTER.test(neighbour);
+  return !joins(phrase.at(0) ?? "", text[start - 1] ?? "") && !joins(phrase.at(-1) ?? "", text[start + phrase.length] ?? "");
+};
+
+/** "has not yet rolled over"; in "was not replaced and rolled over" the "not" is about something else. */
+const MAX_WORDS_AFTER_NEGATION = 1;
+
+type Reach = (text: string, end: number) => boolean;
+
+const anywhere: Reach = () => true;
+
+const nextToEnd: Reach = (text, end) =>
+  text
+    .slice(end)
+    .split(/\s+/u)
+    .filter((word) => word !== "").length <= MAX_WORDS_AFTER_NEGATION;
+
+const hasWord = (text: string, phrases: readonly string[], reaches: Reach): boolean =>
+  phrases.some((phrase) => {
+    const wanted = folded(phrase);
+    return startsOf(text, wanted).some((start) => isWordAt(text, wanted, start) && reaches(text, start + wanted.length));
+  });
+
+/** The rollover word at start is denied by a negation in its own clause: after it, or (in English) just before it. */
+const isDenied = (text: string, start: number, length: number, words: MeterWords): boolean => {
+  const before = text.slice(0, start).split(CLAUSE_END).at(-1) ?? "";
+  const after = text.slice(start + length).split(CLAUSE_END)[0] ?? "";
+  return hasWord(after, words.rolloverNegationAfter, anywhere) || hasWord(before, words.rolloverNegationBefore, nextToEnd);
+};
+
+/** Some rollover word is written and not denied in its clause. */
+export const statesRollover = (text: string, words: MeterWords): boolean => {
+  const lowered = folded(text);
+  return words.rollover.some((phrase) => {
+    const wanted = folded(phrase);
+    return startsOf(lowered, wanted).some((start) => !isDenied(lowered, start, wanted.length, words));
+  });
+};
+
+/** The units of the three agree: each is unstated or the same one. */
+const unitsAgree = (readings: readonly Reading[]): boolean => new Set(readings.map((reading) => reading.unit).filter((unit) => unit !== "")).size <= 1;
+
+/** current − previous at the readings' common scale; a stated rollover adds the previous reading's next power of ten. */
+const difference = (current: Reading, previous: Reading, scale: number, group: MeterGroup, words: MeterWords): bigint | undefined => {
+  const plain = rescaled(current.scaled, current.decimals, scale) - rescaled(previous.scaled, previous.decimals, scale);
+  if (plain >= 0n) return plain;
+  if (!statesRollover(group.text, words)) return undefined;
+  return plain + rescaled(TEN ** BigInt(previous.digits), 0, scale);
+};
+
+/** Usage is written to its last digit, so any value within one step of it, either side, is a rounding of it. */
+const withinRounding = (expected: bigint, usage: Reading, scale: number): boolean => {
+  const gap = expected - rescaled(usage.scaled, usage.decimals, scale);
+  const step = TEN ** BigInt(scale - usage.decimals);
+  return gap < step && gap > -step;
+};
+
+const shown = (scaled: bigint, decimals: number, grouped: boolean): string => {
+  const text = scaled.toString().padStart(decimals + 1, "0");
+  const whole = text.slice(0, text.length - decimals);
+  const groupedWhole = grouped ? BigInt(whole).toLocaleString("en-US") : whole;
+  return decimals === 0 ? groupedWhole : `${groupedWhole}.${text.slice(text.length - decimals)}`;
+};
+
+type Parts = { readonly current: MeterEntry; readonly previous: MeterEntry; readonly usage: MeterEntry; readonly multiplier: MeterEntry | undefined };
+
+/** One of each of the three, and at most one multiplier; two meters in one place are not told apart. */
+const partsOf = (group: MeterGroup): Parts | undefined => {
+  const [current, ...moreCurrent] = ofKind(group.entries, "current");
+  const [previous, ...morePrevious] = ofKind(group.entries, "previous");
+  const [usage, ...moreUsage] = ofKind(group.entries, "usage");
+  const [multiplier, ...moreMultiplier] = ofKind(group.entries, "multiplier");
+  if (current === undefined || previous === undefined || usage === undefined) return undefined;
+  if (moreCurrent.length + morePrevious.length + moreUsage.length + moreMultiplier.length > 0) return undefined;
+  return { current, previous, usage, multiplier };
+};
+
+const groupIssue = (group: MeterGroup, words: MeterWords): StructureIssue[] => {
+  const parts = partsOf(group);
+  if (parts === undefined || mentions(group.text, words.replaced)) return [];
+  const current = readingOf(parts.current, words);
+  const previous = readingOf(parts.previous, words);
+  const usage = readingOf(parts.usage, words);
+  const factor = parts.multiplier === undefined ? { scaled: 1n, decimals: 0 } : multiplierOf(parts.multiplier.value);
+  if (current === undefined || previous === undefined || usage === undefined || factor === undefined) return [];
+  if (!unitsAgree([current, previous, usage])) return [];
+  const readScale = Math.max(current.decimals, previous.decimals);
+  const diff = difference(current, previous, readScale, group, words);
+  if (diff === undefined) return [];
+  const scale = Math.max(readScale + factor.decimals, usage.decimals);
+  const expected = rescaled(diff * factor.scaled, readScale + factor.decimals, scale);
+  if (withinRounding(expected, usage, scale)) return [];
+  const times = parts.multiplier === undefined ? "" : ` × ${shown(factor.scaled, factor.decimals, false)}`;
+  return [
+    {
+      offset: parts.current.offset,
+      values: {
+        current: current.written,
+        previous: previous.written,
+        times,
+        expected: shown(expected, scale, current.grouped || usage.grouped),
+        usage: usage.written,
+      },
+    },
+  ];
+};
+
+export const meterUsageMismatches = (groups: readonly MeterGroup[], words: MeterWords): StructureIssue[] => groups.flatMap((group) => groupIssue(group, words));

package/src/structure/net-amount.ts

@@ -0,0 +1,243 @@
+/**
+ * net-amount-mismatch: the deciding half. A net amount (差引支給額, Net pay) or a taxable amount (課税対象額, Taxable income)
+ * against the gross amount (総支給額, Gross pay) minus the total of deductions (控除合計, Total deductions) written in the same
+ * table or the same section, or minus the parts of the deductions added up (手付金, 融資金). Which words name them is data
+ * (lexicon net-amount-label, grouped gross / deduction / deduction-part / net / taxable); nothing here knows a word of payroll or tax. Pure.
+ */
+import { keyOf, labelKey, noteOf, readNumber } from "./ratio.ts";
+import { withoutPeriod, type TotalQualifier } from "./total-line.ts";
+
+export const NET_ROLES = ["gross", "deduction", "deduction-part", "net", "taxable"] as const;
+export type NetRole = (typeof NET_ROLES)[number];
+
+/** A period word; group names its term, so "Fall" and "for the fall" are one term. */
+export type NetPeriod = TotalQualifier & { readonly group?: string | undefined };
+
+export type NetWords = {
+  readonly labels: Readonly<Record<NetRole, readonly string[]>>;
+  /** Words of the term an amount is for (net-amount-period: 前期分の, Fall, for the fall), cut off a label before it is read. */
+  readonly periods: readonly NetPeriod[];
+  /** Names read only with a period on them (Charges, as Fall charges): alone, the word is too common to name a role. */
+  readonly periodLabels?: Readonly<Partial<Record<NetRole, readonly string[]>>> | undefined;
+  /** Words of magnitude (千, million): an amount written in them is rounded. */
+  readonly magnitudes: readonly string[];
+  readonly percentUnits: readonly string[];
+};
+
+/** An amount as written in a cell or after a label: the text around its number is its unit. */
+export type NetAmount = {
+  readonly start: number;
+  readonly value: number;
+  readonly decimals: number;
+  readonly prefix: string;
+  readonly suffix: string;
+  /** What the amount is compared on: the marks around the number and the note of its label (Net pay (USD)). */
+  readonly unit: string;
+  /** The amount as written, and whether its number groups thousands with commas. */
+  readonly written: string;
+  readonly grouped: boolean;
+};
+
+/** label is the role's word, its note aside: amounts of one label are one value, and parts of different labels add up. */
+export type LabelledAmount = NetAmount & { readonly role: NetRole; readonly period?: string | undefined; readonly label?: string };
+
+export type NetIssue = { readonly offset: number; readonly values: Readonly<Record<string, string>> };
+
+const DECIMAL_BASE = 10;
+const HALF = 0.5;
+
+const roleOfKey = (key: string, words: NetWords, afterPeriod = false): NetRole | undefined =>
+  NET_ROLES.find((role) => [...words.labels[role], ...(afterPeriod ? (words.periodLabels?.[role] ?? []) : [])].some((pattern) => keyOf(pattern) === key));
+
+/** A label read: the role it names and, when a period was cut off it, which term that period is. */
+export type LabelRead = { readonly role: NetRole; readonly period?: string };
+
+const withPeriodCut = (key: string, period: NetPeriod, words: NetWords): LabelRead[] => {
+  const rest = withoutPeriod(key, { ...period, pattern: keyOf(period.pattern) });
+  const role = rest === undefined || rest === "" ? undefined : roleOfKey(rest, words, true);
+  return role === undefined ? [] : [{ role, period: period.group ?? keyOf(period.pattern) }];
+};
+
+/** The role a label names: the word alone or with a period on its side (前期分の納入額), its note in brackets aside. */
+export const readLabel = (label: string, words: NetWords): LabelRead | undefined => {
+  const key = labelKey(label);
+  const role = roleOfKey(key, words);
+  return role === undefined ? words.periods.flatMap((period) => withPeriodCut(key, period, words))[0] : { role };
+};
+
+export const roleOf = (label: string, words: NetWords): NetRole | undefined => readLabel(label, words)?.role;
+
+/** A note that may name a unit: no digit in it (手付金（契約時100万円支払済） describes), and a magnitude or a currency code. */
+const CURRENCY_CODE = /^[(（]\s*[A-Z]{3}\s*[)）]$/u;
+const DIGIT_IN_NOTE = /\d/u;
+
+/**
+ * The part of a label's note that is a unit. An amount without marks takes its unit from the note (総支給額（千円）). An
+ * amount with its own mark keeps only a note naming a magnitude or a currency (Gross pay ($ million), Net pay (USD)); any
+ * other note says what the amount is (手付金（契約時にお支払い済み）, Loan proceeds (from the buyer's lender)) and is not its unit.
+ */
+const unitNote = (marks: string, labelNote: string, words: Pick<NetWords, "magnitudes">): string => {
+  const note = keyOf(labelNote);
+  if (marks === "") return note;
+  const raw = labelNote.normalize("NFKC").trim();
+  const namesUnit = CURRENCY_CODE.test(raw) || words.magnitudes.some((word) => note.includes(keyOf(word)));
+  return namesUnit && !DIGIT_IN_NOTE.test(raw) ? note : "";
+};
+
+/** One plain number with its marks ("256,287円", "$4,301.01"); a percentage, a signed or a bracketed value is not an amount. */
+export const amountOf = (text: string, start: number, labelNote: string, words: Pick<NetWords, "percentUnits" | "magnitudes">): NetAmount | undefined => {
+  const cell = readNumber(text);
+  if (cell === undefined || words.percentUnits.some((unit) => keyOf(unit) === keyOf(cell.suffix))) return undefined;
+  const [prefix, suffix] = [keyOf(cell.prefix), keyOf(cell.suffix)];
+  const unit = `${prefix}|${suffix}|${unitNote(prefix + suffix, labelNote, words)}`;
+  return { start, value: cell.value, decimals: cell.decimals, prefix, suffix, unit, written: text.trim(), grouped: text.normalize("NFKC").includes(",") };
+};
+
+/** The one value of a role: all its amounts the same value in the same unit; undefined when there is none or they differ. */
+const onlyAmount = (amounts: readonly LabelledAmount[], role: NetRole): LabelledAmount | undefined => {
+  const mine = amounts.filter((amount) => amount.role === role);
+  const [first] = mine;
+  if (first === undefined) return undefined;
+  return mine.every((amount) => amount.value === first.value && amount.unit === first.unit) ? (mine.at(-1) ?? first) : undefined;
+};
+
+/** The parts of the deductions added up: one value per label (手付金 and 融資金), all in one unit; undefined otherwise. */
+const partsTotal = (amounts: readonly LabelledAmount[]): LabelledAmount | undefined => {
+  const parts = amounts.filter((amount) => amount.role === "deduction-part");
+  const labels = [...new Set(parts.map((amount) => amount.label ?? ""))];
+  const perLabel = labels.map((label) =>
+    onlyAmount(
+      parts.filter((amount) => (amount.label ?? "") === label),
+      "deduction-part",
+    ),
+  );
+  const values = perLabel.filter((amount): amount is LabelledAmount => amount !== undefined);
+  const [first] = values;
+  if (first === undefined || values.length !== perLabel.length || values.some((value) => value.unit !== first.unit)) return undefined;
+  const value = values.reduce((total, part) => total + part.value, 0);
+  return { ...first, value, decimals: Math.max(...values.map((part) => part.decimals)) };
+};
+
+/**
+ * What is taken off the gross: the total of deductions when the scope names one (控除合計), so parts written beside it are
+ * not counted twice; otherwise the parts added up (売買代金 − 手付金 − 融資金 = 残代金).
+ */
+const deductionOf = (amounts: readonly LabelledAmount[]): LabelledAmount | undefined =>
+  amounts.some((amount) => amount.role === "deduction") ? onlyAmount(amounts, "deduction") : partsTotal(amounts);
+
+/**
+ * The amount gross minus deductions is compared with: the net, or the taxable amount when the scope names no net. A scope
+ * that names both is a payslip whose deductions are what is paid out, not what tax is figured on, so its taxable amount
+ * is not compared.
+ */
+const resultOf = (amounts: readonly LabelledAmount[], netNamed: boolean): LabelledAmount | undefined => onlyAmount(amounts, netNamed ? "net" : "taxable");
+
+/** A mark of currency and no word of magnitude: the amount is exact. Anything else may be rounded to its last digit. */
+export const isExact = (amount: NetAmount, words: Pick<NetWords, "magnitudes">): boolean =>
+  amount.prefix + amount.suffix !== "" && !words.magnitudes.some((word) => `${amount.prefix} ${amount.suffix}`.includes(keyOf(word)));
+
+/**
+ * How far the written net may be from gross minus deductions. Exact amounts must agree to their last digit. Rounded ones
+ * (千円, $ million, a bare number whose unit is in a heading) may be off by one step of the coarsest last digit: each of
+ * the three is rounded on its own, and a difference of one step is what rounding down or to nearest can leave.
+ */
+export const allowedGap = (amounts: readonly NetAmount[], words: NetWords): number => {
+  const finest = Math.max(...amounts.map((amount) => amount.decimals));
+  const coarsest = Math.min(...amounts.map((amount) => amount.decimals));
+  return amounts.every((amount) => isExact(amount, words)) ? HALF * DECIMAL_BASE ** -finest : DECIMAL_BASE ** -coarsest + HALF * DECIMAL_BASE ** -finest;
+};
+
+const DIGIT = /\p{Nd}/u;
+const FULL_WIDTH_DIGIT = /[０-９]/u;
+/** The distance from an ASCII digit, comma or point to its full-width form (0 → ０, , → ，). */
+const FULL_WIDTH_OFFSET = 0xfee0;
+
+const toFullWidth = (number: string): string => [...number].map((char) => String.fromCodePoint((char.codePointAt(0) ?? 0) + FULL_WIDTH_OFFSET)).join("");
+
+/** The expected net, written the way the net is: the marks around its number, its digits, its decimals, its grouping. */
+export const shown = (value: number, like: NetAmount, decimals: number): string => {
+  const ascii = value.toLocaleString("en-US", { minimumFractionDigits: decimals, maximumFractionDigits: decimals, useGrouping: like.grouped });
+  const number = FULL_WIDTH_DIGIT.test(like.written) ? toFullWidth(ascii) : ascii;
+  const digits = [...like.written].flatMap((char, index) => (DIGIT.test(char) ? [index] : []));
+  const [first = 0, last = like.written.length - 1] = [digits[0], digits.at(-1)];
+  return `${like.written.slice(0, first)}${number}${like.written.slice(last + 1)}`;
+};
+
+/**
+ * One scope (a table column, a table row, a section's labelled lines): gross, deductions and net (or taxable) each found,
+ * each with one value, all in one unit. The net is reported when it is not gross minus deductions beyond rounding.
+ * netNamed is whether the scope has a net label, even one whose value is not a plain amount (a net written as —).
+ */
+export const netMismatch = (
+  amounts: readonly LabelledAmount[],
+  words: NetWords,
+  netNamed = amounts.some((amount) => amount.role === "net"),
+): NetIssue | undefined => {
+  const [gross, deduction, net] = [onlyAmount(amounts, "gross"), deductionOf(amounts), resultOf(amounts, netNamed)];
+  if (gross === undefined || deduction === undefined || net === undefined) return undefined;
+  if (new Set([gross, deduction, net].flatMap((amount) => amount.period ?? [])).size > 1) return undefined;
+  if (gross.unit !== deduction.unit || gross.unit !== net.unit) return undefined;
+  const expected = gross.value - deduction.value;
+  if (!Number.isSafeInteger(Math.round(gross.value * DECIMAL_BASE ** gross.decimals))) return undefined;
+  if (expected < 0 || Math.abs(expected - net.value) <= allowedGap([gross, deduction, net], words)) return undefined;
+  const decimals = Math.max(gross.decimals, deduction.decimals, net.decimals);
+  return { offset: net.start, values: { written: net.written, expected: shown(expected, net, decimals) } };
+};
+
+/** A table line read as its cells, each without its edge marks, by where it starts. */
+export type NetCell = { readonly start: number; readonly text: string };
+
+const namesNet = (labels: readonly NetCell[], words: NetWords): boolean => labels.some((label) => roleOf(label.text, words) === "net");
+const labelCellsOf = (lines: readonly LabelledLine[]): NetCell[] => lines.map((line) => ({ start: 0, text: line.label }));
+
+const labelledCells = (labels: readonly NetCell[], values: readonly NetCell[], words: NetWords): LabelledAmount[] =>
+  labels.flatMap((label, column) => {
+    const read = readLabel(label.text, words);
+    const value = values[column];
+    const amount = read === undefined || value === undefined ? undefined : amountOf(value.text, value.start, noteOf(label.text), words);
+    return read === undefined || amount === undefined ? [] : [{ ...amount, ...read, label: labelKey(label.text) }];
+  });
+
+/** A table whose header names the three columns: each body row of the same width is one scope. */
+const byColumns = (header: readonly NetCell[], rows: readonly (readonly NetCell[])[], words: NetWords): NetIssue[] =>
+  rows.flatMap((row) => {
+    if (row.length !== header.length) return [];
+    const issue = netMismatch(labelledCells(header, row, words), words, namesNet(header, words));
+    return issue === undefined ? [] : [issue];
+  });
+
+/** A table whose rows are labelled in their first cell: each column after the labels is one scope. */
+const byRows = (rows: readonly (readonly NetCell[])[], words: NetWords): NetIssue[] => {
+  const labelled = rows.filter((row) => row[0] !== undefined && roleOf(row[0].text, words) !== undefined);
+  const width = labelled[0]?.length ?? 0;
+  if (labelled.length === 0 || labelled.some((row) => row.length !== width)) return [];
+  return Array.from({ length: width - 1 }, (_, index) => index + 1).flatMap((column) => {
+    const amounts = labelled.flatMap((row) => labelledCells([row[0] ?? { start: 0, text: "" }], [row[column] ?? { start: 0, text: "" }], words));
+    const issue = netMismatch(
+      amounts,
+      words,
+      namesNet(
+        labelled.flatMap((row) => row.slice(0, 1)),
+        words,
+      ),
+    );
+    return issue === undefined ? [] : [issue];
+  });
+};
+
+/** One table, read both ways: its header naming the columns, and its first column naming the rows. */
+export const tableNetMismatches = (header: readonly NetCell[], rows: readonly (readonly NetCell[])[], words: NetWords): NetIssue[] => {
+  const issues = [...byColumns(header, rows, words), ...byRows(rows, words)];
+  return issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
+};
+
+/** A line that is a label and its amount (総支給額：117,380円, - Net pay: $1,396.41). */
+export type LabelledLine = { readonly label: string; readonly value: NetCell };
+
+/** The labelled lines of one section: each label that names a role, with its amount. */
+export const sectionNetMismatch = (lines: readonly LabelledLine[], words: NetWords): NetIssue | undefined =>
+  netMismatch(
+    lines.flatMap((line) => labelledCells([{ start: 0, text: line.label }], [line.value], words)),
+    words,
+    namesNet(labelCellsOf(lines), words),
+  );