chaffjs 0.31.0 → 0.32.0

package/src/structure/period-multiple.ts

@@ -0,0 +1,186 @@
+import type { StructureIssue } from "./issues.ts";
+import { alternation, intervalOf, isMultiple, isPlainGap, nearestStated, occurrences, type Interval, type Span, type StatedAmount } from "./stated-multiple.ts";
+
+/**
+ * period-multiple-mismatch: an amount the text says is a number of another period's amount that is not that many of it
+ * (年払（月払の12か月分） 29,800円 with 月払 2,400円; "Annually (12 monthly payments) $298" with Monthly $24). Only an
+ * explicit statement is read: the base's own word beside a count and a word of a multiple (月払の12か月分, 12 times the
+ * monthly premium, 12 monthly payments). An annual amount that only stands beside a monthly one is not compared, since
+ * paying at once is often cheaper. The base is the nearest one stated before (one label, one amount), else the document's
+ * one base. A range of counts, a statement with two amounts, and a statement with a word that makes the amount another
+ * thing (割引, tax, each) are not compared. The words come from the lexicons. Pure.
+ */
+
+export type PeriodMultipleWords = {
+  /** Labels of the base amount, also its words in a multiple (月払, 月額, Monthly, monthly payments). */
+  readonly bases: readonly string[];
+  /** Words after a count that make it a multiple (か月分, 倍, times). */
+  readonly times: readonly string[];
+  /** Words that may stand between a base and its count (の, the), or between a base label and its amount (は, is). */
+  readonly links: readonly string[];
+  /** Words that make the amount something other than the plain multiple (割引, 税込, discount, each). */
+  readonly skips: readonly string[];
+  /** Marks and words that join the two ends of a range (〜, to). */
+  readonly connectors: readonly string[];
+  /** Numbers written as words (twelve, 十二) and their values. */
+  readonly numberWords: readonly { readonly word: string; readonly value: number }[];
+};
+
+/** A count read as a multiple of a base (月払の12か月分, 12 monthly payments). */
+export type Phrase = Span & { readonly count: number };
+
+/** A base as stated. range is undefined when its statement holds more than one amount or a word that makes it another. */
+type Base = { readonly offset: number; readonly label: string; readonly currency: string; readonly range: Interval | undefined; readonly written: string };
+
+type Count = Span & { readonly count: number; readonly timed: boolean };
+
+const DIGITS = "[0-9０-９]+(?:[.．][0-9０-９]+)?";
+/** A count right after one of these is the tail of a larger number (十二, 二百), not a count of its own. */
+const KANJI_NUMERALS = "〇零一二三四五六七八九十百千万";
+const RANGE_START_DIGIT = /[0-9０-９一二三四五六七八九十]\s*$/u;
+const SENTENCE_END = /[。！？；;]|[.!?](?=\s|$)/gu;
+/** Between a phrase and its amount only marks may stand: brackets, a cell's bar, a colon (（月払の12か月分） | 29,800円). */
+const MARKS_ONLY = /^[\s|｜:：=＝、，,()（）[\]［］]*$/u;
+const SPACES_ONLY = /^[ \t\u3000]+$/u;
+/** How far before a count the start of a range (11〜12か月分) is looked for. */
+const RANGE_REACH = 12;
+
+const lineBounds = (text: string, offset: number): Span => {
+  const end = text.indexOf("\n", offset);
+  return { start: text.lastIndexOf("\n", offset - 1) + 1, end: end === -1 ? text.length : end };
+};
+
+/** The sentence around a span, within its line. */
+export const sentenceAround = (text: string, span: Span): Span => {
+  const line = lineBounds(text, span.start);
+  const ends = [...text.slice(line.start, line.end).matchAll(SENTENCE_END)].map((match) => line.start + match.index);
+  const start = ends.filter((end) => end < span.start).at(-1);
+  const end = ends.find((at) => at >= span.end);
+  return { start: start === undefined ? line.start : start + 1, end: end ?? line.end };
+};
+
+const countOf = (written: string, words: PeriodMultipleWords): number =>
+  words.numberWords.find((entry) => entry.word.toLowerCase() === written.toLowerCase())?.value ?? Number(written.normalize("NFKC"));
+
+/** Every count in the text (12, twelve), marked when a word of a multiple follows it (12か月分, 12 times). */
+export const countsIn = (text: string, words: PeriodMultipleWords): Count[] => {
+  const numberWords = alternation(words.numberWords.map((entry) => entry.word));
+  const count = numberWords === undefined ? DIGITS : `${DIGITS}|${numberWords}`;
+  const times = alternation(words.times);
+  const tail = times === undefined ? "" : `(\\s?(?:${times}))?`;
+  const pattern = new RegExp(`(?<![0-9０-９.,，．${KANJI_NUMERALS}])(${count})(?![0-9０-９]|[.,，．][0-9０-９])${tail}`, "giu");
+  return [...text.matchAll(pattern)].map((match) => ({
+    start: match.index,
+    end: match.index + match[0].length,
+    count: countOf(match[1] ?? "", words),
+    timed: match[2] !== undefined,
+  }));
+};
+
+/** Whether only link words and spaces stand between a base word and its count, on one line (の, " the "). */
+const isLinkGap = (gap: string, words: PeriodMultipleWords): boolean => {
+  if (gap.includes("\n")) return false;
+  const pattern = alternation(words.links);
+  return (pattern === undefined ? gap : gap.replace(new RegExp(pattern, "giu"), "")).trim() === "";
+};
+
+/** Whether a count closes a range: a connector right before it with a number before that (11〜12, eleven to twelve; not "equal to 12"). */
+const endsRange = (text: string, count: Count, words: PeriodMultipleWords): boolean => {
+  const before = text.slice(Math.max(0, count.start - RANGE_REACH), count.start).trimEnd();
+  const endsNumber = (head: string): boolean =>
+    RANGE_START_DIGIT.test(head) || countsIn(head.trimEnd(), words).some((found) => found.end === head.trimEnd().length);
+  return words.connectors.some((connector) => before.toLowerCase().endsWith(connector.toLowerCase()) && endsNumber(before.slice(0, -connector.length)));
+};
+
+/** The base word a count is a multiple of: before it with a word of a multiple (月払の12か月分), or after it (12 monthly payments). */
+const baseOf = (text: string, count: Count, bases: readonly Span[], words: PeriodMultipleWords): Span | undefined => {
+  const after = bases.find(
+    (base) =>
+      base.start >= count.end && (count.timed ? isLinkGap(text.slice(count.end, base.start), words) : SPACES_ONLY.test(text.slice(count.end, base.start))),
+  );
+  if (after !== undefined) return after;
+  return count.timed ? bases.findLast((base) => base.end <= count.start && isLinkGap(text.slice(base.end, count.start), words)) : undefined;
+};
+
+/** Every count stated as a multiple of a base word (月払の12か月分, 12 times the monthly premium, 12 monthly payments). */
+export const phrasesIn = (text: string, words: PeriodMultipleWords): Phrase[] => {
+  const bases = occurrences(text, words.bases);
+  return countsIn(text, words).flatMap((count) => {
+    const base = baseOf(text, count, bases, words);
+    if (base === undefined || endsRange(text, count, words)) return [];
+    return [{ start: Math.min(base.start, count.start), end: Math.max(base.end, count.end), count: count.count }];
+  });
+};
+
+const amountsWithin = (amounts: readonly StatedAmount[], span: Span): StatedAmount[] =>
+  amounts.filter((amount) => amount.offset >= span.start && amount.end <= span.end);
+
+const inside = (phrases: readonly Phrase[], offset: number): boolean => phrases.some((phrase) => offset >= phrase.start && offset < phrase.end);
+
+/** A base label followed on its line by an amount (月払 | 2,400円, Monthly: $24); unclear when the sentence holds more. */
+const baseAt = (text: string, label: Span, amounts: readonly StatedAmount[], phrases: readonly Phrase[], words: PeriodMultipleWords): Base[] => {
+  const sentence = sentenceAround(text, label);
+  const [first, ...rest] = amountsWithin(amounts, { start: label.end, end: sentence.end });
+  if (first === undefined || !isPlainGap(text.slice(label.end, first.offset), words.links)) return [];
+  const written = text.slice(first.offset, first.end);
+  const statement = text.slice(sentence.start, sentence.end);
+  const unclear =
+    rest.length > 0 || occurrences(statement, words.skips).length > 0 || phrases.some((phrase) => phrase.start >= sentence.start && phrase.end <= sentence.end);
+  const range = unclear ? undefined : intervalOf(first, written);
+  return [{ offset: label.start, label: text.slice(label.start, label.end), currency: first.currency, range, written }];
+};
+
+/** Each base label outside a multiple that is followed by its amount, in document order. */
+const statedBases = (text: string, amounts: readonly StatedAmount[], phrases: readonly Phrase[], words: PeriodMultipleWords): Base[] =>
+  occurrences(text, words.bases)
+    .filter((label) => !inside(phrases, label.start))
+    .flatMap((label) => baseAt(text, label, amounts, phrases, words));
+
+const gapBetween = (text: string, phrase: Phrase, amount: StatedAmount): string =>
+  amount.offset >= phrase.end ? text.slice(phrase.end, amount.offset) : text.slice(amount.end, phrase.start);
+
+/** The one amount a phrase's sentence states beside it, when the sentence holds no other amount, phrase or skip word. */
+const multipleAmount = (
+  text: string,
+  phrase: Phrase,
+  phrases: readonly Phrase[],
+  amounts: readonly StatedAmount[],
+  words: PeriodMultipleWords,
+): StatedAmount | undefined => {
+  const sentence = sentenceAround(text, phrase);
+  const [amount, ...rest] = amountsWithin(amounts, sentence);
+  if (amount === undefined || rest.length > 0 || (amount.offset < phrase.end && amount.end > phrase.start)) return undefined;
+  const others = phrases.some((other) => other !== phrase && other.start >= sentence.start && other.end <= sentence.end);
+  if (others || occurrences(text.slice(sentence.start, sentence.end), words.skips).length > 0) return undefined;
+  return MARKS_ONLY.test(gapBetween(text, phrase, amount)) ? amount : undefined;
+};
+
+const mismatchOf = (
+  text: string,
+  phrase: Phrase,
+  phrases: readonly Phrase[],
+  amounts: readonly StatedAmount[],
+  bases: readonly Base[],
+  words: PeriodMultipleWords,
+): StructureIssue[] => {
+  const amount = multipleAmount(text, phrase, phrases, amounts, words);
+  const base = nearestStated(bases, phrase.start);
+  if (amount === undefined || base?.range === undefined || base.currency !== amount.currency) return [];
+  if (isMultiple(phrase.count, intervalOf(amount, text.slice(amount.offset, amount.end)), [base.range])) return [];
+  const values = {
+    multiple: text.slice(phrase.start, phrase.end),
+    amount: text.slice(amount.offset, amount.end),
+    label: base.label,
+    base: base.written,
+    count: phrase.count,
+  };
+  return [{ offset: Math.min(phrase.start, amount.offset), values }];
+};
+
+/** Every amount stated as a number of a base's amount (月払の12か月分) that is not that many of the nearest stated base. */
+export const periodMultipleMismatches = (text: string, amounts: readonly StatedAmount[], words: PeriodMultipleWords): StructureIssue[] => {
+  const phrases = phrasesIn(text, words);
+  if (phrases.length === 0) return [];
+  const bases = statedBases(text, amounts, phrases, words);
+  return phrases.flatMap((phrase) => mismatchOf(text, phrase, phrases, amounts, bases, words));
+};

