chaffjs 0.31.0 → 0.32.0

package/src/structure/bmi.ts

@@ -0,0 +1,133 @@
+/**
+ * bmi-mismatch: the deciding half. A BMI written next to the height and the weight of the same person, against the weight in
+ * kilograms divided by the square of the height in metres. Which labels name the three, and which units a height or a weight
+ * may be written in, is data (lexicons bmi-term, bmi-unit, unit-length, unit-mass). Pure.
+ */
+import { keyOf, labelKey, noteOf, readNumber, type TableCell, type TableRow } from "./ratio.ts";
+
+export type BodyKind = "height" | "weight" | "bmi";
+
+export type BodyTerm = { readonly pattern: string; readonly kind: BodyKind };
+
+/** A unit and its factor to the base unit the lexicon counts in (metres for a length, grams for a mass). */
+export type BodyUnit = { readonly pattern: string; readonly factor: number };
+
+export type BodyWords = {
+  readonly terms: readonly BodyTerm[];
+  readonly lengthUnits: readonly BodyUnit[];
+  readonly massUnits: readonly BodyUnit[];
+  readonly bmiUnits: readonly string[];
+};
+
+/** A measure as written, in the base unit: its value and the half step of its last written digit. */
+export type Measure = { readonly value: number; readonly half: number };
+
+/** A BMI as written: where it starts, its value and the number of its decimals. */
+export type WrittenBmi = { readonly start: number; readonly value: number; readonly decimals: number };
+
+export type BmiIssue = { readonly offset: number; readonly values: Readonly<Record<string, string>> };
+
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+const GRAMS_PER_KILOGRAM = 1000;
+/** Floating error must not push a BMI that sits on the edge of its rounding out of it. */
+const FLOAT_SLACK = 1e-9;
+
+/**
+ * The BMI the height and the weight give, when the written BMI cannot be it; undefined when it can. Every written figure
+ * stands for the half step of its last digit around it (22.0 is 21.95 to 22.05, 178 cm is 177.5 to 178.5 cm), and the
+ * BMI is compared with the whole range the height and weight can give: the lightest weight over the tallest height to the
+ * heaviest weight over the shortest height.
+ */
+export const bmiDisagreement = (bmi: WrittenBmi, height: Measure, weight: Measure): string | undefined => {
+  const shortest = height.value - height.half;
+  if (shortest <= 0 || weight.value <= 0) return undefined;
+  const lowest = Math.max(0, weight.value - weight.half) / (height.value + height.half) ** 2;
+  const highest = (weight.value + weight.half) / shortest ** 2;
+  const half = HALF * DECIMAL_BASE ** -bmi.decimals + FLOAT_SLACK;
+  if (bmi.value + half >= lowest && bmi.value - half <= highest) return undefined;
+  return (weight.value / height.value ** 2).toFixed(bmi.decimals);
+};
+
+const unitFactor = (unit: string, units: readonly BodyUnit[]): number | undefined => units.find((entry) => keyOf(entry.pattern) === keyOf(unit))?.factor;
+
+/** The unit a row label notes in brackets (身長（cm）, Weight (kg)), without the brackets. */
+const notedUnit = (label: string): string => noteOf(label).slice(1, -1);
+
+/**
+ * A cell read as a measure in the base unit: one plain number and a unit of the list after it, or nothing after it when the
+ * row label notes the unit. Anything else (a range, 約, a second number, a unit not listed) is not read, nor is a row whose
+ * label notes something other than a unit (Weight (last year)).
+ */
+export const cellMeasure = (text: string, label: string, units: readonly BodyUnit[]): Measure | undefined => {
+  const cell = readNumber(text);
+  const noted = notedUnit(label);
+  if (cell === undefined || cell.prefix !== "" || (noted !== "" && unitFactor(noted, units) === undefined)) return undefined;
+  const factor = unitFactor(cell.suffix === "" ? noted : cell.suffix, units);
+  return factor === undefined ? undefined : { value: cell.value * factor, half: HALF * DECIMAL_BASE ** -cell.decimals * factor };
+};
+
+/** The text without a BMI unit at its end. The unit is cut off before the number is read, as its ² is a digit after NFKC. */
+const withoutBmiUnit = (text: string, units: readonly string[]): string => {
+  const plain = text.normalize("NFKC").trim();
+  const unit = units.map((entry) => entry.normalize("NFKC")).find((entry) => plain.toLowerCase().endsWith(entry.toLowerCase()));
+  return unit === undefined ? plain : plain.slice(0, -unit.length);
+};
+
+/**
+ * A cell read as a BMI: one plain number, with nothing after it or a BMI unit (kg/m²). A row whose label notes something
+ * other than a BMI unit (BMI (percentile)) is not read.
+ */
+export const cellBmi = (cell: TableCell, label: string, units: readonly string[]): WrittenBmi | undefined => {
+  const noted = notedUnit(label);
+  if (noted !== "" && withoutBmiUnit(noted, units) !== "") return undefined;
+  const read = readNumber(withoutBmiUnit(cell.text, units));
+  if (read === undefined || read.prefix !== "" || read.suffix !== "") return undefined;
+  return { start: cell.start, value: read.value, decimals: read.decimals };
+};
+
+const kindOf = (row: TableRow, terms: readonly BodyTerm[]): BodyKind | undefined => terms.find((term) => keyOf(term.pattern) === labelKey(row.label))?.kind;
+
+/** The rows of one kind, from every group. */
+const rowsOfKind = (groups: readonly (readonly TableRow[])[], terms: readonly BodyTerm[], kind: BodyKind): { group: number; row: TableRow }[] =>
+  groups.flatMap((rows, group) => rows.filter((row) => kindOf(row, terms) === kind).map((row) => ({ group, row })));
+
+type Trio = { readonly height: TableRow; readonly weight: TableRow; readonly bmi: TableRow };
+
+/** The one height, weight and BMI row of a section, all in the same group; undefined when any is missing or written twice. */
+const trioOf = (groups: readonly (readonly TableRow[])[], terms: readonly BodyTerm[]): Trio | undefined => {
+  const only = (kind: BodyKind): { group: number; row: TableRow } | undefined => {
+    const found = rowsOfKind(groups, terms, kind);
+    return found.length === 1 ? found[0] : undefined;
+  };
+  const [height, weight, bmi] = [only("height"), only("weight"), only("bmi")];
+  if (height === undefined || weight === undefined || bmi === undefined) return undefined;
+  if (height.group !== bmi.group || weight.group !== bmi.group) return undefined;
+  return { height: height.row, weight: weight.row, bmi: bmi.row };
+};
+
+const sameWidth = (trio: Trio): boolean => trio.height.cells.length === trio.bmi.cells.length && trio.weight.cells.length === trio.bmi.cells.length;
+
+const columnIssue = (trio: Trio, column: number, words: BodyWords): BmiIssue[] => {
+  const [heightCell, weightCell, bmiCell] = [trio.height.cells[column], trio.weight.cells[column], trio.bmi.cells[column]];
+  if (heightCell === undefined || weightCell === undefined || bmiCell === undefined) return [];
+  const height = cellMeasure(heightCell.text, trio.height.label, words.lengthUnits);
+  const mass = cellMeasure(weightCell.text, trio.weight.label, words.massUnits);
+  const bmi = cellBmi(bmiCell, trio.bmi.label, words.bmiUnits);
+  if (height === undefined || mass === undefined || bmi === undefined) return [];
+  const weight = { value: mass.value / GRAMS_PER_KILOGRAM, half: mass.half / GRAMS_PER_KILOGRAM };
+  const computed = bmiDisagreement(bmi, height, weight);
+  return computed === undefined ? [] : [{ offset: bmi.start, values: { written: bmi.value.toFixed(bmi.decimals), computed } }];
+};
+
+/**
+ * One section of a document is one person. Its groups are its tables and, as one more group, its "label: value" lines, each
+ * read as a row of one cell. When the section has exactly one height, one weight and one BMI row, all in one group, the three
+ * are compared column by column. Two heights or two weights (two people, or a before and an after) leave it unread, and so
+ * does a table whose three rows have different numbers of cells (its columns may not line up).
+ */
+export const sectionBmiMismatches = (groups: readonly (readonly TableRow[])[], words: BodyWords): BmiIssue[] => {
+  const trio = trioOf(groups, words.terms);
+  if (trio === undefined || !sameWidth(trio)) return [];
+  return trio.bmi.cells.flatMap((_, column) => columnIssue(trio, column, words));
+};

