chaffjs 0.31.0 → 0.33.0

package/src/structure/reference-flags.ts

@@ -0,0 +1,156 @@
+// reference-flag-mismatch: a row of a lab or checkup results table whose flag (H, L, 高, 低, 基準内, Normal) says the opposite of
+// where its value stands against the reference range on the same row. The column headings, the flags and the bound marks come
+// from the lexicons (lab-result-column with reference-column-heading, reference-flag, range-band-word, reference-bound-mark). Pure.
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { labColumnsOf, type LabColumnWord } from "./lab-columns.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { parseBand, type Band, type BandWords, type Bound } from "./range-bands.ts";
+
+/** What a flag says: above the range, below it, inside it, or outside it on either side (基準外, *). */
+export type FlagMeaning = "high" | "low" | "normal" | "outside";
+
+export type ReferenceWords = {
+  readonly headings: readonly LabColumnWord[];
+  readonly flags: readonly { readonly pattern: string; readonly meaning: FlagMeaning }[];
+  /** How a range is read: range-band-word with the reference marks (≤, >), and no units (the row's own unit is taken out first). */
+  readonly band: BandWords;
+};
+
+export type Position = "below" | "inside" | "above";
+
+/**
+ * "inside": flagged high, low or outside although inside the range. "outside": flagged normal although outside it. "below": flagged
+ * high although below the range; "above": flagged low although above it.
+ */
+export type FlagSlipKind = "inside" | "outside" | "below" | "above";
+
+export type FlagSlip = {
+  readonly kind: FlagSlipKind;
+  readonly item: string;
+  readonly value: string;
+  readonly range: string;
+  readonly flag: Cell;
+};
+
+/** A result cell: one number and what follows it (its unit, possibly nothing). */
+export type ReadValue = { readonly number: number; readonly unit: string };
+
+const DIGITS = /^(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?/u;
+const STARTS_NUMERIC = /^[\d.,]/u;
+/** A unit has no figure and no note: 1.2/1, 88 (fasting) and 3.5 x10^4/μL are not a number and its unit. */
+const NOT_A_UNIT = /[\d()[\]]/u;
+const NOTE_OPEN = /[([]/u;
+/** A unit is a whole word when no Latin or Greek letter runs on from it: cm in 90 cm未満, not the l of less. */
+const LETTER = /[\p{Script=Latin}\p{Script=Greek}]/u;
+const SPACES = /\s+/gu;
+
+const normalized = (text: string): string => withoutEdgeMarks(text.normalize("NFKC").toLowerCase().replace(SPACES, " ").trim());
+
+/** The number of a result cell and the unit after it; undefined when the cell is not a plain number (<0.5, 陰性, —). */
+export const valueOf = (text: string): ReadValue | undefined => {
+  const plain = normalized(text);
+  const digits = DIGITS.exec(plain)?.[0];
+  if (digits === undefined) return undefined;
+  const unit = plain.slice(digits.length).trim();
+  if (STARTS_NUMERIC.test(unit) || NOT_A_UNIT.test(unit)) return undefined;
+  return { number: Number(digits.replaceAll(",", "")), unit };
+};
+
+const isLetterAt = (text: string, index: number): boolean => LETTER.test(text.charAt(index));
+
+/** The text with every whole occurrence of the unit blanked out: mg/dL in "30〜149 mg/dL", not the l of "less". */
+const withoutUnit = (text: string, unit: string): string => {
+  if (unit === "") return text;
+  const at = text.indexOf(unit);
+  if (at === -1) return text;
+  const end = at + unit.length;
+  const whole = !(LETTER.test(unit.charAt(0)) && isLetterAt(text, at - 1)) && !(LETTER.test(unit.charAt(unit.length - 1)) && isLetterAt(text, end));
+  const head = text.slice(0, at) + (whole ? " " : unit);
+  return head + withoutUnit(text.slice(end), unit);
+};
+
+/**
+ * The reference range of a row, read once the row's unit is taken out: 30〜149 mg/dL, 79 U/L 以下, ≤79, below 102 cm. undefined
+ * when anything else is left (another unit, a range for men and one for women, a note), so a row in two units is not read.
+ */
+export const rangeOf = (text: string, unit: string, words: ReferenceWords): Band | undefined => {
+  const bare = withoutUnit(normalized(text), unit);
+  return NOTE_OPEN.test(bare) ? undefined : parseBand(bare, words.band);
+};
+
+/** A heading without the unit in brackets at its end: Result (mg/dL), 結果（mg/dL）. */
+const headingKeyOf = (heading: string): string => {
+  const key = normalized(heading);
+  const open = key.lastIndexOf("(");
+  return key.endsWith(")") && open > 0 ? key.slice(0, open).trim() : key;
+};
+
+/** A flag compared as written: emphasis marks dropped, unless the flag is only such a mark (*). */
+const flagKeyOf = (text: string): string => {
+  const plain = normalized(text);
+  return plain === "" ? text.normalize("NFKC").trim().toLowerCase() : plain;
+};
+
+/** What a flag cell says, by the flag lexicon; undefined for a flag chaff does not know (A, 要再検査, —). */
+export const flagOf = (text: string, words: ReferenceWords): FlagMeaning | undefined => {
+  const key = flagKeyOf(text);
+  return key === "" ? undefined : words.flags.find((flag) => flagKeyOf(flag.pattern) === key)?.meaning;
+};
+
+/**
+ * A two-sided range written with only a range mark (30〜149, 4.0–5.6) includes its ends: a reference interval names the lowest
+ * and the highest value counted as within it, so 149 against 30〜149 is inside. 未満, 超, under and < leave their end out.
+ */
+const belowLow = (value: number, low: Bound | undefined): boolean => low !== undefined && (low.kind === "exclusive" ? value <= low.value : value < low.value);
+const aboveHigh = (value: number, high: Bound | undefined): boolean =>
+  high !== undefined && (high.kind === "exclusive" ? value >= high.value : value > high.value);
+
+export const positionOf = (value: number, range: Band): Position => {
+  if (belowLow(value, range.low)) return "below";
+  return aboveHigh(value, range.high) ? "above" : "inside";
+};
+
+/** Whether a flag contradicts the value's place against its range, and how. */
+export const slipKindOf = (flag: FlagMeaning, position: Position): FlagSlipKind | undefined => {
+  if (position === "inside") return flag === "normal" ? undefined : "inside";
+  if (flag === "normal") return "outside";
+  if (flag === "high" && position === "below") return "below";
+  return flag === "low" && position === "above" ? "above" : undefined;
+};
+
+type Columns = { readonly result: number; readonly range: number; readonly flag: number };
+
+const COLUMNS = ["result", "range", "flag"] as const;
+
+/** The column of each kind, by its heading; undefined unless each kind names exactly one column. */
+export const columnsOf = (headings: readonly string[], words: ReferenceWords): Columns | undefined => {
+  const kinds = labColumnsOf(headings, words.headings, headingKeyOf);
+  const found = COLUMNS.map((column) => kinds.flatMap((kind, index) => (kind === column ? [index] : [])));
+  const [result, range, flag] = found.map((indexes) => (indexes.length === 1 ? indexes[0] : undefined));
+  return result === undefined || range === undefined || flag === undefined ? undefined : { result, range, flag };
+};
+
+const rowSlip = (row: Line, columns: Columns, words: ReferenceWords): FlagSlip[] => {
+  const cells = cellsOf(row);
+  const [valueCell, rangeCell, flagCell] = [cells[columns.result], cells[columns.range], cells[columns.flag]];
+  if (valueCell === undefined || rangeCell === undefined || flagCell === undefined) return [];
+  const flag = flagOf(flagCell.text, words);
+  const value = valueOf(valueCell.text);
+  const range = value === undefined ? undefined : rangeOf(rangeCell.text, value.unit, words);
+  if (flag === undefined || value === undefined || range === undefined) return [];
+  const kind = slipKindOf(flag, positionOf(value.number, range));
+  if (kind === undefined) return [];
+  const item = withoutEdgeMarks((cells[0]?.text ?? "").trim());
+  return [{ kind, item, value: valueCell.text.trim(), range: rangeCell.text.trim(), flag: flagCell }];
+};
+
+/** Every row of every results table of the text whose flag contradicts its value and reference range. */
+export const referenceFlagSlips = (text: string, words: ReferenceWords): FlagSlip[] =>
+  tablesOf(linesOf(text)).flatMap((table) => {
+    const columns = columnsOf(
+      cellsOf(table.header).map((cell) => cell.text),
+      words,
+    );
+    return columns === undefined ? [] : table.rows.flatMap((row) => rowSlip(row, columns, words));
+  });

package/src/structure/reference-number-repeated.ts

@@ -0,0 +1,57 @@
+// reference-number-repeated: in a table of separate items (expense lines, invoice lines), the same receipt, invoice or slip
+// number on two rows. The column is found by its heading words only (lexicon reference-column). Pure.
+import type { ChangeTable, TableCell } from "./change-rate-table.ts";
+import { plain } from "./change-rate-table.ts";
+
+/** The second row that carries a number, and the first row that already did (both as offsets into the source). */
+export type RepeatedReference = { readonly offset: number; readonly firstOffset: number; readonly number: string; readonly heading: string };
+
+/** A heading or a number compared without case, width or spaces: 「領収書 No.」 is 「領収書No.」, "t-0384" is "T-0384". */
+const keyOf = (text: string): string => plain(text).toLowerCase().replace(/\s+/gu, "");
+
+const DIGIT = /\d/u;
+
+/** The one column whose heading is a reference-number heading; undefined when none or several are. */
+export const referenceColumnOf = (headings: readonly string[], words: readonly string[]): number | undefined => {
+  const wanted = new Set(words.map(keyOf));
+  const indexes = headings.flatMap((heading, index) => (wanted.has(keyOf(heading)) ? [index] : []));
+  return indexes.length === 1 ? indexes[0] : undefined;
+};
+
+const offsetOf = (cell: TableCell): number => cell.start + (cell.text.length - cell.text.trimStart().length);
+
+/** The cells of the column that hold a number: blank, a dash, 「なし」 and "N/A" hold no digit and are not numbers. */
+const numberCells = (rows: readonly (readonly TableCell[])[], column: number): TableCell[] =>
+  rows.flatMap((row) => {
+    const cell = row[column];
+    return cell !== undefined && DIGIT.test(plain(cell.text)) ? [cell] : [];
+  });
+
+/**
+ * A table's one repeated number. Only a table where exactly one number is written exactly twice is read: when several
+ * numbers repeat, or one three times, the rows are grouped by slip (the lines of one invoice, an invoice and its payment),
+ * and a repeat is how the table is meant to be read.
+ */
+const repeatOf = (cells: readonly TableCell[], heading: string): RepeatedReference[] => {
+  const byKey = cells.reduce((groups, cell) => {
+    const key = keyOf(cell.text);
+    return groups.set(key, [...(groups.get(key) ?? []), cell]);
+  }, new Map<string, TableCell[]>());
+  const repeated = [...byKey.values()].filter((group) => group.length > 1);
+  const [only] = repeated;
+  if (repeated.length !== 1 || only?.length !== 2) return [];
+  const [first, second] = only;
+  if (first === undefined || second === undefined) return [];
+  return [{ offset: offsetOf(second), firstOffset: offsetOf(first), number: plain(second.text), heading: plain(heading) }];
+};
+
+export const repeatedReferences = (tables: readonly ChangeTable[], words: readonly string[]): RepeatedReference[] =>
+  tables.flatMap((table) => {
+    const column = referenceColumnOf(
+      table.header.map((cell) => cell.text),
+      words,
+    );
+    const heading = column === undefined ? undefined : table.header[column];
+    if (column === undefined || heading === undefined) return [];
+    return repeatOf(numberCells(table.rows, column), heading.text);
+  });

package/src/structure/reference-unit.ts

@@ -0,0 +1,105 @@
+import type { StructureIssue } from "./issues.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { labColumnsOf, type LabColumn, type LabColumnWord } from "./lab-columns.ts";
+
+/**
+ * 検査結果の表で、結果の単位と基準値の単位が違う行（64 mmol/L と 40〜96 mg/dL）。結果・基準値・単位の列は見出しの語
+ * （lab-result-column と reference-unit-column）で見つけ、単位は語彙表 reference-unit で読む。group が同じ単位
+ * （mg/dL と mg/dl、×10⁴/µL と 万/µL）は同じ単位。升に単位が無ければ、列の見出しの単位、次にその行の単位の列を使う。どちらかの単位が読めなければ比べない。Pure.
+ */
+export type UnitWord = { readonly pattern: string; readonly unit: string };
+type ColumnRole = Exclude<LabColumn, "flag">;
+export type ReferenceUnitWords = { readonly units: readonly UnitWord[]; readonly columns: readonly LabColumnWord[] };
+
+type UnitsIn = (text: string) => ReadonlySet<string>;
+type Column = { readonly index: number; readonly role: ColumnRole; readonly units: ReadonlySet<string> };
+
+const NO_UNITS: ReadonlySet<string> = new Set();
+const DIGIT = /\d/u;
+const BRACKET_OPEN = /[([]/u;
+const SPACES = /\s+/gu;
+
+const fold = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+/** A unit written as a count per volume ("/µL") is not read right after a scale it does not include ("× 10⁴/µL" is not "/µL"). */
+const AFTER_SCALE = "(?<![×x]\\s*10\\^?\\d*\\s*)";
+
+const alternationOf = (patterns: readonly string[]): string => patterns.map(escapeRegExp).join("|");
+
+/** The units written in a text, by their group, never inside a longer word or unit ("mol/L" is not in "mmol/L", "mg" not in "mg/kg"). */
+export const unitMatcher = (units: readonly UnitWord[]): UnitsIn => {
+  const unitOf = new Map(units.map((word) => [fold(word.pattern), word.unit]));
+  if (unitOf.size === 0) return () => NO_UNITS;
+  const patterns = [...unitOf.keys()];
+  const perVolume = alternationOf(patterns.filter((pattern) => pattern.startsWith("/")));
+  const others = alternationOf(patterns.filter((pattern) => !pattern.startsWith("/")));
+  const alternation = [others, perVolume === "" ? "" : `${AFTER_SCALE}(?:${perVolume})`].filter((part) => part !== "").join("|");
+  const pattern = new RegExp(`(?<!\\p{L})(?:${alternation})(?![\\p{L}\\d/])`, "gu");
+  return (text) => new Set([...fold(text).matchAll(pattern)].map((match) => unitOf.get(match[0]) ?? match[0]));
+};
+
+/** Two units are said to disagree only when both are known and the two share none (a cell may give a conversion too). */
+export const unitsDisagree = (result: ReadonlySet<string>, range: ReadonlySet<string>): boolean =>
+  result.size > 0 && range.size > 0 && ![...result].some((unit) => range.has(unit));
+
+/** A heading without what it says in brackets ("結果（mg/dL）" is 結果, "Reference range (adult)" is reference range). */
+const headingKey = (text: string): string => {
+  const folded = fold(withoutEdgeMarks(text));
+  const bracket = folded.search(BRACKET_OPEN);
+  return (bracket === -1 ? folded : folded.slice(0, bracket)).replace(SPACES, " ").trim();
+};
+
+const columnsOf = (header: Line, words: ReferenceUnitWords, unitsIn: UnitsIn): Column[] => {
+  const cells = cellsOf(header);
+  const kinds = labColumnsOf(
+    cells.map((cell) => cell.text),
+    words.columns,
+    headingKey,
+  );
+  return cells.flatMap((cell, index) => {
+    const role = kinds[index];
+    return role === undefined || role === "flag" ? [] : [{ index, role, units: unitsIn(cell.text) }];
+  });
+};
+
+/** A cell's units: its own, else its column heading's, else the row's unit column. None when the cell holds no number. */
+const unitsOfCell = (cell: Cell | undefined, fallbacks: readonly ReadonlySet<string>[], unitsIn: UnitsIn): ReadonlySet<string> => {
+  if (cell === undefined || !DIGIT.test(fold(cell.text))) return NO_UNITS;
+  const own = unitsIn(cell.text);
+  return own.size > 0 ? own : (fallbacks.find((units) => units.size > 0) ?? NO_UNITS);
+};
+
+const issueAt = (cell: Cell, item: string, range: Cell): StructureIssue => ({
+  offset: cell.start + (cell.text.length - cell.text.trimStart().length),
+  values: { item, result: withoutEdgeMarks(cell.text), range: withoutEdgeMarks(range.text) },
+});
+
+/** Each result cell against each reference range cell (two ranges, for men and women, are two comparisons); one issue a result. */
+const rowIssues = (row: Line, columns: readonly Column[], unitsIn: UnitsIn): StructureIssue[] => {
+  const cells = cellsOf(row);
+  const unitColumn = columns.find((column) => column.role === "unit");
+  const rowUnits = unitColumn === undefined ? NO_UNITS : unitsIn(cells[unitColumn.index]?.text ?? "");
+  const unitsAt = (column: Column): ReadonlySet<string> => unitsOfCell(cells[column.index], [column.units, rowUnits], unitsIn);
+  const ranges = columns.filter((column) => column.role === "range");
+  const item = withoutEdgeMarks(cells[0]?.text ?? "");
+  return columns.flatMap((column) => {
+    const cell = cells[column.index];
+    if (column.role !== "result" || cell === undefined) return [];
+    const range = ranges.find((candidate) => unitsDisagree(unitsAt(column), unitsAt(candidate)));
+    const rangeCell = range === undefined ? undefined : cells[range.index];
+    return rangeCell === undefined ? [] : [issueAt(cell, item, rangeCell)];
+  });
+};
+
+/** The rows of every result table whose result is in another unit than its reference range. */
+export const referenceUnitMismatches = (source: string, words: ReferenceUnitWords): StructureIssue[] => {
+  const unitsIn = unitMatcher(words.units);
+  return tablesOf(linesOf(source)).flatMap((table) => {
+    const columns = columnsOf(table.header, words, unitsIn);
+    if (!columns.some((column) => column.role === "result") || !columns.some((column) => column.role === "range")) return [];
+    return table.rows.flatMap((row) => rowIssues(row, columns, unitsIn));
+  });
+};

package/src/structure/rent-multiple.ts

@@ -1,5 +1,5 @@
-import { escapeRegExp } from "../orthography.ts";
 import type { StructureIssue } from "./issues.ts";
+import { alternation, intervalOf, isMultiple, isPlainGap, nearestStated, occurrences, type Interval, type StatedAmount } from "./stated-multiple.ts";
 
 /**
  * rent-multiple-mismatch: a deposit, key money or guarantee given both as a number of months of rent and as an amount that
@@ -11,15 +11,6 @@ import type { StructureIssue } from "./issues.ts";
  * range of months, and two different pairs in one statement are not compared. 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 RentAmount = {
-  readonly offset: number;
-  readonly end: number;
-  readonly currency: string;
-  readonly value: number;
-  readonly scale: number | undefined;
-};
-
 export type RentMultipleWords = {
   /** Labels of the monthly rent (賃料, Rent). */
   readonly rents: readonly string[];
@@ -41,70 +32,21 @@ export type RentMultipleWords = {
   readonly numberWords: readonly { readonly word: string; readonly value: number }[];
 };
 
-/** An amount read as the interval its written digits allow (9.8万円 is anything from 97,500 to 98,500). */
-export type Interval = { readonly low: number; readonly high: number };
-
 /** A rent or fee as stated. range is undefined when the label has amounts that are not one monthly amount (a change, per week). */
 type Stated = { readonly offset: number; readonly currency: string; readonly range: Interval | undefined; readonly written: string };
 
 type Months = { readonly start: number; readonly end: number; readonly count: number };
 
-/** Rounding to the currency's unit (a yen, a dollar) is allowed on top of the written precision. */
-const UNIT_SLACK = 1;
-
-const LATIN = /[A-Za-z]/u;
-const SEPARATORS = /[\s|｜:：=＝、，,・/／'’()（）[\]［］-]/gu;
-const PARENTHETICAL_WITHOUT_DIGITS = /[（(][^()（）0-9０-９]*[)）]/gu;
-/** The possessive after a months count (2 months' rent, 1 month's rent). */
-const POSSESSIVE = /['’]s?(?![A-Za-z])/gu;
 const RANGE_START = /[0-9０-９A-Za-z一二三四五六七八九十]\s*$/u;
 const SENTENCE_END = /[。！？；;]|[.!?](?=\s|$)/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[]): { readonly start: number; readonly end: number }[] => {
-  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 withoutWords = (text: string, words: readonly string[]): string => {
-  const pattern = alternation(words);
-  return pattern === undefined ? text : text.replace(new RegExp(pattern, "giu"), "");
-};
-
-/** Whether only separators, bracketed words and link words stand in the gap (「 | 」, " (monthly): ", "の", "'s rent ("). */
-export const isPlainGap = (gap: string, words: readonly string[]): boolean =>
-  withoutWords(gap.replace(PARENTHETICAL_WITHOUT_DIGITS, "").replace(POSSESSIVE, ""), words).replace(SEPARATORS, "") === "";
-
-const decimalsOf = (written: string): number => /[.．]([0-9０-９]+)/u.exec(written)?.[1]?.length ?? 0;
-
-/** The interval an amount's digits allow: a word of scale (9.8万) leaves half its last digit either way; plain digits are exact. */
-export const intervalOf = (amount: RentAmount, written: string): Interval => {
-  const half = amount.scale === undefined ? 0 : (amount.scale * 10 ** -decimalsOf(written)) / 2;
-  return { low: amount.value - half, high: amount.value + half };
-};
-
 const lineBounds = (text: string, offset: number): { readonly start: number; readonly end: number } => {
   const end = text.indexOf("\n", offset);
   return { start: text.lastIndexOf("\n", offset - 1) + 1, end: end === -1 ? text.length : end };
 };
 
-const amountsBetween = (amounts: readonly RentAmount[], start: number, end: number): RentAmount[] =>
+const amountsBetween = (amounts: readonly StatedAmount[], start: number, end: number): StatedAmount[] =>
   amounts.filter((amount) => amount.offset >= start && amount.end <= end);
 
 /** A label preceded by a months count (2 months' rent, First month's rent) names a multiple, not the rent. */
@@ -114,7 +56,7 @@ const followsMonths = (before: string, words: RentMultipleWords): boolean => {
 };
 
 /** The second end of a range that starts with this amount (85,000円〜90,000円), if one follows. */
-const rangeEnd = (text: string, first: RentAmount, next: RentAmount | undefined, words: RentMultipleWords): RentAmount | undefined => {
+const rangeEnd = (text: string, first: StatedAmount, next: StatedAmount | undefined, words: RentMultipleWords): StatedAmount | undefined => {
   if (next === undefined || next.currency !== first.currency || next.value < first.value) return undefined;
   const joint = text.slice(first.end, next.offset).trim();
   return words.connectors.some((connector) => connector.toLowerCase() === joint.toLowerCase()) ? next : undefined;
@@ -133,7 +75,7 @@ const labelledEnd = (text: string, from: number, lineEnd: number, words: RentMul
 const statedAt = (
   text: string,
   label: { readonly start: number; readonly end: number },
-  amounts: readonly RentAmount[],
+  amounts: readonly StatedAmount[],
   words: RentMultipleWords,
 ): Stated[] => {
   const line = lineBounds(text, label.start);
@@ -149,7 +91,7 @@ const statedAt = (
 };
 
 /** Each label of the kind followed on its line by an amount (賃料 | 98,000円, Rent: $1,600 to $1,700), in document order. */
-const statedAmounts = (text: string, labels: readonly string[], amounts: readonly RentAmount[], words: RentMultipleWords): Stated[] =>
+const statedAmounts = (text: string, labels: readonly string[], amounts: readonly StatedAmount[], words: RentMultipleWords): Stated[] =>
   occurrences(text, labels).flatMap((label) => statedAt(text, label, amounts, words));
 
 const numberWordValue = (word: string, words: RentMultipleWords): number | undefined =>
@@ -177,13 +119,13 @@ const endsRange = (text: string, months: Months, words: RentMultipleWords): bool
   return words.connectors.some((connector) => before.endsWith(connector) && RANGE_START.test(before.slice(0, -connector.length)));
 };
 
-type Pair = { readonly months: Months; readonly amount: RentAmount };
+type Pair = { readonly months: Months; readonly amount: StatedAmount };
 
-const gapBetween = (text: string, months: Months, amount: RentAmount): string =>
+const gapBetween = (text: string, months: Months, amount: StatedAmount): string =>
   amount.offset >= months.end ? text.slice(months.end, amount.offset) : text.slice(amount.end, months.start);
 
 /** A months count and an amount standing together, either way round (1か月（98,000円）, $3,200 (2 months' rent)). */
-const pairsIn = (text: string, months: readonly Months[], amounts: readonly RentAmount[], words: RentMultipleWords): Pair[] => {
+const pairsIn = (text: string, months: readonly Months[], amounts: readonly StatedAmount[], words: RentMultipleWords): Pair[] => {
   const between = [...words.links, ...words.rents];
   return months.flatMap((count) =>
     amounts
@@ -206,7 +148,7 @@ const statementAt = (
   text: string,
   label: { readonly start: number; readonly end: number },
   next: number | undefined,
-  amounts: readonly RentAmount[],
+  amounts: readonly StatedAmount[],
   words: RentMultipleWords,
 ): Statement[] => {
   const end = statementEnd(text, label.end, next);
@@ -221,19 +163,11 @@ const statementAt = (
 };
 
 /** Every label of a multiple with one months count and one amount (敷金 | 2か月（98,000円）). */
-const multipleStatements = (text: string, amounts: readonly RentAmount[], words: RentMultipleWords): Statement[] => {
+const multipleStatements = (text: string, amounts: readonly StatedAmount[], words: RentMultipleWords): Statement[] => {
   const labels = occurrences(text, words.multiples);
   return labels.flatMap((label, index) => statementAt(text, label, labels[index + 1]?.start, amounts, words));
 };
 
-/** The rent a statement at this offset is of: the nearest before it, or, before any, the one rent the document states. */
-export const rentFor = <T extends Stated>(rents: readonly T[], offset: number): T | undefined => {
-  const before = rents.filter((rent) => rent.offset < offset).at(-1);
-  if (before !== undefined) return before;
-  const [first] = rents;
-  return rents.every((rent) => rent.range !== undefined && rent.range.low === first?.range?.low && rent.range.high === first.range.high) ? first : undefined;
-};
-
 /** The fees of the listing a rent belongs to: those after it and before the next rent; for the first rent, else those before it. */
 export const feesFor = <T extends Stated>(rent: Stated, rents: readonly Stated[], fees: readonly T[]): T[] => {
   const index = rents.indexOf(rent);
@@ -252,12 +186,8 @@ export const monthlyBases = (rent: Interval, fees: readonly Interval[]): Interva
   return [rent, ...withEach, ...withAll];
 };
 
-/** Whether the amount is the count of months of one of the bases, within the written precision and a unit's rounding. */
-export const isMultiple = (count: number, amount: Interval, bases: readonly Interval[]): boolean =>
-  bases.some((base) => count * base.low - UNIT_SLACK <= amount.high && amount.low <= count * base.high + UNIT_SLACK);
-
 const mismatchOf = (text: string, statement: Statement, rents: readonly Stated[], fees: readonly Stated[]): StructureIssue[] => {
-  const rent = rentFor(rents, statement.label);
+  const rent = nearestStated(rents, statement.label);
   const { months, amount } = statement.pair;
   if (rent?.range === undefined || rent.currency !== amount.currency) return [];
   const feeRanges = feesFor(rent, rents, fees).map((fee) => fee.range);
@@ -269,7 +199,7 @@ const mismatchOf = (text: string, statement: Statement, rents: readonly Stated[]
 };
 
 /** Every multiple of rent whose amount is not that many months of the listing's rent (or of the rent and its fee). */
-export const rentMultipleMismatches = (text: string, amounts: readonly RentAmount[], words: RentMultipleWords): StructureIssue[] => {
+export const rentMultipleMismatches = (text: string, amounts: readonly StatedAmount[], words: RentMultipleWords): StructureIssue[] => {
   const rents = statedAmounts(text, words.rents, amounts, words);
   if (rents.length === 0) return [];
   const fees = statedAmounts(text, words.fees, amounts, words);