package/src/structure/quantity-range.ts

@@ -5,13 +5,6 @@ import { escapeRegExp } from "../orthography.ts";
 import type { StructureIssue } from "./issues.ts";
 import type { RangeAmount } from "./amount-range.ts";
 
-const LATIN_EDGE = /[A-Za-z]$/u;
-const LATIN_START = /^[A-Za-z]/u;
-
-/** A Latin unit running into a word is part of that word: the t of "40 to" is not a tonne. */
-const standsAlone = (text: string, measured: Measured): boolean =>
-  !(LATIN_EDGE.test(measured.unit) && LATIN_START.test(text.slice(measured.end, measured.end + 1)));
-
 /** 10 and a minus sign right before the number is a power of ten written flat ("10-8 cm" for 10⁻⁸ cm), not a range. */
 const POWER_OF_TEN = /(?<![0-9０-９.,，．])[1１][0０][-−－]$/u;
 
@@ -33,7 +26,7 @@ const rangeEndOf = (text: string, measured: Measured): RangeAmount => ({
 
 /** The measured quantities that can end a range, as range ends. */
 export const quantityRangeEnds = (text: string, measured: readonly Measured[]): RangeAmount[] =>
-  measured.filter((value) => standsAlone(text, value) && !isExponent(text, value)).map((value) => rangeEndOf(text, value));
+  measured.filter((value) => !isExponent(text, value)).map((value) => rangeEndOf(text, value));
 
 const LATIN_WORD = /^[A-Za-z]/u;
 

package/src/structure/range-bands.ts

@@ -59,7 +59,7 @@ export const normalizeBandText = (text: string): string => splitNote(plainOf(tex
 const normalizeWord = (word: string): string => word.normalize("NFKC").toLowerCase();
 
 /** A unit compared across bands: years and year, kg and kgs are the same unit. */
-const unitKey = (unit: string): string => (unit.length > 2 && unit.endsWith("s") ? unit.slice(0, -1) : unit);
+export const unitKey = (unit: string): string => (unit.length > 2 && unit.endsWith("s") ? unit.slice(0, -1) : unit);
 
 type Cursor = { readonly text: string; readonly at: number };
 

package/src/structure/range-years.ts

@@ -0,0 +1,75 @@
+import { weekdayOf } from "./weekday.ts";
+
+/**
+ * 期間の両端を、比べられる値にする。年を片方にだけ書いた期間（2026年7月9日〜7月8日、July 9 – July 8, 2026）は、書いた年を
+ * もう片方にも当てて読む。そう読むと逆になる期間は、年の境をまたぐ期間（2026年12月28日〜1月4日）でもあり得るので、
+ * もう片方を一年ずらした読み方を退けられるときだけ逆と言う。年の無い側の曜日がどちらの年に合うか、合わなければ、またぐ読み方の長さで決める。
+ */
+export type RangeEnd = { readonly value: string; readonly weekday?: number | undefined };
+
+export type RangeReading = { readonly start: string; readonly end: string };
+
+/** 年の境をまたぐと読んだ期間がこれより長ければ、またぐ読み方は退ける。年末年始の休みや冬の旅程は数週間で、一年近い期間を年を省いて書くことはない。 */
+export const YEAR_END_CROSSING_DAYS = 300;
+
+const DAY_MS = 86_400_000;
+const FULL_DATE = /^(?<y>\d{4})-(?<md>\d{2}-\d{2})$/u;
+const MONTH_DAY = /^\d{2}-\d{2}$/u;
+const COMPARABLE = [/^\d{4}-\d{2}-\d{2}$/u, /^\d{4}-\d{2}$/u];
+
+const timeOf = (value: string): number | undefined => {
+  if (weekdayOf(value) === undefined) return undefined;
+  const [year, month, day] = value.split("-").map(Number);
+  return Date.UTC(year ?? 0, (month ?? 1) - 1, day ?? 1);
+};
+
+const withYear = (year: number, monthDay: string): string => `${String(year)}-${monthDay}`;
+
+/** 二つの読み方。same は年を書いた側と同じ年、crossing は年の無い側を一年ずらした年。 */
+type Readings = { readonly same: RangeReading; readonly crossing: RangeReading; readonly yearless: "start" | "end"; readonly weekday?: number | undefined };
+
+const readingsOf = (start: RangeEnd, end: RangeEnd): Readings | undefined => {
+  const startYear = FULL_DATE.exec(start.value)?.groups;
+  const endYear = FULL_DATE.exec(end.value)?.groups;
+  if (startYear !== undefined && MONTH_DAY.test(end.value)) {
+    const year = Number(startYear["y"]);
+    const crossing = { start: start.value, end: withYear(year + 1, end.value) };
+    return { same: { start: start.value, end: withYear(year, end.value) }, crossing, yearless: "end", weekday: end.weekday };
+  }
+  if (endYear !== undefined && MONTH_DAY.test(start.value)) {
+    const year = Number(endYear["y"]);
+    const crossing = { start: withYear(year - 1, start.value), end: end.value };
+    return { same: { start: withYear(year, start.value), end: end.value }, crossing, yearless: "start", weekday: start.weekday };
+  }
+  return undefined;
+};
+
+/** 年の無い側の曜日が、同じ年の読み方に合えば同じ年、またぐ読み方に合えばまたぐ。どちらにも合わなければ決めない。 */
+const weekdayDecides = (readings: Readings): "same" | "crossing" | undefined => {
+  if (readings.weekday === undefined) return undefined;
+  const weekdayAt = (reading: RangeReading): number | undefined => weekdayOf(reading[readings.yearless]);
+  if (weekdayAt(readings.same) === readings.weekday) return "same";
+  return weekdayAt(readings.crossing) === readings.weekday ? "crossing" : undefined;
+};
+
+const crossingTooLong = ({ start, end }: RangeReading): boolean => {
+  const [from, to] = [timeOf(start), timeOf(end)];
+  return from === undefined || to === undefined || to - from > YEAR_END_CROSSING_DAYS * DAY_MS;
+};
+
+/** 年を片方にだけ書いた期間を同じ年と読んで逆になり、年の境をまたぐ読み方を退けられるときの、同じ年の読み方。 */
+const sameYearReversed = (start: RangeEnd, end: RangeEnd): RangeReading | undefined => {
+  const readings = readingsOf(start, end);
+  if (readings === undefined || timeOf(readings.same.start) === undefined || timeOf(readings.same.end) === undefined) return undefined;
+  if (readings.same.end >= readings.same.start) return undefined;
+  const decided = weekdayDecides(readings) ?? (crossingTooLong(readings.crossing) ? "same" : "crossing");
+  return decided === "same" ? readings.same : undefined;
+};
+
+/** 終わりが始まりより前と言える期間の、比べた両端。両方に年があればそのまま比べる。言えなければ undefined。 */
+export const reversedReading = (start: RangeEnd, end: RangeEnd): RangeReading | undefined => {
+  if (COMPARABLE.some((pattern) => pattern.test(start.value) && pattern.test(end.value))) {
+    return end.value < start.value ? { start: start.value, end: end.value } : undefined;
+  }
+  return sameYearReversed(start, end);
+};

package/src/structure/ratio.ts

@@ -0,0 +1,296 @@
+/**
+ * ratio-mismatch: the deciding half. A ratio written in percent (営業利益率 7.3%, Operating margin 7.5%) against the numerator
+ * and the denominator it names (営業利益 ÷ 売上高), in a results table or in one sentence. Which ratio names which two rows is
+ * data (lexicons ratio-label and ratio-term); nothing here knows a word of accounting. Pure.
+ */
+import type { StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "./issues.ts";
+
+/** An amount as written: its value in the unit it is written in, the step of its last written digit, and that unit. */
+export type Figure = { readonly start: number; readonly value: number; readonly step: number; readonly unit: string };
+
+/** A ratio as written: its value in percent and the number of its decimals. */
+export type WrittenRate = { readonly start: number; readonly value: number; readonly decimals: number };
+
+/** A ratio label and the names of the terms it divides (営業利益率 → operating-profit / sales). */
+export type RatioLabel = { readonly pattern: string; readonly numerator: string; readonly denominator: string };
+
+export type RatioTerm = { readonly pattern: string; readonly term: string };
+
+export type RatioWords = { readonly labels: readonly RatioLabel[]; readonly terms: readonly RatioTerm[]; readonly percentUnits: readonly string[] };
+
+export type RatioIssue = { readonly offset: number; readonly values: Readonly<Record<string, string>> };
+
+const PERCENT = 100;
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+/** Floating error must not push a ratio that sits on the edge of its rounding out of it. */
+const FLOAT_SLACK = 1e-9;
+
+/** The ratio written as a decimal-point string of the written precision (7.3, 12.50). */
+const shown = (value: number, decimals: number): string => value.toFixed(decimals);
+
+/**
+ * The ratio the two amounts give, when the written ratio cannot be it; undefined when it can or when they cannot be compared.
+ * The written ratio stands for the half step of its last digit around it (7.3% is 7.25% to 7.35%). Each amount may be off by a
+ * whole step of its last digit, not half: results tables round down (百万円未満切捨て) as often as to nearest, and the margin is
+ * worked out from the unrounded amounts.
+ */
+export const ratioDisagreement = (rate: WrittenRate, numerator: Figure, denominator: Figure): string | undefined => {
+  if (numerator.unit !== denominator.unit || numerator.value < 0 || denominator.value - denominator.step <= 0) return undefined;
+  const lowest = (Math.max(0, numerator.value - numerator.step) / (denominator.value + denominator.step)) * PERCENT;
+  const highest = ((numerator.value + numerator.step) / (denominator.value - denominator.step)) * PERCENT;
+  const half = HALF * DECIMAL_BASE ** -rate.decimals + FLOAT_SLACK;
+  if (rate.value + half >= lowest && rate.value - half <= highest) return undefined;
+  return shown((numerator.value / denominator.value) * PERCENT, rate.decimals);
+};
+
+/** The words compared: NFKC, lower case, one space. */
+export const keyOf = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
+
+const PREFIX = /^[^\d\s]*/u;
+const NUMBER = /^(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?/u;
+/** Marks that make an amount negative or a note ((1,200), ▲50, -50, +3%): such a cell is not read. */
+const SIGNED = /[-−▲△+＋(（]/u;
+const DIGIT = /\d/u;
+
+/** The value of a number written with grouping commas and its decimals apart ("1,320" and "5"). */
+const numberOf = (integer: string, decimals: string): number => Number([integer.replaceAll(",", ""), decimals].filter((part) => part !== "").join("."));
+
+export type ReadCell = { readonly prefix: string; readonly value: number; readonly decimals: number; readonly suffix: string };
+
+/** A cell holding one number with what is written before and after it ("$2,400 million", "1,320百万円", "7.3%"). */
+export const readNumber = (text: string): ReadCell | undefined => {
+  const plain = text.normalize("NFKC").trim();
+  const prefix = PREFIX.exec(plain)?.[0] ?? "";
+  const number = NUMBER.exec(plain.slice(prefix.length));
+  if (number === null || SIGNED.test(prefix)) return undefined;
+  const suffix = plain.slice(prefix.length + number[0].length).trim();
+  if (DIGIT.test(suffix) || SIGNED.test(suffix)) return undefined;
+  const decimals = number[2] ?? "";
+  return { prefix, value: numberOf(number[1] ?? "", decimals), decimals: decimals.length, suffix };
+};
+
+/** A cell read as a percentage: a percent unit after the number, or nothing after it when the row says it is in percent. */
+export const cellRate = (text: string, start: number, percentUnits: readonly string[], rowInPercent: boolean): WrittenRate | undefined => {
+  const cell = readNumber(text);
+  if (cell === undefined || cell.prefix !== "") return undefined;
+  const inPercent = percentUnits.some((unit) => keyOf(unit) === keyOf(cell.suffix)) || (rowInPercent && cell.suffix === "");
+  return inPercent ? { start, value: cell.value, decimals: cell.decimals } : undefined;
+};
+
+/** A cell read as an amount, in the unit written around its number. A percentage is not an amount. */
+export const cellFigure = (text: string, start: number, percentUnits: readonly string[]): Figure | undefined => {
+  const cell = readNumber(text);
+  if (cell === undefined || percentUnits.some((unit) => keyOf(unit) === keyOf(cell.suffix))) return undefined;
+  return { start, value: cell.value, step: DECIMAL_BASE ** -cell.decimals, unit: `${keyOf(cell.prefix)}|${keyOf(cell.suffix)}` };
+};
+
+export type TableCell = { readonly start: number; readonly text: string };
+
+/** A table row: its label (the first cell, as written) and the cells after it. */
+export type TableRow = { readonly label: string; readonly cells: readonly TableCell[] };
+
+/** A note in brackets after a row label (営業利益率（%）, Net sales (millions)): not part of the label. */
+const LABEL_NOTE = /[(（][^()（）]*[)）]$/u;
+
+export const labelKey = (label: string): string => keyOf(label.replace(LABEL_NOTE, ""));
+
+export const noteOf = (label: string): string => LABEL_NOTE.exec(label.normalize("NFKC").trim())?.[0] ?? "";
+
+/** The one row whose label is a term of the name; undefined when no row or more than one row is. */
+const onlyRow = (rows: readonly TableRow[], terms: readonly RatioTerm[], name: string): TableRow | undefined => {
+  const patterns = terms.filter((term) => term.term === name).map((term) => keyOf(term.pattern));
+  const found = rows.filter((row) => patterns.includes(labelKey(row.label)));
+  return found.length === 1 ? found[0] : undefined;
+};
+
+/** An amount cell, in its unit and the unit its row label notes (Net sales (thousand yen)): rows noted differently differ. */
+const rowFigure = (cell: TableCell, row: TableRow, percentUnits: readonly string[]): Figure | undefined => {
+  const figure = cellFigure(cell.text, cell.start, percentUnits);
+  return figure === undefined ? undefined : { ...figure, unit: `${figure.unit}|${keyOf(noteOf(row.label))}` };
+};
+
+const sameWidth = (rows: readonly TableRow[]): boolean => rows.every((row) => row.cells.length === rows[0]?.cells.length);
+
+const columnIssues = (ratioRow: TableRow, numeratorRow: TableRow, denominatorRow: TableRow, words: RatioWords): RatioIssue[] => {
+  const inPercent = words.percentUnits.some((unit) => noteOf(ratioRow.label).includes(unit.normalize("NFKC")));
+  return ratioRow.cells.flatMap((cell, column) => {
+    const rate = cellRate(cell.text, cell.start, words.percentUnits, inPercent);
+    const top = numeratorRow.cells[column];
+    const bottom = denominatorRow.cells[column];
+    const numerator = top === undefined ? undefined : rowFigure(top, numeratorRow, words.percentUnits);
+    const denominator = bottom === undefined ? undefined : rowFigure(bottom, denominatorRow, words.percentUnits);
+    if (rate === undefined || numerator === undefined || denominator === undefined) return [];
+    const computed = ratioDisagreement(rate, numerator, denominator);
+    return computed === undefined ? [] : [{ offset: rate.start, values: { written: shown(rate.value, rate.decimals), computed } }];
+  });
+};
+
+/**
+ * In one table, each row labelled with a ratio against the one row of its numerator and the one row of its denominator,
+ * column by column. A table whose three rows do not have the same number of cells is not read: its columns may not line up.
+ */
+export const tableRatioMismatches = (rows: readonly TableRow[], words: RatioWords): RatioIssue[] =>
+  rows.flatMap((ratioRow) => {
+    const label = words.labels.find((entry) => keyOf(entry.pattern) === labelKey(ratioRow.label));
+    if (label === undefined) return [];
+    const numeratorRow = onlyRow(rows, words.terms, label.numerator);
+    const denominatorRow = onlyRow(rows, words.terms, label.denominator);
+    if (numeratorRow === undefined || denominatorRow === undefined || !sameWidth([ratioRow, numeratorRow, denominatorRow])) return [];
+    return columnIssues(ratioRow, numeratorRow, denominatorRow, words).map((issue) => ({
+      offset: issue.offset,
+      values: { ...issue.values, ratio: ratioRow.label.trim() },
+    }));
+  });
+
+/** How amounts are written around their number: currency marks before and after it, and words of magnitude (million, 万). */
+export type AmountWords = {
+  readonly before: readonly string[];
+  readonly after: readonly string[];
+  readonly multipliers: readonly string[];
+  readonly percentUnits: readonly string[];
+};
+
+/** A quantity the structure tree read: where it stands in the document and the unit it names (円, $, %, 社). */
+export type ProseQuantity = { readonly start: number; readonly end: number; readonly unit: string };
+
+/** The tree's quantities, in document order. */
+export const proseQuantitiesOf = (tree: StructureNode | undefined): ProseQuantity[] =>
+  tree === undefined
+    ? []
+    : inDocumentOrder(tree).flatMap((node) =>
+        node.kind === "quantity" ? [{ start: node.span.start, end: node.span.end, unit: String(node.attrs["unit"] ?? "") }] : [],
+      );
+
+const PROSE_NUMBER = /(?<![\d.,])(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?(?![\d,.]\d)/gu;
+const NEGATIVE_BEFORE = /[-−▲△]$/u;
+/** Words after the quantity ("$198 million", "1,320 million yen"). */
+const WORDS_AFTER = /^\s+([A-Za-z]+)(?:\s+([A-Za-z]+))?/u;
+
+/** The currency mark before a number, which may stand one space apart ($5, € 5, US$5), and the text before that mark. */
+const markBefore = (before: string, marks: readonly string[]): { readonly mark: string; readonly rest: string } => {
+  const gapped = before.endsWith(" ") ? before.slice(0, -1) : before;
+  const mark = marks.filter((entry) => gapped.endsWith(entry)).toSorted((left, right) => right.length - left.length)[0];
+  return mark === undefined ? { mark: "", rest: before } : { mark, rest: gapped.slice(0, gapped.length - mark.length) };
+};
+
+/**
+ * An amount of money as written in prose. The mark is the currency written before the number ($, US$); the suffix is what is
+ * written after it: the magnitude and the mark inside the quantity (百万円 of 96百万円), or up to two words of magnitude or
+ * currency (million, million yen). Both are compared as written (NFKC, lower case), so US$ and $ differ, and so do 百万円 and
+ * 億円. writtenStart and writtenEnd are where the whole amount, its marks and words included, stands.
+ */
+export type ProseFigure = Figure & { readonly mark: string; readonly suffix: string; readonly writtenStart: number; readonly writtenEnd: number };
+
+/** Up to two words of magnitude or currency after the quantity, and where they end. */
+const wordsAfter = (after: string, words: AmountWords): { readonly named: string; readonly length: number } => {
+  const units = [...words.multipliers, ...words.after].map((word) => word.toLowerCase());
+  const found = WORDS_AFTER.exec(after);
+  const [first = "", second = ""] = [found?.[1] ?? "", found?.[2] ?? ""];
+  if (found === null || !units.includes(first.toLowerCase())) return { named: "", length: 0 };
+  if (!units.includes(second.toLowerCase())) return { named: first, length: after.indexOf(first) + first.length };
+  return { named: `${first} ${second}`, length: found[0].length };
+};
+
+/** What a piece of text holds: amounts of money, percentages, and the other numbers (years, counts), by where they start. */
+export type ProseValues = { readonly figures: readonly ProseFigure[]; readonly rates: readonly WrittenRate[]; readonly others: readonly number[] };
+
+type ProseNumber = { readonly figure: ProseFigure } | { readonly rate: WrittenRate } | { readonly other: number };
+
+type NumberRead = { readonly start: number; readonly value: number; readonly decimals: number };
+
+const figureOf = (text: string, offset: number, match: RegExpExecArray, quantity: ProseQuantity, words: AmountWords): ProseFigure => {
+  const { mark, rest } = markBefore(text.slice(0, match.index), words.before);
+  const [end, quantityEnd] = [match.index + match[0].length, quantity.end - offset];
+  const after = wordsAfter(text.slice(quantityEnd), words);
+  const [mine, suffix] = [keyOf(mark), keyOf(`${text.slice(end, quantityEnd)} ${after.named}`)];
+  const decimals = match[2] ?? "";
+  const written = { writtenStart: offset + (mark === "" ? match.index : rest.length), writtenEnd: offset + quantityEnd + after.length };
+  const value = numberOf(match[1] ?? "", decimals);
+  return { start: offset + match.index, value, step: DECIMAL_BASE ** -decimals.length, unit: `${mine}|${suffix}`, mark: mine, suffix, ...written };
+};
+
+const proseNumber = (text: string, offset: number, match: RegExpExecArray, quantities: readonly ProseQuantity[], words: AmountWords): ProseNumber[] => {
+  if (NEGATIVE_BEFORE.test(markBefore(text.slice(0, match.index), words.before).rest)) return [];
+  const decimals = match[2] ?? "";
+  const read: NumberRead = { start: offset + match.index, value: numberOf(match[1] ?? "", decimals), decimals: decimals.length };
+  const quantity = quantities.find((entry) => entry.start === read.start);
+  if (quantity === undefined) return [{ other: read.start }];
+  if (words.percentUnits.includes(quantity.unit)) return [{ rate: read }];
+  if (![...words.before, ...words.after].includes(quantity.unit)) return [{ other: read.start }];
+  return [{ figure: figureOf(text, offset, match, quantity, words) }];
+};
+
+/**
+ * The numbers of a piece of text, read with the tree's quantities (offset is where the text starts in the document, and the
+ * quantities are in the same coordinates). A quantity in a currency is an amount of money and one in a percent unit a
+ * percentage; any other number (a count, a year, the first of a range) is kept only by where it starts. Signed numbers (-5,
+ * ▲5, -$5) are not read at all.
+ */
+export const proseValues = (text: string, offset: number, quantities: readonly ProseQuantity[], words: AmountWords): ProseValues => {
+  const numbers = [...text.matchAll(PROSE_NUMBER)].flatMap((match) => proseNumber(text, offset, match, quantities, words));
+  return {
+    figures: numbers.flatMap((number) => ("figure" in number ? [number.figure] : [])),
+    rates: numbers.flatMap((number) => ("rate" in number ? [number.rate] : [])),
+    others: numbers.flatMap((number) => ("other" in number ? [number.other] : [])),
+  };
+};
+
+/** A word of the lexicons found in a sentence. */
+export type LabelHit = { readonly start: number; readonly end: number } & ({ readonly label: RatioLabel } | { readonly term: string });
+
+/** What one sentence holds: where it ends, the words found in it, and its numbers. */
+export type RatioSentence = Omit<ProseValues, "figures"> & {
+  readonly figures: readonly Figure[];
+  readonly end: number;
+  readonly hits: readonly LabelHit[];
+};
+
+/** How far after its word a value may start (「営業利益は」, "net sales of", "an operating margin of"). */
+const MAX_GAP = 16;
+
+type Value = { readonly start: number } & ({ readonly figure: Figure } | { readonly rate: WrittenRate } | { readonly other: true });
+
+const valuesOf = (sentence: RatioSentence): Value[] => [
+  ...sentence.figures.map((figure) => ({ start: figure.start, figure })),
+  ...sentence.rates.map((rate) => ({ start: rate.start, rate })),
+  ...sentence.others.map((start): Value => ({ start, other: true })),
+];
+
+/**
+ * The value of a word: the only number between it and the next word of the lexicons (or the end of the sentence), close to
+ * it. Two numbers there (「前期の84百万円から96百万円に」, "in 2026 was $198 million") leave it unknown.
+ */
+const valueAfter = (hit: LabelHit, sentence: RatioSentence): Value | undefined => {
+  const until = Math.min(sentence.end, ...sentence.hits.filter((other) => other.start >= hit.end).map((other) => other.start));
+  const between = valuesOf(sentence).filter((value) => value.start >= hit.end && value.start < until);
+  const only = between.length === 1 ? between[0] : undefined;
+  return only !== undefined && only.start - hit.end <= MAX_GAP ? only : undefined;
+};
+
+const termHits = (sentence: RatioSentence, name: string): LabelHit[] => sentence.hits.filter((hit) => "term" in hit && hit.term === name);
+
+const figureAfter = (hits: readonly LabelHit[], sentence: RatioSentence): Figure | undefined => {
+  const hit = hits.length === 1 ? hits[0] : undefined;
+  const value = hit === undefined ? undefined : valueAfter(hit, sentence);
+  return value !== undefined && "figure" in value ? value.figure : undefined;
+};
+
+/**
+ * One sentence that names a ratio, its numerator and its denominator, each once, each with its value right after it
+ * (「営業利益は96百万円、売上高は1,320百万円で、営業利益率は7.3%」). Any other shape is not read.
+ */
+export const sentenceRatioMismatch = (sentence: RatioSentence): RatioIssue | undefined => {
+  const ratios = sentence.hits.filter((hit) => "label" in hit);
+  const ratio = ratios.length === 1 ? ratios[0] : undefined;
+  if (ratio === undefined || !("label" in ratio)) return undefined;
+  const value = valueAfter(ratio, sentence);
+  const numerator = figureAfter(termHits(sentence, ratio.label.numerator), sentence);
+  const denominator = figureAfter(termHits(sentence, ratio.label.denominator), sentence);
+  if (value === undefined || !("rate" in value) || numerator === undefined || denominator === undefined) return undefined;
+  const computed = ratioDisagreement(value.rate, numerator, denominator);
+  return computed === undefined
+    ? undefined
+    : { offset: value.start, values: { written: shown(value.rate.value, value.rate.decimals), computed, ratio: ratio.label.pattern } };
+};