package/src/structure/change-rate-table.ts

@@ -0,0 +1,135 @@
+// change-rate-mismatch in a table: a row with the earlier value, the later one and the rate of change, each in a column the
+// header names (「| 売上高 | 1,200 | 1,320 | 12.0% |」 under 前期 / 当期 / 増減率, "Prior year / Current year / YoY"). Pure.
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import { disagreeingRate } from "./change-rate.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+export type ColumnRole = "base" | "current" | "rate" | "change";
+export type ColumnWord = { readonly pattern: string; readonly role: ColumnRole };
+export type TableCell = Span & { readonly text: string };
+export type ChangeTable = { readonly header: readonly TableCell[]; readonly rows: readonly (readonly TableCell[])[] };
+
+/** Rate words first: 「前期比」 holds 前期 and "change vs prior year" holds "prior year", and both are rates. */
+const ROLE_ORDER: readonly ColumnRole[] = ["rate", "change", "base", "current"];
+const LATIN = /[a-z]/u;
+/** A calendar year in a heading (FY2025, 2025年3月期, 2026年度), not part of a longer number. */
+const YEAR = /(?<!\d|\d[.,])(?:1[89]|2[01])\d{2}(?!\d|[.,]\d)/gu;
+const PERCENT_MARK = /%/u;
+/** A rate cell: a sign (+, -, −, ▲, △), the number, and % when the cell carries it. 1.2pt, (5.0)% and — are not rates. */
+const RATE_CELL = /^([+\-−▲△])?\s*(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?\s*(%)?$/u;
+/** A value cell: the number with what is written around it (¥, $, 百万円, million), and no sign, bracket or %. */
+const VALUE_CELL = /^([^\d+\-−▲△()%]*?)(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?([^\d+\-−▲△()%]*)$/u;
+const NEGATIVE_SIGNS: ReadonlySet<string> = new Set(["-", "−", "▲", "△"]);
+const DECIMAL_BASE = 10;
+
+export const plain = (text: string): string => text.normalize("NFKC").replace(/[*_`]/gu, "").trim();
+
+/** A Latin word stands as a whole word (change is not in "exchange"); anything else as written. */
+export const holds = (heading: string, word: string): boolean => {
+  const key = plain(word).toLowerCase();
+  if (!LATIN.test(key)) return heading.includes(key);
+  return new RegExp(`(?<![a-z0-9])${escapeRegExp(key)}(?![a-z0-9])`, "u").test(heading);
+};
+
+const roleOf = (heading: string, words: readonly ColumnWord[]): ColumnRole | undefined => {
+  const key = plain(heading).toLowerCase();
+  return ROLE_ORDER.find((role) => words.some((word) => word.role === role && holds(key, word.pattern)));
+};
+
+const onlyIndex = (indexes: readonly number[]): number | undefined => (indexes.length === 1 ? indexes[0] : undefined);
+
+type Columns = { readonly base: number; readonly current: number; readonly rate: number; readonly percentOnly: boolean };
+
+/** Two columns each headed by one calendar year and no word of role: the earlier year's is the earlier value. */
+const datedColumns = (headings: readonly string[], roles: readonly (ColumnRole | undefined)[]): { base: number; current: number } | undefined => {
+  const dated = headings.flatMap((heading, index) => {
+    const years = [...plain(heading).matchAll(YEAR)].map((match) => Number(match[0]));
+    const [year] = years;
+    return years.length === 1 && year !== undefined && roles[index] === undefined ? [{ index, year }] : [];
+  });
+  const [first, second] = dated;
+  if (dated.length !== 2 || first === undefined || second === undefined || first.year === second.year) return undefined;
+  return first.year < second.year ? { base: first.index, current: second.index } : { base: second.index, current: first.index };
+};
+
+/** What a heading writes in brackets, less its numbers: 「（百万円）」, "(thousand yen)"; 「（2025年3月期）」 keeps only 「年月期」. */
+const BRACKET = /[()（）]/u;
+const bracketedOf = (heading: string): string =>
+  plain(heading)
+    .split(BRACKET)
+    .filter((_, index) => index % 2 === 1)
+    .map((inside) => inside.replace(/[\d.,]/gu, "").trim())
+    .join("|");
+
+/** The two period columns do not name different units in their headings ("FY2025 (thousand yen)", "FY2026 (million yen)"). */
+export const sameHeadingUnits = (base: string | undefined, current: string | undefined): boolean => bracketedOf(base ?? "") === bracketedOf(current ?? "");
+
+/** The one column of each role. A rate column is one headed by a rate word, else the one change column whose cells carry %. */
+export const columnsOf = (headings: readonly string[], words: readonly ColumnWord[]): Columns | undefined => {
+  const roles = headings.map((heading) => roleOf(heading, words));
+  const indexesOf = (role: ColumnRole): number[] => roles.flatMap((found, index) => (found === role ? [index] : []));
+  const rateColumn = onlyIndex(indexesOf("rate"));
+  const changeColumn = indexesOf("rate").length === 0 ? onlyIndex(indexesOf("change")) : undefined;
+  const rate = rateColumn ?? changeColumn;
+  const [base, current] = [onlyIndex(indexesOf("base")), onlyIndex(indexesOf("current"))];
+  const periods = base !== undefined && current !== undefined ? { base, current } : datedColumns(headings, roles);
+  if (rate === undefined || periods === undefined || !sameHeadingUnits(headings[periods.base], headings[periods.current])) return undefined;
+  return { ...periods, rate, percentOnly: rateColumn === undefined && !PERCENT_MARK.test(plain(headings[rate] ?? "")) };
+};
+
+const numberText = (whole: string, fraction: string): string => [whole, fraction].filter((part) => part !== "").join(".");
+
+type WrittenRate = { readonly sign: string; readonly value: number; readonly decimals: number; readonly digits: string };
+
+/** The signed rate a cell writes, undefined when it is not one (1.2pt, (5.0)%, —) or lacks the % its column needs. */
+export const rateIn = (text: string, percentOnly: boolean): WrittenRate | undefined => {
+  const match = RATE_CELL.exec(plain(text));
+  if (match === null || (percentOnly && match[4] === undefined)) return undefined;
+  const [, sign = "", whole = "", fraction = ""] = match;
+  const magnitude = Number(numberText(whole.replaceAll(",", ""), fraction));
+  const digits = numberText(whole, fraction);
+  return { sign, value: NEGATIVE_SIGNS.has(sign) ? -magnitude : magnitude, decimals: fraction.length, digits };
+};
+
+type WrittenValue = { readonly value: number; readonly step: number; readonly marks: string };
+
+/** The value a cell writes, with what stands around the number (¥, 百万円, million) as the unit to compare. */
+export const valueIn = (text: string): WrittenValue | undefined => {
+  const match = VALUE_CELL.exec(plain(text));
+  if (match === null) return undefined;
+  const [, before = "", whole = "", fraction = "", after = ""] = match;
+  const value = Number(numberText(whole.replaceAll(",", ""), fraction));
+  return { value, step: DECIMAL_BASE ** -fraction.length, marks: `${before.trim()}|${after.trim()}` };
+};
+
+/** The computed rate written the way the cell writes its sign: 「△5.3」 beside 「△5.0」, "+10.0" beside "+12.0". */
+const shownRate = (computed: number, written: WrittenRate): string => {
+  const magnitude = Math.abs(computed).toFixed(written.decimals);
+  const negative = NEGATIVE_SIGNS.has(written.sign) ? written.sign : "-";
+  if (computed < 0) return `${negative}${magnitude}`;
+  return `${written.sign === "+" ? "+" : ""}${magnitude}`;
+};
+
+const issueInRow = (row: readonly TableCell[], columns: Columns): StructureIssue[] => {
+  const [baseCell, currentCell, rateCell] = [row[columns.base], row[columns.current], row[columns.rate]];
+  const base = baseCell === undefined ? undefined : valueIn(baseCell.text);
+  const current = currentCell === undefined ? undefined : valueIn(currentCell.text);
+  const rate = rateCell === undefined ? undefined : rateIn(rateCell.text, columns.percentOnly);
+  if (rateCell === undefined || base === undefined || current === undefined || rate === undefined || base.marks !== current.marks) return [];
+  const computed = disagreeingRate(base, current, rate.value, rate.decimals);
+  if (computed === undefined) return [];
+  const offset = rateCell.start + (rateCell.text.length - rateCell.text.trimStart().length);
+  return [{ offset, values: { rate: `${rate.sign}${rate.digits}`, computed: shownRate(computed, rate) } }];
+};
+
+/** Each row whose rate of change the two values in the columns the header names do not give. */
+export const tableRateMismatches = (tables: readonly ChangeTable[], words: readonly ColumnWord[]): StructureIssue[] =>
+  tables.flatMap((table) => {
+    const columns = columnsOf(
+      table.header.map((cell) => cell.text),
+      words,
+    );
+    if (columns === undefined) return [];
+    return table.rows.filter((row) => row.length === table.header.length).flatMap((row) => issueInRow(row, columns));
+  });

package/src/structure/change-rate.ts

@@ -76,12 +76,6 @@ const isBaseFor = (figure: Figure, rate: Rate, marks: readonly BaseMark[]): bool
   return mark !== undefined && Math.min(distance(figure, rate), distance(mark, rate)) <= BASE_REACH;
 };
 
-/**
- * The later value is written before the rate (「1,200社となり、…20%増えました」"1,200 companies, up 20%") or marked as the
- * value reached (「1,200社に」"to 1,200"). Another amount after the rate is about something else ("…, and revenue was $1,300").
- */
-const isCurrentFor = (figure: Figure, rate: Rate, targets: readonly BaseMark[]): boolean => figure.end <= rate.start || markOf(figure, targets) !== undefined;
-
 /** The one sign the direction words beside the rate agree on. */
 const signNear = (rate: Rate, directions: readonly Direction[]): 1 | -1 | undefined => {
   const signs = new Set(directions.filter((direction) => distance(direction, rate) <= DIRECTION_REACH).map((direction) => direction.sign));
@@ -93,13 +87,26 @@ const signNear = (rate: Rate, directions: readonly Direction[]): 1 | -1 | undefi
  * The rates of change the two values allow. Each value may be off by half the step it is written to: 12億 is anything from
  * 11.5億 to 12.5億, so 12億 from 10億 is a rise of 9.5% to 31.6%, and only a rate outside that is a mistake.
  */
-const rateRange = (base: Figure, current: Figure): readonly [number, number] | undefined => {
+type Rounded = Pick<Figure, "value" | "step">;
+
+const rateRange = (base: Rounded, current: Rounded): readonly [number, number] | undefined => {
   const [baseLow, baseHigh] = [base.value - base.step * HALF, base.value + base.step * HALF];
   const [currentLow, currentHigh] = [current.value - current.step * HALF, current.value + current.step * HALF];
   if (baseLow <= 0) return undefined;
   return [(currentLow / baseHigh - 1) * PERCENT, (currentHigh / baseLow - 1) * PERCENT];
 };
 
+/**
+ * The rate in percent the two values give, when the written rate (signed, with its decimals) is one their rounding cannot
+ * reach; undefined when it can, or when the earlier value may be zero or below.
+ */
+export const disagreeingRate = (base: Rounded, current: Rounded, written: number, decimals: number): number | undefined => {
+  const range = rateRange(base, current);
+  const slack = HALF * DECIMAL_BASE ** -decimals;
+  if (range === undefined || (written >= range[0] - slack && written <= range[1] + slack)) return undefined;
+  return (current.value / base.value - 1) * PERCENT;
+};
+
 type Pair = { readonly base: Figure; readonly current: Figure };
 /** One sentence's parts, with the rate: the one percentage that has a word of direction beside it. */
 type Reading = ChangeText & { readonly rate: Rate; readonly sign: 1 | -1 };
@@ -110,16 +117,48 @@ const brokenBetween = (text: Reading, one: Span, other: Span): boolean => {
   return text.breaks.some((word) => within(gap, word));
 };
 
+/** right follows left closely, with no value, rate or word of another subject or clause between them. */
+const followsClosely = (text: Reading, left: Span, right: Span, reach: number): boolean => {
+  const gap = gapBetween(left, right);
+  if (gap.start > gap.end || gapLength(text.source, gap) > reach) return false;
+  return ![...text.figures, ...text.rates, ...text.breaks].some((span) => within(gap, span));
+};
+
+/**
+ * The later value is written before the rate (「1,200社となり、…20%増えました」"1,200 companies, up 20%") or marked as the
+ * value reached right after the rate or the earlier value (「から20%増加し、1,200社となりました」"from 1,000 to 1,200"), in the
+ * same clause. Another amount after the rate is about something else ("…, and revenue was $1,300", 「…増加し、利益は300万円に」).
+ */
+const isCurrentFor = (text: Reading, figure: Figure, base: Figure): boolean => {
+  if (figure.end <= text.rate.start) return true;
+  const from = text.rate.end < base.end && base.end <= figure.start ? base : text.rate;
+  return markOf(figure, text.targets) !== undefined && followsClosely(text, from, figure, BASE_REACH) && !brokenBetween(text, text.rate, figure);
+};
+
 /** The earlier value marked beside the rate, and the one value in its unit before the rate or marked as reached. */
 const besideRate = (text: Reading): Pair | undefined => {
   const bases = text.figures.filter((figure) => isBaseFor(figure, text.rate, text.marks) && !brokenBetween(text, figure, text.rate));
   const [base] = bases;
   if (bases.length !== 1 || base === undefined) return undefined;
-  const currents = text.figures.filter((figure) => figure !== base && figure.unit === base.unit && isCurrentFor(figure, text.rate, text.targets));
+  const currents = text.figures.filter((figure) => figure !== base && figure.unit === base.unit && isCurrentFor(text, figure, base));
   const [current] = currents;
   return currents.length === 1 && current !== undefined ? { base, current } : undefined;
 };
 
+/**
+ * The value reached right after the rate, and the earlier value right after it ("rose 12% to $2,640 million from $2,400
+ * million"): the earlier value stands too far from the rate to be read beside it.
+ */
+const reachedThenBase = (text: Reading): Pair | undefined => {
+  const pairs = text.figures.flatMap((current, index) => {
+    const base = text.figures[index + 1];
+    if (base?.unit !== current.unit || markOf(current, text.targets) === undefined || markOf(base, text.marks) === undefined) return [];
+    return followsClosely(text, text.rate, current, BASE_REACH) && followsClosely(text, current, base, PAIR_GAP) ? [{ base, current }] : [];
+  });
+  const [pair] = pairs;
+  return pairs.length === 1 ? pair : undefined;
+};
+
 const yearsBeside = (text: Reading, figure: Figure, side: "before" | "after", bound: Span): Period[] =>
   text.periods.filter((period) => {
     const [left, right] = side === "before" ? [period, figure] : [figure, period];
@@ -205,19 +244,17 @@ const readingIn = (text: ChangeText, sentence: Span): Reading | undefined => {
 
 const issueIn = (text: ChangeText, sentence: Span): StructureIssue[] => {
   const reading = readingIn(text, sentence);
-  const pair = reading === undefined ? undefined : (besideRate(reading) ?? beforeRate(reading));
-  const range = pair === undefined ? undefined : rateRange(pair.base, pair.current);
-  if (reading === undefined || pair === undefined || range === undefined) return [];
+  const pair = reading === undefined ? undefined : (besideRate(reading) ?? beforeRate(reading) ?? reachedThenBase(reading));
+  if (reading === undefined || pair === undefined) return [];
   const { rate, sign } = reading;
-  const written = sign * rate.value;
-  const slack = HALF * DECIMAL_BASE ** -rate.decimals;
-  if (written >= range[0] - slack && written <= range[1] + slack) return [];
-  const computed = Math.abs((pair.current.value / pair.base.value - 1) * PERCENT).toFixed(rate.decimals);
-  return [{ offset: rate.start, values: { rate: String(rate.value), computed } }];
+  const computed = disagreeingRate(pair.base, pair.current, sign * rate.value, rate.decimals);
+  if (computed === undefined) return [];
+  return [{ offset: rate.start, values: { rate: String(rate.value), computed: Math.abs(computed).toFixed(rate.decimals) } }];
 };
 
 /**
  * Each sentence with one rate of change and its direction, and the two values it is computed from, that disagree: the
- * earlier value marked beside the rate, or the two values written together right before it.
+ * earlier value marked beside the rate, the two values written together right before it, or the value reached and then
+ * the earlier one right after it.
  */
 export const changeRateMismatches = (text: ChangeText): StructureIssue[] => text.sentences.flatMap((sentence) => issueIn(text, sentence));

package/src/structure/closing-balance.ts

@@ -0,0 +1,104 @@
+/**
+ * closing-balance-mismatch: the deciding half. A closing balance (当月末残高, Closing balance) against the opening balance
+ * (前月末残高, Opening balance) plus the total paid in (お預入れ合計, Total deposits) less the total paid out (お引出し合計,
+ * Total withdrawals), written in the same table or the same section. Which words name them is data (lexicon
+ * closing-balance-label, grouped opening / inflow / outflow / closing); an amount is read as net-amount-mismatch reads one.
+ * Pure.
+ */
+import { keyOf, labelKey, noteOf } from "./ratio.ts";
+import { amountOf, isExact, shown, type LabelledLine, type NetAmount, type NetCell, type NetIssue, type NetWords } from "./net-amount.ts";
+
+export const BALANCE_ROLES = ["opening", "inflow", "outflow", "closing"] as const;
+export type BalanceRole = (typeof BALANCE_ROLES)[number];
+
+export type BalanceWords = Pick<NetWords, "magnitudes" | "percentUnits"> & { readonly labels: Readonly<Record<BalanceRole, readonly string[]>> };
+
+export type BalanceAmount = NetAmount & { readonly role: BalanceRole };
+
+const DECIMAL_BASE = 10;
+const HALF = 0.5;
+/** Four amounts each rounded on their own to nearest may leave the sum off by up to two steps of the coarsest digit. */
+const ROUNDED_STEPS = 2;
+
+export const balanceRoleOf = (label: string, words: BalanceWords): BalanceRole | undefined =>
+  BALANCE_ROLES.find((role) => words.labels[role].some((pattern) => keyOf(pattern) === labelKey(label)));
+
+/** The one amount of a role in a scope; undefined when the role is missing or written more than once. */
+const onlyAmount = (amounts: readonly BalanceAmount[], role: BalanceRole): BalanceAmount | undefined => {
+  const mine = amounts.filter((amount) => amount.role === role);
+  return mine.length === 1 ? mine[0] : undefined;
+};
+
+const allowedGap = (amounts: readonly BalanceAmount[], words: BalanceWords): number => {
+  const finest = Math.max(...amounts.map((amount) => amount.decimals));
+  const coarsest = Math.min(...amounts.map((amount) => amount.decimals));
+  const exact = amounts.every((amount) => isExact(amount, words));
+  return HALF * DECIMAL_BASE ** -finest + (exact ? 0 : ROUNDED_STEPS * DECIMAL_BASE ** -coarsest);
+};
+
+/**
+ * One scope: opening, inflow, outflow and closing each found once, all in one unit. The closing balance is reported when it
+ * is not opening + inflow − outflow beyond rounding. A sum below zero is not compared: an overdrawn balance is written with
+ * a sign, which is not read as an amount.
+ */
+export const closingMismatch = (amounts: readonly BalanceAmount[], words: BalanceWords): NetIssue | undefined => {
+  const found = BALANCE_ROLES.map((role) => onlyAmount(amounts, role));
+  const [opening, inflow, outflow, closing] = found;
+  if (opening === undefined || inflow === undefined || outflow === undefined || closing === undefined) return undefined;
+  const four = [opening, inflow, outflow, closing];
+  if (four.some((amount) => amount.unit !== closing.unit)) return undefined;
+  const decimals = Math.max(...four.map((amount) => amount.decimals));
+  const expected = Math.round((opening.value + inflow.value - outflow.value) * DECIMAL_BASE ** decimals) / DECIMAL_BASE ** decimals;
+  if (!Number.isSafeInteger(Math.round(expected * DECIMAL_BASE ** decimals))) return undefined;
+  if (expected < 0 || Math.abs(expected - closing.value) <= allowedGap(four, words)) return undefined;
+  return { offset: closing.start, values: { written: closing.written, expected: shown(expected, closing, decimals) } };
+};
+
+const labelledCells = (labels: readonly NetCell[], values: readonly NetCell[], words: BalanceWords): BalanceAmount[] =>
+  labels.flatMap((label, column) => {
+    const role = balanceRoleOf(label.text, words);
+    const value = values[column];
+    const amount = role === undefined || value === undefined ? undefined : amountOf(value.text, value.start, noteOf(label.text), words);
+    return role === undefined || amount === undefined ? [] : [{ ...amount, role }];
+  });
+
+const issuesOf = (scopes: readonly (readonly BalanceAmount[])[], words: BalanceWords): NetIssue[] =>
+  scopes.flatMap((amounts) => {
+    const issue = closingMismatch(amounts, words);
+    return issue === undefined ? [] : [issue];
+  });
+
+/** A table whose header names the four columns (one month a row): each body row of the same width is one scope. */
+const byColumns = (header: readonly NetCell[], rows: readonly (readonly NetCell[])[], words: BalanceWords): NetIssue[] =>
+  issuesOf(
+    rows.filter((row) => row.length === header.length).map((row) => labelledCells(header, row, words)),
+    words,
+  );
+
+/** 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: BalanceWords): NetIssue[] => {
+  const labelled = rows.filter((row) => row[0] !== undefined && balanceRoleOf(row[0].text, words) !== undefined);
+  const width = labelled[0]?.length ?? 0;
+  if (labelled.length === 0 || labelled.some((row) => row.length !== width)) return [];
+  const columns = Array.from({ length: width - 1 }, (_, index) => index + 1);
+  return issuesOf(
+    columns.map((column) => labelled.flatMap((row) => labelledCells(row.slice(0, 1), row.slice(column, column + 1), words))),
+    words,
+  );
+};
+
+/**
+ * One table, read both ways. A table of transactions with a running balance (日付, お預入れ, お引出し, 残高) names none of the
+ * four totals in its header or its first column, so it gives no scope; running-balance-mismatch reads it row by row.
+ */
+export const tableClosingMismatches = (header: readonly NetCell[], rows: readonly (readonly NetCell[])[], words: BalanceWords): NetIssue[] => {
+  const issues = [...byColumns(header, rows, words), ...byRows(rows, words)];
+  return issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
+};
+
+/** The labelled lines of one section (前月末残高：412,350円). */
+export const sectionClosingMismatch = (lines: readonly LabelledLine[], words: BalanceWords): NetIssue | undefined =>
+  closingMismatch(
+    lines.flatMap((line) => labelledCells([{ start: 0, text: line.label }], [line.value], words)),
+    words,
+  );

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

@@ -0,0 +1,73 @@
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import type { PairedIssue, OrderDate } from "./labelled-date-order.ts";
+import { labelPairsOf, type LabelPair, type OrderLabel } from "./labelled-order.ts";
+import { linesOf, type Line } from "./lines.ts";
+
+/**
+ * Two dates of one table row that must come in order: a table whose header names an earlier-date column and a
+ * later-date column of one pair (| ご利用日 | 獲得ポイント | 有効期限 |, | Date | Points | Expires |). Each row is compared
+ * with itself only: a column is never paired with another table's. A header naming either side twice is not read, nor is
+ * a cell without exactly one full date, nor a row with a passed word (期限切れ, expired). A group with context words is
+ * read only when another header column contains one: a Date and Expiration date of a claims log are not a points table. Pure.
+ */
+
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
+
+const keyOf = (text: string): string => withoutEdgeMarks(text).normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
+
+type Column = { readonly index: number; readonly label: string };
+
+/** The one header column that is one of the words, and the word; undefined when none or more than one is. */
+const columnNamed = (header: readonly Cell[], words: readonly string[]): Column | undefined => {
+  const named = header.flatMap((cell, index) => {
+    const label = words.find((word) => keyOf(word) === keyOf(cell.text));
+    return label === undefined ? [] : [{ index, label }];
+  });
+  return named.length === 1 ? named[0] : undefined;
+};
+
+const oneDateIn = (cell: Cell | undefined, dates: readonly OrderDate[]): OrderDate | undefined => {
+  if (cell === undefined) return undefined;
+  const within = dates.filter((date) => date.offset >= cell.start && (date.end ?? date.offset) <= cell.end && FULL_DATE.test(date.value));
+  return within.length === 1 ? within[0] : undefined;
+};
+
+type Table = { readonly header: Line; readonly rows: readonly Line[] };
+
+/** A group's words without a position name what the table is about: another header column must contain one (獲得ポイント). */
+type GroupPair = LabelPair & { readonly context: readonly string[] };
+
+const groupPairsOf = (labels: readonly OrderLabel[]): GroupPair[] =>
+  [...new Set(labels.flatMap((label) => (label.group === undefined ? [] : [label.group])))].flatMap((group) => {
+    const ofGroup = labels.filter((label) => label.group === group);
+    const context = ofGroup.flatMap((label) => (label.position === undefined ? [keyOf(label.pattern)] : []));
+    return labelPairsOf(ofGroup).map((pair) => ({ ...pair, context }));
+  });
+
+const aboutContext = (header: readonly Cell[], context: readonly string[]): boolean =>
+  context.length === 0 || header.some((cell) => context.some((word) => keyOf(cell.text).includes(word)));
+
+const rowOutOfOrder = (row: Line, earlier: Column, later: Column, dates: readonly OrderDate[]): PairedIssue[] => {
+  const cells = cellsOf(row);
+  const from = oneDateIn(cells[earlier.index], dates);
+  const to = oneDateIn(cells[later.index], dates);
+  if (from === undefined || to === undefined || to.value >= from.value) return [];
+  const values = { later: to.value, earlier: from.value, later_label: later.label, earlier_label: earlier.label };
+  return [{ offset: Math.max(from.offset, to.offset), values, period: false }];
+};
+
+const rowsOutOfOrder = (table: Table, pair: GroupPair, dates: readonly OrderDate[], passed: readonly string[]): PairedIssue[] => {
+  const header = cellsOf(table.header);
+  const earlier = columnNamed(header, pair.earlier);
+  const later = columnNamed(header, pair.later);
+  if (earlier === undefined || later === undefined || !aboutContext(header, pair.context)) return [];
+  const reported = (row: Line): boolean => passed.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
+  return table.rows.flatMap((row) => (reported(row) ? [] : rowOutOfOrder(row, earlier, later, dates)));
+};
+
+/** Every row of a table whose later-column date is before its earlier-column date, for each pair the lexicon names. */
+export const columnDatesOutOfOrder = (source: string, dates: readonly OrderDate[], labels: readonly OrderLabel[], passed: readonly string[]): PairedIssue[] => {
+  const tables = tablesOf(linesOf(source));
+  return groupPairsOf(labels).flatMap((pair) => tables.flatMap((table) => rowsOutOfOrder(table, pair, dates, passed)));
+};

package/src/structure/compound-hours.ts

@@ -0,0 +1,49 @@
+import type { Amount } from "./total.ts";
+import type { TimeLength } from "../derived/time-lengths.ts";
+
+/**
+ * 時間と分を続けて書いた長さ（9時間30分、7 hours 30 minutes、7時間半）を、一つの時間の量（9.5時間）として足す。
+ * 木は 9時間 と 30分 を別の量に読むので、そのままでは 30分 が落ちた和を合計と比べてしまう。Pure.
+ */
+
+const MINUTES_PER_HOUR = 60;
+const HUNDREDTHS = 100;
+
+/** 足さない長さの単位に付ける印。どの量とも同じ単位にならないので、その長さがある列の和は取らない。 */
+const UNSUMMABLE = "?";
+
+/** 時間の百分の一で割り切れる長さか（15分、30分、45分）。20分は割り切れず、丸めの差が書き誤りに見える。 */
+const exactInHundredths = (minutes: number): boolean => Number.isInteger((minutes * HUNDREDTHS) / MINUTES_PER_HOUR);
+
+const unsummable = (length: TimeLength, unit: string): Amount => ({
+  offset: length.start,
+  end: length.end,
+  value: length.minutes / MINUTES_PER_HOUR,
+  unit: `${unit}${UNSUMMABLE}${String(length.start)}`,
+});
+
+/**
+ * 長さ一つを足す量に直す。時間の量の後ろに分か半を続けた長さは時間の量に、分が 60 以上か百分の一で割り切れなければ足さない量に、
+ * 木が量と読まなかった長さ（8 h）も足さない量にする。時間だけの長さ（8時間、木が数だけを量と読む 8 hours も）と、分から始まる長さ（90分）は、木の量のまま（undefined）。
+ */
+const compoundOf = (length: TimeLength, amounts: readonly Amount[], hourUnits: ReadonlySet<string>): Amount | undefined => {
+  const first = amounts.find((amount) => amount.offset === length.start);
+  if (first === undefined) return unsummable(length, "");
+  if (!hourUnits.has(first.unit)) return undefined;
+  const extraMinutes = length.minutes - first.value * MINUTES_PER_HOUR;
+  if (extraMinutes === 0) return undefined;
+  const readable = extraMinutes > 0 && extraMinutes < MINUTES_PER_HOUR && exactInHundredths(length.minutes);
+  if (!readable) return unsummable(length, first.unit);
+  return { offset: length.start, end: length.end, value: length.minutes / MINUTES_PER_HOUR, unit: first.unit };
+};
+
+/** amounts の中の、時間と分を続けて書いた長さを、一つの量に置き換える。hourUnits は時間の単位（時間、hours）。 */
+export const withCompoundHours = (amounts: readonly Amount[], lengths: readonly TimeLength[], hourUnits: readonly string[]): Amount[] => {
+  const units = new Set(hourUnits);
+  const compounds = lengths.flatMap((length) => {
+    const compound = compoundOf(length, amounts, units);
+    return compound === undefined ? [] : [compound];
+  });
+  const covered = (amount: Amount): boolean => compounds.some((compound) => amount.offset >= compound.offset && amount.offset < compound.end);
+  return [...amounts.filter((amount) => !covered(amount)), ...compounds].toSorted((left, right) => left.offset - right.offset);
+};