chaffjs 0.30.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/capacity-count.ts

@@ -0,0 +1,196 @@
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 書いた定員より多い申込・招待・参加の人数（定員：90名 と 95名の方にお申し込み、Capacity: 90 seats と 95 members have registered）。
+ * 定員の語（定員、先着、capacity、limited to）と人数の語（申込、招待者、have registered）を付けた数だけを読み、語の無い数は読まない。
+ * 比べるのは、文書に定員が一つ（一つの値）だけ書いてあるときだけ。二つ以上あれば、どの人数がどの定員のものか決められない。
+ * 数える物の組が違う数（30組と45名）は比べない。キャンセル待ちや抽選の語が文書にあれば、定員を超える申込は書いたとおりのことなので
+ * 言わない。一回あたりの数（各回定員20名、20 per session）は、定員でも人数でも比べない。全体の人数と一回の定員は比べられない。
+ * 去年や前回の人数（昨年は120名が参加）は、この催しの人数ではないので読まない。語は言語パッケージの語彙表から受け取る。
+ */
+
+/** 語彙表の一語。position は数のどちら側に書くか。group は語の種類（数える物の組、place の付いた定員の語）。 */
+export type CountMark = { readonly pattern: string; readonly position?: "before" | "after" | undefined; readonly group?: string | undefined };
+
+export type CapacityWords = {
+  /** 定員の語。group が place のものは、席の数（seats、places）にだけ付く（there are 25 places）。 */
+  readonly capacities: readonly CountMark[];
+  /** 申込・招待・参加の人数の語。 */
+  readonly counts: readonly CountMark[];
+  /** 数える物の語（名、人、席、people、seats）。group は組（head は人、place は席で人と比べる、party は組や家族）。 */
+  readonly units: readonly CountMark[];
+  /** 文書にあれば定員を超える申込を言わない語（キャンセル待ち、抽選、waitlist）。 */
+  readonly overflows: readonly string[];
+  /** 同じ行にあれば一回・一日あたりの数だと言う語（各回、per session）。 */
+  readonly perSession: readonly string[];
+  /** 人数と同じ行にあれば別の時の人数だと言う語（昨年、前回、last year）。 */
+  readonly otherOccasions: readonly string[];
+  /** 人数の後ろの句にあれば、申し込んでいない人の数だと言う語（していません、not）。 */
+  readonly negations: readonly string[];
+};
+
+/** 句の切れ目。人数の後ろの打ち消しは、ここまでで探す。 */
+const CLAUSE_BREAK = /[。．.!?！？;；、,，\n]/u;
+
+const clauseAfter = (source: string, end: number): string => {
+  const rest = source.slice(end);
+  const cut = CLAUSE_BREAK.exec(rest)?.index ?? rest.length;
+  return rest.slice(0, cut);
+};
+
+/** 語の付いた数。unit は数える物の組で、単位を書かない数（capacity 30）は undefined。line はその数の行。 */
+export type LabelledCount = {
+  readonly start: number;
+  readonly end: number;
+  readonly value: number;
+  readonly unit: string | undefined;
+  readonly line: string;
+};
+
+const DIGIT = "[0-9０-９]";
+/** 整数（1,200 は千二百）。小数と、桁区切りの続きの途中からは読まない。 */
+const NUMBER = new RegExp(`(?<!${DIGIT}|[.,，．])${DIGIT}+(?:[,，]${DIGIT}{3})*(?!${DIGIT}|[.,，．]${DIGIT})`, "gu");
+
+/** 記号と空白を除いて、語と数の間に挟んでよいもの（定員：90名、定員は25名、capacity of 30、registrations: 45）。 */
+const BEFORE_GAP_WORDS: ReadonlySet<string> = new Set(["", "は", "が", "of", "is", "was", "at"]);
+const isBeforeGap = (gap: string): boolean => BEFORE_GAP_WORDS.has(lower(gap.replaceAll(/[\s:：=]/gu, "")));
+/** 数（と単位）と後ろの和語の間に挟んでよいもの（95名の方にお申し込み、28名のお申し込み）。 */
+const AFTER_GAP_CJK = /^(?:の方|の皆様|の皆さま)?(?:[にがの]|から)?[おご]?$/u;
+/** 数（と単位）と後ろの英語の間の語は三つまで（95 members have registered、28 children had already booked）。 */
+const AFTER_GAP_LATIN = /^(?:\s+[A-Za-z]+){0,3}\s+$/u;
+/** 英語の単位は数との間に空白を一つ置ける（90 seats）。 */
+const LATIN_UNIT_GAP = /^\s?/u;
+const WORD_NEXT = /^\s?[A-Za-z]/u;
+
+const LETTER = /[A-Za-z]/u;
+
+const lower = (text: string): string => text.toLowerCase();
+
+const isLatin = (word: string): boolean => LETTER.test(word.charAt(0));
+
+const numberOf = (digits: string): number => Number(digits.normalize("NFKC").replaceAll(/[,，]/gu, ""));
+
+const startsWithWord = (text: string, word: string): boolean =>
+  lower(text).startsWith(lower(word)) && !(LETTER.test(word.slice(-1)) && LETTER.test(text.charAt(word.length)));
+
+const endsWithWord = (text: string, word: string): boolean =>
+  lower(text).endsWith(lower(word)) && !(LETTER.test(word.charAt(0)) && LETTER.test(text.charAt(text.length - word.length - 1)));
+
+/** 英字の語は語の切れ目で照らす（past が pastry に当たらない）。 */
+const contains = (text: string, words: readonly string[]): boolean =>
+  words.some((word) =>
+    [...lower(text).matchAll(new RegExp(escapeRegExp(lower(word)), "gu"))].some(
+      (match) => startsWithWord(text.slice(match.index), word) && endsWithWord(text.slice(0, match.index + word.length), word),
+    ),
+  );
+
+type Unit = { readonly mark: CountMark; readonly end: number };
+
+/** 数のすぐ後ろの単位と、単位の終わりの位置。長い語から照らす。 */
+const unitAfter = (line: string, end: number, units: readonly CountMark[]): Unit | undefined =>
+  units
+    .toSorted((left, right) => right.pattern.length - left.pattern.length)
+    .flatMap((mark) => {
+      const gap = isLatin(mark.pattern) ? (LATIN_UNIT_GAP.exec(line.slice(end))?.[0].length ?? 0) : 0;
+      return startsWithWord(line.slice(end + gap), mark.pattern) ? [{ mark, end: end + gap + mark.pattern.length }] : [];
+    })[0];
+
+const labelBefore = (head: string, marks: readonly CountMark[]): CountMark | undefined =>
+  marks
+    .filter((mark) => mark.position !== "after")
+    .find((mark) => {
+      const at = lower(head).lastIndexOf(lower(mark.pattern));
+      const end = at + mark.pattern.length;
+      return at !== -1 && endsWithWord(head.slice(0, end), mark.pattern) && isBeforeGap(head.slice(end));
+    });
+
+const labelAfter = (tail: string, marks: readonly CountMark[]): CountMark | undefined =>
+  marks
+    .filter((mark) => mark.position === "after")
+    .find((mark) => {
+      const at = lower(tail).indexOf(lower(mark.pattern));
+      if (at === -1 || !startsWithWord(tail.slice(at), mark.pattern)) return false;
+      return (isLatin(mark.pattern) ? AFTER_GAP_LATIN : AFTER_GAP_CJK).test(tail.slice(0, at));
+    });
+
+/**
+ * 語の付いた数か。和語の語には単位が要る（定員90 は読まない）。英語の数は単位を書かなくてよいが、後ろに単位でない語が続けば
+ * 別の物の数（capacity 30 cars）。place の付いた語は席の数にだけ付く。
+ */
+const isLabelled = (label: CountMark | undefined, unit: Unit | undefined, after: string, afterLabel: CountMark | undefined): label is CountMark => {
+  if (label === undefined || (label.group === "place" && unit?.mark.group !== "place")) return false;
+  if (unit !== undefined) return true;
+  return isLatin(label.pattern) && (afterLabel !== undefined || !WORD_NEXT.test(after));
+};
+
+/** 一行の中の、語の付いた数。 */
+const labelledIn = (line: string, lineStart: number, marks: readonly CountMark[], units: readonly CountMark[]): LabelledCount[] =>
+  [...line.matchAll(NUMBER)].flatMap((match) => {
+    const unit = unitAfter(line, match.index + match[0].length, units);
+    const end = unit?.end ?? match.index + match[0].length;
+    const after = line.slice(end);
+    const afterLabel = labelAfter(after, marks);
+    if (!isLabelled(labelBefore(line.slice(0, match.index), marks) ?? afterLabel, unit, after, afterLabel)) return [];
+    return [{ start: lineStart + match.index, end: lineStart + end, value: numberOf(match[0]), unit: unit?.mark.group, line }];
+  });
+
+const linesOf = (source: string): { readonly text: string; readonly start: number }[] => {
+  const starts = [0, ...[...source.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.map((start, index) => ({ text: source.slice(start, (starts[index + 1] ?? source.length + 1) - 1), start }));
+};
+
+const readAll = (source: string, marks: readonly CountMark[], units: readonly CountMark[]): LabelledCount[] =>
+  linesOf(source).flatMap((line) => labelledIn(line.text, line.start, marks, units));
+
+/** 席（place）は人（head）と同じ組として比べる。単位を書かない数は人の数。 */
+export const comparableGroup = (unit: string | undefined): string => (unit === undefined || unit === "place" ? "head" : unit);
+
+/** 文書の中の、定員の語の付いた数。一回あたりの定員は除く。 */
+export const capacityStatements = (source: string, words: CapacityWords): LabelledCount[] =>
+  readAll(source, words.capacities, words.units).filter((reading) => !contains(reading.line, words.perSession));
+
+/** 文書の中の、人数の語の付いた数。一回あたりの人数と、別の時の人数は除く。 */
+export const countStatements = (source: string, words: CapacityWords): LabelledCount[] =>
+  readAll(source, words.counts, words.units).filter(
+    (reading) =>
+      !contains(reading.line, words.perSession) &&
+      !contains(reading.line, words.otherOccasions) &&
+      !contains(clauseAfter(source, reading.end), words.negations),
+  );
+
+/** 定員を超える人数のうち一番多いもの。定員が一つの値でなければ、比べない。 */
+export const overCapacity = (
+  capacities: readonly LabelledCount[],
+  counts: readonly LabelledCount[],
+): { readonly capacity: LabelledCount; readonly over: LabelledCount } | undefined => {
+  const capacity = capacities[0];
+  if (capacity === undefined || capacities.some((other) => other.value !== capacity.value)) return undefined;
+  const over = counts
+    .filter((count) => comparableGroup(count.unit) === comparableGroup(capacity.unit) && count.value > capacity.value)
+    .toSorted((left, right) => right.value - left.value)[0];
+  return over === undefined ? undefined : { capacity, over };
+};
+
+/** その位置を含む一番小さい節の原文。節が無ければ文書の全体。 */
+export const sectionAround = (source: string, offset: number, sections: readonly Span[]): string => {
+  const around = sections
+    .filter((section) => section.start <= offset && offset < section.end)
+    .toSorted((left, right) => left.end - left.start - (right.end - right.start))[0];
+  return around === undefined ? source : source.slice(around.start, around.end);
+};
+
+/**
+ * 定員より多い人数。キャンセル待ちや抽選の語のある節の定員と人数は読まない（定員を超える申込が書いたとおりのこと）。
+ * 節に限るのは、別の節の「抽選会」（催しの一つ）で比べるのをやめないため。定員の位置を指す。sections は節の範囲。
+ */
+export const countsOverCapacity = (source: string, words: CapacityWords, sections: readonly Span[] = []): StructureIssue[] => {
+  const settled = (reading: LabelledCount): boolean => !contains(sectionAround(source, reading.start, sections), words.overflows);
+  const capacities = capacityStatements(source, words);
+  if (!capacities.every(settled)) return [];
+  const found = overCapacity(capacities, countStatements(source, words).filter(settled));
+  if (found === undefined) return [];
+  const { capacity, over } = found;
+  return [{ offset: capacity.start, values: { capacity: source.slice(capacity.start, capacity.end), count: source.slice(over.start, over.end) } }];
+};

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));