chaffjs 0.31.0 → 0.33.0

package/src/structure/annual-pay.ts

@@ -0,0 +1,339 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * annual-pay-mismatch: a job posting's example annual pay that is not the monthly pay times twelve plus the bonus months
+ * (年収例 450万円 with 月給28万円 and 賞与 計3ヶ月分, where 28万 × 15 is 420万). The monthly pay and the bonus are the ones
+ * written on the annual line itself (月給28万円の場合), else the one reading the rest of the document gives. Two different
+ * readings, a reading that cannot be read plainly (a range of months, 各, 約, 以上, an open range) and an annual line or note
+ * that mentions overtime or allowances all leave the figure unchecked. A posting that mentions an annual salary (年俸) is
+ * not compared: its monthly pay may be the salary divided by 12, 14 or 16. The words come from the lexicons. Pure.
+ */
+
+/** One amount of money as read: its currency, its value, and the value of the word of scale written in it (万), if any. */
+export type PayAmount = {
+  readonly offset: number;
+  readonly end: number;
+  readonly currency: string;
+  readonly value: number;
+  readonly scale: number | undefined;
+};
+
+export type LabelKind = "example" | "salary" | "monthly" | "pay" | "bonus";
+
+export type PositionedWord = { readonly word: string; readonly position: "before" | "after" };
+
+export type AnnualPayWords = {
+  /** Labels by kind: an example annual pay (年収例), an annual salary (年俸), a monthly pay (月給), a pay that is monthly only beside a per-month word (給与), a bonus (賞与). */
+  readonly labels: Readonly<Record<LabelKind, readonly string[]>>;
+  /** Words that may stand between a label and its amount (は, of). */
+  readonly links: readonly string[];
+  /** Words that make a pay label monthly (a month, /月). */
+  readonly perMonth: readonly string[];
+  /** Words that say there is no bonus: after the label (なし, none) or before it (No bonus). */
+  readonly none: readonly PositionedWord[];
+  /** Words that make a bonus months count per payment (各, each); such a bonus is not read. */
+  readonly each: readonly string[];
+  /** Words of a bonus paid besides the stated one (別途, additional); such a bonus is not read. */
+  readonly extra: readonly string[];
+  /** Words that say a bonus is paid more than once a year (年2回, twice a year); with one, the months must be called a total. */
+  readonly times: readonly string[];
+  /** Words that call a bonus's months the year's total (合計, in total). */
+  readonly totals: readonly string[];
+  /** Words that say a pay holds overtime or allowances (残業, 手当, overtime); such a pay is not compared. */
+  readonly includes: readonly string[];
+  /** Words that make an amount or a count open-ended or approximate (約, 以上, from, or more). */
+  readonly markers: readonly PositionedWord[];
+  /** The word of a month after a count (ヶ月, months). */
+  readonly months: readonly string[];
+  /** Marks and words that join the two ends of a range (〜, to). */
+  readonly connectors: readonly string[];
+  /** Numbers written as words (three) and their values. */
+  readonly numberWords: readonly { readonly word: string; readonly value: number }[];
+};
+
+/** Two ends of a pay; a single amount has both ends the same. */
+export type Ends = { readonly low: number; readonly high: number };
+
+/** A pay as read: its ends, its currency, how it was written, and the rounding its written digits allow. */
+export type PayReading = { readonly offset: number; readonly ends: Ends; readonly currency: string; readonly written: string; readonly unit: number };
+
+export type BonusReading = { readonly months: number; readonly written: string };
+
+/** A pay or a bonus that is stated but cannot be read plainly. */
+type Unclear = { readonly unclear: true };
+const UNCLEAR: Unclear = { unclear: true };
+
+type Span = { readonly start: number; readonly end: number };
+type Label = Span & { readonly kind: LabelKind };
+type Count = Span & { readonly count: number; readonly marked: boolean };
+type Scope = { readonly label: Label; readonly end: number };
+type Context = { readonly text: string; readonly labels: readonly Label[]; readonly amounts: readonly PayAmount[]; readonly words: AnnualPayWords };
+type Posting = { readonly monthly: PayReading | undefined; readonly bonus: BonusReading | undefined };
+
+/** An annual pay written in plain digits ($72,000, 4,200,000円) may be rounded to a thousand of its currency. */
+export const PLAIN_ROUNDING = 1000;
+const MONTHS_A_YEAR = 12;
+const KINDS: readonly LabelKind[] = ["example", "salary", "monthly", "pay", "bonus"];
+const ANNUAL: readonly LabelKind[] = ["example", "salary"];
+const BONUS_STOPS: readonly LabelKind[] = ["example", "salary", "bonus"];
+/** How far from an amount or a count a marker (約, 以上) or the start of a range is looked for. */
+const MARKER_REACH = 12;
+
+const LATIN = /[A-Za-z]/u;
+const SEPARATORS = /[\s|｜:：=＝、，,・/／'’()（）[\]［］-]/gu;
+const PARENTHETICAL_WITHOUT_DIGITS = /[（(][^()（）0-9０-９]*[)）]/gu;
+const SENTENCE_END = /[。！？；;]|[.!?](?=\s|$)/u;
+const SENTENCE_SPLIT = /[。！？；;]|[.!?](?=\s)/u;
+const RANGE_START = /[0-9０-９A-Za-z一二三四五六七八九十]\s*$/u;
+const WORD_END = /[0-9A-Za-z]$/u;
+const DIGITS = "[0-9０-９]+(?:[.．][0-9０-９]+)?";
+
+const wordPattern = (word: string): string => {
+  const edgeStart = LATIN.test(word.charAt(0)) ? "(?<![A-Za-z])" : "";
+  const edgeEnd = LATIN.test(word.charAt(word.length - 1)) ? "(?![A-Za-z])" : "";
+  return `${edgeStart}${escapeRegExp(word)}${edgeEnd}`;
+};
+
+/** One alternation of the words, longest first so 年収例 wins over 年収. Undefined when there are none. */
+const alternation = (words: readonly string[]): string | undefined =>
+  words.length === 0
+    ? undefined
+    : words
+        .toSorted((left, right) => right.length - left.length)
+        .map(wordPattern)
+        .join("|");
+
+const occurrences = (text: string, words: readonly string[]): Span[] => {
+  const pattern = alternation(words);
+  if (pattern === undefined) return [];
+  return [...text.matchAll(new RegExp(pattern, "giu"))].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+};
+
+const contains = (text: string, words: readonly string[]): boolean => occurrences(text, words).length > 0;
+
+/** Whether only separators, bracketed words without digits and the given words stand in the gap (「：」, " of "). */
+export const isPlainGap = (gap: string, words: readonly string[]): boolean => {
+  const pattern = alternation(words);
+  const bare = gap.replace(PARENTHETICAL_WITHOUT_DIGITS, "");
+  return (pattern === undefined ? bare : bare.replace(new RegExp(pattern, "giu"), "")).replace(SEPARATORS, "") === "";
+};
+
+/** Every label in document order with its kind, read in one pass so a longer label (Annual salary) hides a shorter one in it (salary). */
+export const labelsIn = (text: string, words: AnnualPayWords): Label[] => {
+  const kinds = new Map(KINDS.flatMap((kind) => words.labels[kind].map((label): [string, LabelKind] => [label.toLowerCase(), kind])));
+  return occurrences(text, [...kinds.keys()]).flatMap((span) => {
+    const kind = kinds.get(text.slice(span.start, span.end).toLowerCase());
+    return kind === undefined ? [] : [{ ...span, kind }];
+  });
+};
+
+const lineStart = (text: string, offset: number): number => text.lastIndexOf("\n", offset - 1) + 1;
+
+const lineEnd = (text: string, offset: number): number => {
+  const end = text.indexOf("\n", offset);
+  return end === -1 ? text.length : end;
+};
+
+/** Where a label's statement ends: at the end of its sentence or line, or at the next label of one of the given kinds. */
+const statementEnd = (text: string, label: Label, labels: readonly Label[], stops: readonly LabelKind[]): number => {
+  const end = lineEnd(text, label.end);
+  const sentence = SENTENCE_END.exec(text.slice(label.end, end));
+  const next = labels.find((other) => other.start >= label.end && stops.includes(other.kind))?.start ?? end;
+  return Math.min(end, next, sentence === null ? end : label.end + sentence.index);
+};
+
+/** The sentence a scope's label is in, from its start to the end of the scope. */
+const sentenceOf = (text: string, scope: Scope): string => {
+  const head = text.slice(lineStart(text, scope.label.start), scope.label.start).split(SENTENCE_SPLIT).at(-1) ?? "";
+  return `${head}${text.slice(scope.label.start, scope.end)}`;
+};
+
+const amountsBetween = (amounts: readonly PayAmount[], start: number, end: number): PayAmount[] =>
+  amounts.filter((amount) => amount.offset >= start && amount.end <= end);
+
+const textBefore = (text: string, start: number): string =>
+  text
+    .slice(Math.max(0, start - MARKER_REACH), start)
+    .trimEnd()
+    .toLowerCase();
+
+const textAfter = (text: string, end: number): string =>
+  text
+    .slice(end, end + MARKER_REACH)
+    .trimStart()
+    .toLowerCase();
+
+/** Whether a marker stands right before the start (約450万円, about $72,000). */
+const markedBefore = (text: string, start: number, words: AnnualPayWords): boolean => {
+  const before = textBefore(text, start);
+  return words.markers.some((marker) => marker.position === "before" && before.endsWith(marker.word.toLowerCase()));
+};
+
+/** Whether a marker stands right after the end (400万円以上, $70,000 or more), or a range is left open there (400万円〜). */
+const markedAfter = (text: string, end: number, words: AnnualPayWords): boolean => {
+  const after = textAfter(text, end);
+  const marked = words.markers.some((marker) => marker.position === "after" && after.startsWith(marker.word.toLowerCase()));
+  return marked || words.connectors.some((connector) => after.startsWith(connector.toLowerCase()));
+};
+
+const isMarked = (text: string, span: Span, words: AnnualPayWords): boolean => markedBefore(text, span.start, words) || markedAfter(text, span.end, words);
+
+/** Whether a count or an amount is the upper end of a range (2〜3ヶ月, 2 to 3 months). */
+const endsRange = (text: string, start: number, words: AnnualPayWords): boolean => {
+  const before = text.slice(Math.max(0, start - MARKER_REACH), start).trimEnd();
+  return words.connectors.some((connector) => before.endsWith(connector) && RANGE_START.test(before.slice(0, -connector.length)));
+};
+
+/** The second end of a range that starts with this amount (25万円〜30万円), if one follows; a reversed range is none. */
+const rangeEnd = (text: string, first: PayAmount, next: PayAmount | undefined, words: AnnualPayWords): PayAmount | undefined => {
+  if (next === undefined || next.currency !== first.currency || next.value < first.value) return undefined;
+  const joint = text.slice(first.end, next.offset).trim().toLowerCase();
+  return words.connectors.some((connector) => connector.toLowerCase() === joint) ? next : undefined;
+};
+
+const decimalsOf = (written: string): number => /[.．]([0-9０-９]+)/u.exec(written)?.[1]?.length ?? 0;
+
+/** The rounding an amount's digits allow: one of its last written place with a word of scale (420万 to a 万), else a thousand. */
+export const roundingOf = (amount: PayAmount, written: string): number =>
+  amount.scale === undefined ? PLAIN_ROUNDING : amount.scale * 10 ** -decimalsOf(written);
+
+const readingOf = (text: string, first: PayAmount, last: PayAmount): PayReading => ({
+  offset: first.offset,
+  ends: { low: first.value, high: last.value },
+  currency: first.currency,
+  written: text.slice(first.offset, last.end),
+  unit: Math.max(roundingOf(first, text.slice(first.offset, first.end)), roundingOf(last, text.slice(last.offset, last.end))),
+});
+
+/**
+ * The pay a label states up to the end: undefined when no amount is joined to the label, unclear when the amount is
+ * followed by another, marked (約, 以上), left open, or stated with overtime or allowances.
+ */
+const payAt = (context: Context, label: Label, end: number): PayReading | Unclear | undefined => {
+  const { text, words } = context;
+  const [first, second, ...rest] = amountsBetween(context.amounts, label.end, end);
+  if (first === undefined || !isPlainGap(text.slice(label.end, first.offset), words.links)) return undefined;
+  const last = rangeEnd(text, first, second, words) ?? first;
+  const others = rest.length > 0 || (second !== undefined && last !== second);
+  const marked = isMarked(text, { start: first.offset, end: last.end }, words);
+  if (others || marked || contains(text.slice(label.end, end), words.includes)) return UNCLEAR;
+  return readingOf(text, first, last);
+};
+
+const numberWordValue = (word: string, words: AnnualPayWords): number | undefined =>
+  words.numberWords.find((entry) => entry.word.toLowerCase() === word.toLowerCase())?.value;
+
+const countOf = (written: string, words: AnnualPayWords): number => numberWordValue(written, words) ?? Number(written.normalize("NFKC"));
+
+/** The months counts between start and end (3ヶ月, three months), each marked when it is approximate, open or a range's end. */
+export const monthsIn = (text: string, start: number, end: number, words: AnnualPayWords): Count[] => {
+  const marker = alternation(words.months);
+  if (marker === undefined) return [];
+  const numberWords = alternation(words.numberWords.map((entry) => entry.word));
+  const count = numberWords === undefined ? DIGITS : `${DIGITS}|${numberWords}`;
+  const pattern = new RegExp(`(?<![0-9０-９.,，．])(${count})\\s?(?:${marker})`, "giu");
+  return [...text.slice(start, end).matchAll(pattern)].map((match) => {
+    const span = { start: start + match.index, end: start + match.index + match[0].length };
+    return { ...span, count: countOf(match[1] ?? "", words), marked: endsRange(text, span.start, words) || isMarked(text, span, words) };
+  });
+};
+
+/** Where a word saying there is no bonus stands: right before the label (No bonus) or right after it (賞与：なし). */
+const noneSpan = (text: string, label: Label, end: number, none: PositionedWord): Span | undefined => {
+  if (none.position === "before") {
+    const before = text.slice(lineStart(text, label.start), label.start).trimEnd();
+    const start = before.length - none.word.length;
+    const isWord = before.toLowerCase().endsWith(none.word.toLowerCase()) && !WORD_END.test(before.slice(0, start));
+    if (!isPlainGap(text.slice(label.end, end), [])) return undefined;
+    return isWord ? { start: lineStart(text, label.start) + start, end: label.end } : undefined;
+  }
+  const [at] = occurrences(text.slice(label.end, end), [none.word]);
+  return at !== undefined && isPlainGap(text.slice(label.end, label.end + at.start), []) ? { start: label.end + at.start, end: label.end + at.end } : undefined;
+};
+
+/** The words saying there is no bonus, as written (No bonus, なし). */
+const noneAt = (text: string, label: Label, end: number, words: AnnualPayWords): string | undefined => {
+  const span = words.none.map((none) => noneSpan(text, label, end, none)).find((found) => found !== undefined);
+  return span === undefined ? undefined : text.slice(span.start, span.end);
+};
+
+/**
+ * The bonus a label states up to the end: undefined when it states no months and no "none", unclear when it is per
+ * payment (各), besides another (別途), given as an amount, approximate, a range, or two different counts.
+ */
+const bonusAt = (context: Context, label: Label, end: number): BonusReading | Unclear | undefined => {
+  const { text, words } = context;
+  const none = noneAt(text, label, end, words);
+  if (none !== undefined) return { months: 0, written: none };
+  const counts = monthsIn(text, label.end, end, words);
+  const [first] = counts;
+  if (first === undefined) return undefined;
+  const piece = text.slice(label.end, end);
+  const odd = contains(piece, [...words.each, ...words.extra]) || amountsBetween(context.amounts, label.end, end).length > 0;
+  const perPayment = contains(piece, words.times) && !contains(piece, words.totals);
+  if (odd || perPayment || counts.length > 1 || first.marked) return UNCLEAR;
+  return { months: first.count, written: text.slice(first.start, first.end) };
+};
+
+const isRead = <T extends object>(reading: T | Unclear): reading is T => !("unclear" in reading);
+
+/** The one reading all agree on; undefined when there is none, one is unclear, or two differ. */
+const agreed = <T extends object>(readings: readonly (T | Unclear)[], same: (left: T, right: T) => boolean): T | undefined => {
+  const [first] = readings;
+  if (first === undefined || !isRead(first)) return undefined;
+  return readings.every((reading) => isRead(reading) && same(reading, first)) ? first : undefined;
+};
+
+const samePay = (left: PayReading, right: PayReading): boolean =>
+  left.currency === right.currency && left.ends.low === right.ends.low && left.ends.high === right.ends.high;
+
+const sameBonus = (left: BonusReading, right: BonusReading): boolean => left.months === right.months;
+
+/** The monthly pays the labels state; a pay label (給与) counts only with a per-month word in its statement. */
+const monthlyReadings = (context: Context, labels: readonly Label[]): (PayReading | Unclear)[] =>
+  labels.flatMap((label) => {
+    if (label.kind !== "monthly" && label.kind !== "pay") return [];
+    const end = statementEnd(context.text, label, context.labels, KINDS);
+    if (label.kind === "pay" && !contains(context.text.slice(label.end, end), context.words.perMonth)) return [];
+    const reading = payAt(context, label, end);
+    return reading === undefined ? [] : [reading];
+  });
+
+const bonusReadings = (context: Context, labels: readonly Label[]): (BonusReading | Unclear)[] =>
+  labels.flatMap((label) => (label.kind === "bonus" ? (bonusAt(context, label, statementEnd(context.text, label, context.labels, BONUS_STOPS)) ?? []) : []));
+
+/** Whether the annual pay is the monthly pay times the months, end for end, within the annual pay's rounding. */
+export const isAnnualOf = (annual: Ends, unit: number, monthly: Ends, months: number): boolean =>
+  Math.abs(annual.low - monthly.low * months) < unit && Math.abs(annual.high - monthly.high * months) < unit;
+
+const isRange = (ends: Ends): boolean => ends.low !== ends.high;
+
+const inside = (labels: readonly Label[], scope: Scope): Label[] => labels.filter((label) => label.start > scope.label.start && label.start < scope.end);
+
+const mismatchOf = (context: Context, scope: Scope, posting: Posting): StructureIssue[] => {
+  const annual = payAt(context, scope.label, statementEnd(context.text, scope.label, context.labels, KINDS));
+  if (annual === undefined || !isRead(annual)) return [];
+  const own = inside(context.labels, scope);
+  const ownMonthly = monthlyReadings(context, own);
+  const ownBonus = bonusReadings(context, own);
+  const monthly = ownMonthly.length > 0 ? agreed(ownMonthly, samePay) : posting.monthly;
+  const bonus = ownBonus.length > 0 ? agreed(ownBonus, sameBonus) : posting.bonus;
+  if (monthly === undefined || bonus === undefined || monthly.currency !== annual.currency) return [];
+  if (isRange(annual.ends) !== isRange(monthly.ends)) return [];
+  if (isAnnualOf(annual.ends, annual.unit, monthly.ends, MONTHS_A_YEAR + bonus.months)) return [];
+  const values = { annual: annual.written, monthly: monthly.written, bonus: bonus.written, months: MONTHS_A_YEAR + bonus.months };
+  return [{ offset: annual.offset, values }];
+};
+
+/** Every annual pay that is not the posting's monthly pay times twelve plus its bonus months. */
+export const annualPayMismatches = (text: string, amounts: readonly PayAmount[], words: AnnualPayWords): StructureIssue[] => {
+  const labels = labelsIn(text, words);
+  const scopes = labels.filter((label) => ANNUAL.includes(label.kind)).map((label) => ({ label, end: statementEnd(text, label, labels, ANNUAL) }));
+  const salary = scopes.some((scope) => scope.label.kind === "salary");
+  if (salary || scopes.length === 0 || scopes.some((scope) => contains(sentenceOf(text, scope), words.includes))) return [];
+  const context = { text, labels, amounts, words };
+  const outside = labels.filter((label) => !scopes.some((scope) => label.start >= scope.label.start && label.start < scope.end));
+  const posting = { monthly: agreed(monthlyReadings(context, outside), samePay), bonus: agreed(bonusReadings(context, outside), sameBonus) };
+  return scopes.flatMap((scope) => mismatchOf(context, scope, posting));
+};

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