chaffjs 0.30.0 → 0.31.0

package/src/structure/range-bands.ts

@@ -0,0 +1,316 @@
+// range-band-mismatch: the bands of one table column or one list (7〜11歳, 12〜14歳, 15歳以上; under 7, 7 to 11, 12 and over)
+// that overlap or leave a gap between neighbours. The words that bound a band and the units it is counted in come from the
+// lexicons (range-band-word, range-band-unit, range-band-heading). Pure.
+
+/** How an end of a band is written: 以上/以下 (inclusive), 未満/超 (exclusive), or only a range mark (7〜11, 7 to 11). */
+export type BoundKind = "inclusive" | "exclusive" | "loose";
+
+export type Bound = { readonly value: number; readonly kind: BoundKind; readonly decimals: number };
+
+/** Integer units (ages, people, points) have no value between 11 and 12; continuous ones (kg, yen, hours) do. */
+export type UnitKind = "integer" | "continuous";
+
+export type Band = { readonly low: Bound | undefined; readonly high: Bound | undefined; readonly unit: string };
+
+export type BandMarker = {
+  readonly pattern: string;
+  readonly side: "low" | "high";
+  readonly kind: "inclusive" | "exclusive";
+  readonly position: "before" | "after";
+};
+
+export type BandUnit = { readonly pattern: string; readonly kind: UnitKind; readonly position: "before" | "after" };
+
+export type BandWords = {
+  /** Marks between the two ends (〜, –, to). Written after a number alone (12歳〜) it leaves the band open above. */
+  readonly connectors: readonly string[];
+  /** The marks that, before a number alone (〜6歳), close a band above. A hyphen is not one: "- 5" is a bullet or a minus. */
+  readonly openers: readonly string[];
+  readonly markers: readonly BandMarker[];
+  /** Words a band may open with that say nothing about its ends ("ages", "aged"). */
+  readonly leads: readonly string[];
+  readonly units: readonly BandUnit[];
+  /** Column headings that name what bare numbers count (年齢, Age), with the kind of that quantity. */
+  readonly headings: readonly { readonly pattern: string; readonly kind: UnitKind }[];
+};
+
+/** One band as written, with where it is. */
+export type PlacedBand = { readonly band: Band; readonly start: number; readonly end: number; readonly text: string };
+
+export type BandSlip = { readonly kind: "overlap" | "gap"; readonly earlier: PlacedBand; readonly later: PlacedBand };
+
+const NUMBER = /^(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?/u;
+const LATIN_END = /[a-z]$/u;
+const LETTER = /^[a-z]/u;
+const SPACE = /^\s*/u;
+const EMPHASIS = /[*_`]/gu;
+
+/** The text without a note in brackets at its end (15歳以上（成人）), and the note. */
+const splitNote = (text: string): { readonly bare: string; readonly note: string | undefined } => {
+  const open = text.lastIndexOf("(");
+  if (!text.endsWith(")") || open === -1) return { bare: text, note: undefined };
+  return { bare: text.slice(0, open).trim(), note: text.slice(open + 1, -1).trim() };
+};
+
+const plainOf = (text: string): string => text.normalize("NFKC").toLowerCase().replace(EMPHASIS, "").trim();
+
+export const normalizeBandText = (text: string): string => splitNote(plainOf(text)).bare;
+
+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);
+
+type Cursor = { readonly text: string; readonly at: number };
+
+const skipSpace = (cursor: Cursor): Cursor => ({ text: cursor.text, at: cursor.at + (SPACE.exec(cursor.text.slice(cursor.at))?.[0].length ?? 0) });
+
+/** The longest word at the cursor; a Latin word must end at a word edge (to is not the start of total). */
+const wordAt = (cursor: Cursor, words: readonly string[]): string | undefined =>
+  words
+    .map(normalizeWord)
+    .filter((word) => word !== "" && cursor.text.startsWith(word, cursor.at))
+    .filter((word) => !LATIN_END.test(word) || !LETTER.test(cursor.text.slice(cursor.at + word.length)))
+    .reduce<string | undefined>((best, word) => (best === undefined || word.length > best.length ? word : best), undefined);
+
+const advance = (cursor: Cursor, word: string | undefined): Cursor =>
+  word === undefined ? cursor : skipSpace({ text: cursor.text, at: cursor.at + word.length });
+
+type Read<T> = { readonly value: T; readonly cursor: Cursor } | undefined;
+
+const numberAt = (cursor: Cursor): Read<{ value: number; decimals: number }> => {
+  const written = NUMBER.exec(cursor.text.slice(cursor.at))?.[0];
+  if (written === undefined) return undefined;
+  const digits = written.replaceAll(",", "");
+  return { value: { value: Number(digits), decimals: digits.split(".")[1]?.length ?? 0 }, cursor: advance(cursor, written) };
+};
+
+const unitsAt = (cursor: Cursor, words: BandWords, position: "before" | "after"): Read<string | undefined> => {
+  const unit = wordAt(
+    cursor,
+    words.units.filter((entry) => entry.position === position).map((entry) => entry.pattern),
+  );
+  return { value: unit, cursor: advance(cursor, unit) };
+};
+
+const markerAt = (cursor: Cursor, words: BandWords, position: "before" | "after"): Read<BandMarker | undefined> => {
+  const markers = words.markers.filter((marker) => marker.position === position);
+  const word = wordAt(
+    cursor,
+    markers.map((marker) => marker.pattern),
+  );
+  return { value: markers.find((marker) => normalizeWord(marker.pattern) === word), cursor: advance(cursor, word) };
+};
+
+/** One number with the units written around it ($5, 7歳, 8 years). */
+type Figure = { readonly value: number; readonly decimals: number; readonly units: readonly string[] };
+
+const figureAt = (cursor: Cursor, words: BandWords): Read<Figure> => {
+  const prefix = unitsAt(cursor, words, "before");
+  const number = prefix === undefined ? undefined : numberAt(prefix.cursor);
+  const suffix = number === undefined ? undefined : unitsAt(number.cursor, words, "after");
+  if (prefix === undefined || number === undefined || suffix === undefined) return undefined;
+  const units = [prefix.value, suffix.value].filter((unit) => unit !== undefined);
+  return { value: { ...number.value, units }, cursor: suffix.cursor };
+};
+
+const boundOf = (figure: Figure, kind: BoundKind): Bound => ({ value: figure.value, kind, decimals: figure.decimals });
+
+/** A band with the units it was written in. undefined when the text is not one band of one unit. */
+type Parsed = { readonly low: Bound | undefined; readonly high: Bound | undefined; readonly units: readonly string[] };
+
+const withMarker = (figure: Figure, marker: BandMarker): Parsed => ({
+  low: marker.side === "low" ? boundOf(figure, marker.kind) : undefined,
+  high: marker.side === "high" ? boundOf(figure, marker.kind) : undefined,
+  units: figure.units,
+});
+
+/** One end with its word: 15歳以上, 7 and over, under 7. */
+const markedEnd = (cursor: Cursor, words: BandWords): Read<{ readonly parsed: Parsed; readonly side: "low" | "high" }> => {
+  const before = markerAt(cursor, words, "before");
+  const figure = before === undefined ? undefined : figureAt(before.cursor, words);
+  const after = figure === undefined ? undefined : markerAt(figure.cursor, words, "after");
+  if (before === undefined || figure === undefined || after === undefined) return undefined;
+  const marker = before.value ?? after.value;
+  if (marker === undefined || (before.value !== undefined && after.value !== undefined)) return undefined;
+  const unit = unitsAt(after.cursor, words, "after");
+  if (unit === undefined) return undefined;
+  const parsed = withMarker(figure.value, marker);
+  return {
+    value: { parsed: { ...parsed, units: [...parsed.units, ...(unit.value === undefined ? [] : [unit.value])] }, side: marker.side },
+    cursor: unit.cursor,
+  };
+};
+
+/** 15歳以上, under 7, and both ends with their words: 7歳以上12歳未満. */
+const markedBand = (cursor: Cursor, words: BandWords): Read<Parsed> => {
+  const first = markedEnd(cursor, words);
+  if (first === undefined) return undefined;
+  const rest = first.value.side === "low" ? markedEnd(first.cursor, words) : undefined;
+  if (rest === undefined || rest.value.side !== "high") return { value: first.value.parsed, cursor: first.cursor };
+  const units = [...first.value.parsed.units, ...rest.value.parsed.units];
+  return { value: { low: first.value.parsed.low, high: rest.value.parsed.high, units }, cursor: rest.cursor };
+};
+
+/** 7〜11歳, 7 to 11, 12歳〜, 〜6歳. */
+const spannedBand = (cursor: Cursor, words: BandWords): Read<Parsed> => {
+  const leading = wordAt(cursor, words.openers);
+  const first = figureAt(advance(cursor, leading), words);
+  if (first === undefined) return undefined;
+  if (leading !== undefined) return { value: { low: undefined, high: boundOf(first.value, "loose"), units: first.value.units }, cursor: first.cursor };
+  const connector = wordAt(first.cursor, words.connectors);
+  if (connector === undefined) return undefined;
+  const second = figureAt(advance(first.cursor, connector), words);
+  if (second === undefined)
+    return { value: { low: boundOf(first.value, "loose"), high: undefined, units: first.value.units }, cursor: advance(first.cursor, connector) };
+  return {
+    value: { low: boundOf(first.value, "loose"), high: boundOf(second.value, "loose"), units: [...first.value.units, ...second.value.units] },
+    cursor: second.cursor,
+  };
+};
+
+/** The band a cell or the head of a list item states, or undefined when the whole text is not one band in one unit. */
+export const parseBand = (written: string, words: BandWords): Band | undefined => {
+  const text = normalizeBandText(written);
+  const start = skipSpace({ text, at: 0 });
+  const begun = advance(start, wordAt(start, words.leads));
+  const read = [begun, start]
+    .flatMap((cursor) => [markedBand(cursor, words), spannedBand(cursor, words)])
+    .find((reading) => reading !== undefined && reading.cursor.at === text.length);
+  if (read === undefined) return undefined;
+  const units = new Set(read.value.units.map(unitKey));
+  if (units.size > 1) return undefined;
+  const { low, high } = read.value;
+  if (low !== undefined && high !== undefined && low.value >= high.value) return undefined;
+  return { low, high, unit: [...units][0] ?? "" };
+};
+
+/** The kind of a unit, by the unit lexicon. */
+export const unitKindOf = (unit: string, words: BandWords): UnitKind | undefined =>
+  words.units.find((entry) => unitKey(normalizeWord(entry.pattern)) === unit)?.kind;
+
+/** What bare numbers under a column heading count: by a word of the heading lexicon, or a unit in brackets (体重(kg)). */
+export const headingOf = (heading: string, words: BandWords): { readonly unit: string; readonly kind: UnitKind } | undefined => {
+  const { bare, note } = splitNote(plainOf(heading).replaceAll("[", "(").replaceAll("]", ")"));
+  const unit = note === undefined ? undefined : unitKey(note);
+  const unitKind = unit === undefined ? undefined : unitKindOf(unit, words);
+  if (unit !== undefined && unitKind !== undefined) return { unit, kind: unitKind };
+  const named = words.headings.find((entry) => normalizeWord(entry.pattern) === bare);
+  return named === undefined ? undefined : { unit: "", kind: named.kind };
+};
+
+type Span = { readonly low: number; readonly high: number };
+
+const POSITIVE = Number.POSITIVE_INFINITY;
+const NEGATIVE = Number.NEGATIVE_INFINITY;
+
+/** The band as the values it holds. An integer band's exclusive end is the next whole number in (7歳未満 holds up to 6). */
+const spanOf = (band: Band, integer: boolean): Span => {
+  const step = integer ? 1 : 0;
+  const inward = (bound: Bound): number => (bound.kind === "exclusive" ? step : 0);
+  return {
+    low: band.low === undefined ? NEGATIVE : band.low.value + inward(band.low),
+    high: band.high === undefined ? POSITIVE : band.high.value - inward(band.high),
+  };
+};
+
+/** Bands written in one direction, each starting and ending past the one before. Nested tiers (〜100万円, 〜200万円) are not. */
+const orderOf = (spans: readonly Span[]): "up" | "down" | undefined => {
+  const pairs = spans.slice(1).flatMap((span, index): [Span, Span][] => {
+    const previous = spans[index];
+    return previous === undefined ? [] : [[previous, span]];
+  });
+  if (pairs.every(([a, b]) => a.low < b.low && a.high < b.high)) return "up";
+  if (pairs.every(([a, b]) => a.low > b.low && a.high > b.high)) return "down";
+  return undefined;
+};
+
+/** Smallest step the two numbers are written to (59 and 60: 1; 59.9 and 60: 0.1). */
+const stepOf = (a: Bound, b: Bound): number => 10 ** -Math.max(a.decimals, b.decimals);
+
+const ROUNDING = 1e-9;
+
+type Meeting = "overlap" | "gap" | undefined;
+
+/** Whole numbers: the next band starts one past the end of the one below. */
+const integerJunction = (below: Band, above: Band): Meeting => {
+  const distance = spanOf(above, true).low - spanOf(below, true).high;
+  if (distance <= 0) return "overlap";
+  return distance > 1 ? "gap" : undefined;
+};
+
+/** At one number, an end included on both sides overlaps and one excluded on both sides leaves the number out. */
+const sameNumber = (end: Bound, start: Bound): Meeting => {
+  if (start.kind === "inclusive" && end.kind === "inclusive") return "overlap";
+  return start.kind === "exclusive" && end.kind === "exclusive" ? "gap" : undefined;
+};
+
+/** Values in between: a shared end with a range mark, or ends a written step apart, are contiguous. */
+const continuousJunction = (end: Bound, start: Bound): Meeting => {
+  if (start.value < end.value) return "overlap";
+  if (start.value === end.value) return sameNumber(end, start);
+  if (start.kind === "exclusive" || end.kind === "exclusive") return "gap";
+  return start.value - end.value > stepOf(start, end) + ROUNDING ? "gap" : undefined;
+};
+
+/** Where the band below ends and the band above starts. */
+const junctionOf = (below: Band, above: Band, integer: boolean): Meeting => {
+  if (below.high === undefined || above.low === undefined) return undefined;
+  return integer ? integerJunction(below, above) : continuousJunction(below.high, above.low);
+};
+
+const widthOf = (span: Span, integer: boolean): number => span.high - span.low + (integer ? 1 : 0);
+
+type Junction = { readonly kind: "overlap" | "gap"; readonly size: number; readonly narrower: number };
+
+/** How much the bands overlap or leave out, next to the narrower of the two. */
+const junctionSize = (kind: "overlap" | "gap", below: Span, above: Span, integer: boolean): Junction => {
+  const edge = integer ? 1 : 0;
+  const size = kind === "overlap" ? below.high - above.low + edge : above.low - below.high - edge;
+  return { kind, size, narrower: Math.min(widthOf(below, integer), widthOf(above, integer)) };
+};
+
+/** An overlap of more than half the narrower band is deliberate: a size guide whose bands share a range. */
+const isDeliberate = (junction: Junction): boolean => junction.kind === "overlap" && junction.size * 2 > junction.narrower;
+
+/**
+ * The overlaps and gaps between neighbouring bands of one column or list. The bands must all be counted in one unit (bare
+ * numbers take the column's), written in one direction; the slip is reported at the later of the two in the document. A run
+ * with one deliberate overlap is a scale meant to overlap, and two bands alone are reported only when the hole or overlap is
+ * no wider than the narrower band.
+ */
+export const bandSlips = (bands: readonly PlacedBand[], kind: UnitKind): BandSlip[] => {
+  if (bands.length < 2) return [];
+  const integer = kind === "integer" && bands.every(({ band }) => [band.low, band.high].every((bound) => bound === undefined || bound.decimals === 0));
+  const order = orderOf(bands.map(({ band }) => spanOf(band, integer)));
+  if (order === undefined) return [];
+  const ascending = order === "up" ? [...bands] : [...bands].reverse();
+  const junctions = ascending.slice(1).flatMap((above, index) => {
+    const below = ascending[index];
+    const slip = below === undefined ? undefined : junctionOf(below.band, above.band, integer);
+    return below === undefined || slip === undefined
+      ? []
+      : [{ below, above, ...junctionSize(slip, spanOf(below.band, integer), spanOf(above.band, integer), integer) }];
+  });
+  if (junctions.some(isDeliberate)) return [];
+  const pair = bands.length === 2;
+  return junctions
+    .filter((junction) => !pair || junction.size <= junction.narrower)
+    .map(({ below, above, kind: slip }) => {
+      const [earlier, later] = below.start < above.start ? [below, above] : [above, below];
+      return { kind: slip, earlier, later };
+    });
+};
+
+/** The unit and kind of a run of bands: one unit for all (bare numbers take the heading's), or undefined. */
+export const runKindOf = (
+  bands: readonly Band[],
+  heading: { readonly unit: string; readonly kind: UnitKind } | undefined,
+  words: BandWords,
+): UnitKind | undefined => {
+  const units = new Set([...bands.map((band) => band.unit), heading?.unit ?? ""].filter((unit) => unit !== ""));
+  if (units.size > 1) return undefined;
+  const unit = [...units][0];
+  if (unit === undefined) return heading?.kind;
+  return unitKindOf(unit, words);
+};

package/src/structure/rent-multiple.ts

@@ -0,0 +1,277 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * rent-multiple-mismatch: a deposit, key money or guarantee given both as a number of months of rent and as an amount that
+ * is not that many months of the listing's rent (敷金 2か月（98,000円） with 賃料 98,000円; "Deposit: Six months' rent
+ * ($145,000)" with Rent $21,500). The rent is the nearest one stated before the deposit (several listings on one page each
+ * state their own); a document whose deposits come before any rent uses the rent only when it states one. When the document
+ * also states a fee beside the rent (管理費, service charge), the multiple may be of the rent alone or of the rent and the
+ * fee, since listings do both and seldom say which. A months count without an amount, an amount without a months count, a
+ * 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[];
+  /** Labels of a monthly fee paid with the rent (管理費, Service charge). */
+  readonly fees: readonly string[];
+  /** Labels of an amount stated in months of rent (敷金, 礼金, Security deposit). */
+  readonly multiples: readonly string[];
+  /** The word of a month after a count (か月, months). */
+  readonly months: readonly string[];
+  /** Words that may stand between a label or a months count and its amount (は, 分, of, equal to). */
+  readonly links: readonly string[];
+  /** Words that say an amount is not per month (per week, 年額, per sq ft); a rent line with one is not read. */
+  readonly periods: readonly string[];
+  /** Words that make the amount something other than the plain multiple (税込, tax included). */
+  readonly skips: readonly string[];
+  /** Marks and words that join the two ends of a range (〜, to). */
+  readonly connectors: readonly string[];
+  /** Numbers written as words (six, 一) and their values. */
+  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[] =>
+  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. */
+const followsMonths = (before: string, words: RentMultipleWords): boolean => {
+  const trimmed = before.replace(/['’]s?\s*$/u, "").trimEnd();
+  return words.months.some((month) => trimmed.toLowerCase().endsWith(month.toLowerCase()));
+};
+
+/** 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 => {
+  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;
+};
+
+/** Where a label's own amount must be: before the next label of any kind on its line (賃料 98,000円 管理費 6,000円). */
+const labelledEnd = (text: string, from: number, lineEnd: number, words: RentMultipleWords): number => {
+  const [next] = occurrences(text.slice(from, lineEnd), [...words.rents, ...words.fees, ...words.multiples]);
+  return next === undefined ? lineEnd : from + next.start;
+};
+
+/**
+ * A rent or fee stated with one amount or one range of amounts. With a second amount (a change from one to another, two
+ * units) or a word of another period on the line (per week, 年額), it is stated but its monthly amount is not known.
+ */
+const statedAt = (
+  text: string,
+  label: { readonly start: number; readonly end: number },
+  amounts: readonly RentAmount[],
+  words: RentMultipleWords,
+): Stated[] => {
+  const line = lineBounds(text, label.start);
+  const [first, second, ...rest] = amountsBetween(amounts, label.end, labelledEnd(text, label.end, line.end, words));
+  if (first === undefined || !isPlainGap(text.slice(label.end, first.offset), words.links)) return [];
+  if (followsMonths(text.slice(line.start, label.start), words)) return [];
+  const last = rangeEnd(text, first, second, words) ?? first;
+  const written = text.slice(first.offset, last.end);
+  const unclear = (second !== undefined && last !== second) || rest.length > 0 || occurrences(text.slice(line.start, line.end), words.periods).length > 0;
+  if (unclear) return [{ offset: label.start, currency: first.currency, range: undefined, written }];
+  const range = { low: intervalOf(first, text.slice(first.offset, first.end)).low, high: intervalOf(last, text.slice(last.offset, last.end)).high };
+  return [{ offset: label.start, currency: first.currency, range, written }];
+};
+
+/** 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[] =>
+  occurrences(text, labels).flatMap((label) => statedAt(text, label, amounts, words));
+
+const numberWordValue = (word: string, words: RentMultipleWords): number | undefined =>
+  words.numberWords.find((entry) => entry.word.toLowerCase() === word.toLowerCase())?.value;
+
+const countOf = (written: string, words: RentMultipleWords): number => numberWordValue(written, words) ?? Number(written.normalize("NFKC"));
+
+/** The months counts in a piece of text (2か月, Six months), with the offset of the piece. */
+export const monthsIn = (piece: string, offset: number, words: RentMultipleWords): Months[] => {
+  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 [...piece.matchAll(pattern)].map((match) => ({
+    start: offset + match.index,
+    end: offset + match.index + match[0].length,
+    count: countOf(match[1] ?? "", words),
+  }));
+};
+
+/** Whether a months count is the upper end of a range (1〜2か月). */
+const endsRange = (text: string, months: Months, words: RentMultipleWords): boolean => {
+  const before = text.slice(Math.max(0, months.start - 12), months.start).trimEnd();
+  return words.connectors.some((connector) => before.endsWith(connector) && RANGE_START.test(before.slice(0, -connector.length)));
+};
+
+type Pair = { readonly months: Months; readonly amount: RentAmount };
+
+const gapBetween = (text: string, months: Months, amount: RentAmount): 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 between = [...words.links, ...words.rents];
+  return months.flatMap((count) =>
+    amounts
+      .filter((amount) => (amount.offset >= count.end || amount.end <= count.start) && isPlainGap(gapBetween(text, count, amount), between))
+      .map((amount) => ({ months: count, amount })),
+  );
+};
+
+type Statement = { readonly label: number; readonly pair: Pair };
+
+/** Where the statement of one label ends: at the next label of its kind, the end of the sentence, or the end of the line. */
+const statementEnd = (text: string, from: number, nextLabel: number | undefined): number => {
+  const line = lineBounds(text, from);
+  const sentence = SENTENCE_END.exec(text.slice(from, line.end));
+  return Math.min(line.end, nextLabel ?? line.end, sentence === null ? line.end : from + sentence.index);
+};
+
+/** One label's months count and amount, when the statement holds exactly one such pair and no word that makes it another. */
+const statementAt = (
+  text: string,
+  label: { readonly start: number; readonly end: number },
+  next: number | undefined,
+  amounts: readonly RentAmount[],
+  words: RentMultipleWords,
+): Statement[] => {
+  const end = statementEnd(text, label.end, next);
+  const piece = text.slice(label.end, end);
+  if (occurrences(piece, words.skips).length > 0) return [];
+  const months = monthsIn(piece, label.end, words);
+  if (months.some((count) => endsRange(text, count, words))) return [];
+  const pairs = pairsIn(text, months, amountsBetween(amounts, label.end, end), words);
+  const [pair] = pairs;
+  const single = pairs.every((other) => other.months.count === pair?.months.count && other.amount.value === pair.amount.value);
+  return pair === undefined || !single ? [] : [{ label: label.start, pair }];
+};
+
+/** 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 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);
+  const next = rents[index + 1]?.offset ?? Number.POSITIVE_INFINITY;
+  const ofCurrency = fees.filter((fee) => fee.currency === rent.currency);
+  const after = ofCurrency.filter((fee) => fee.offset > rent.offset && fee.offset < next);
+  return after.length > 0 || index > 0 ? after : ofCurrency.filter((fee) => fee.offset < rent.offset);
+};
+
+const plus = (left: Interval, right: Interval): Interval => ({ low: left.low + right.low, high: left.high + right.high });
+
+/** The monthly amounts a multiple may be of: the rent alone, the rent with each fee, and the rent with every fee. */
+export const monthlyBases = (rent: Interval, fees: readonly Interval[]): Interval[] => {
+  const withEach = fees.map((fee) => plus(rent, fee));
+  const withAll = fees.length > 1 ? [fees.reduce(plus, rent)] : [];
+  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 { months, amount } = statement.pair;
+  if (rent?.range === undefined || rent.currency !== amount.currency) return [];
+  const feeRanges = feesFor(rent, rents, fees).map((fee) => fee.range);
+  if (!feeRanges.every((range) => range !== undefined)) return [];
+  const bases = monthlyBases(rent.range, feeRanges);
+  if (isMultiple(months.count, intervalOf(amount, text.slice(amount.offset, amount.end)), bases)) return [];
+  const values = { months: text.slice(months.start, months.end), amount: text.slice(amount.offset, amount.end), rent: rent.written };
+  return [{ offset: Math.min(months.start, amount.offset), values }];
+};
+
+/** 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[] => {
+  const rents = statedAmounts(text, words.rents, amounts, words);
+  if (rents.length === 0) return [];
+  const fees = statedAmounts(text, words.fees, amounts, words);
+  return multipleStatements(text, amounts, words).flatMap((statement) => mismatchOf(text, statement, rents, fees));
+};