chaffjs 0.31.0 → 0.33.0

package/src/structure/discount-rate.ts

@@ -0,0 +1,209 @@
+// discount-rate-mismatch: a volume-tier price list whose discount is not what its tier price and its list price give (list
+// 8.0円 a sheet, 7.2円 at 1,000 sheets is 10% off, and the row says 15%). The list price is a column of the table, else the
+// one price the document states as the list price: a sentence (「定価は1枚8.0円」, "The list price is $0.080 per envelope")
+// or a row (| 定価 | 8.0円 |). Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { bodyRows, offsetOf, sameUnit } from "./order-quantity.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+/** rate: the discount column. price: the price after the discount. list: the list price. not: a rate that is no discount (tax). per: a unit mark. */
+export type DiscountRole = "rate" | "price" | "list" | "not" | "per";
+export type DiscountWord = { readonly pattern: string; readonly role: DiscountRole };
+/** A line outside tables and the amounts of money written in it, each at its offset in the line. */
+export type MoneyLine = { readonly text: string; readonly amounts: readonly { readonly offset: number; readonly written: string }[] };
+export type DiscountText = { readonly tables: readonly ChangeTable[]; readonly lines: readonly MoneyLine[] };
+
+type Price = { readonly value: number; readonly marks: string; readonly unit: string | undefined; readonly text: string };
+type StatedRate = { readonly value: number; readonly decimals: number; readonly written: string };
+type Columns = {
+  readonly rate: number;
+  readonly price: number;
+  readonly list: number | undefined;
+  readonly priceUnit: string | undefined;
+  readonly listUnit: string | undefined;
+};
+
+/** A discount written 10%, 12.5 %, -10%, △10%, or in tenths 1割 / 1割5分 (15%). */
+const PERCENT_RATE = /^[-−▲△]?\s*(\d{1,3})(?:\.(\d+))?\s*%$/u;
+const TENTHS_RATE = /^([1-9])割(?:([1-9])分)?$/u;
+const TENTH = 10;
+const HUNDRED = 100;
+const DECIMAL_BASE = 10;
+/** A unit after its mark: 枚 in 1枚, envelope in "per envelope", box in /box. Hiragana ends it (1枚の単価, 1枚あたり). */
+const UNIT_WORD = /^\s*([\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}ー]+)/u;
+const DIGIT_BEFORE = /[\d.,]$/u;
+/** What may stand between a list-price word and its amount once a unit is out: 「定価は1枚8.0円」, "List price: $0.080", "is". */
+const GAP_MARKS = /[\s:：=、,（()）*_.]/gu;
+const GAP_WORDS: readonly string[] = ["あたり", "当たり", "につき", "税抜き", "税抜", "税込み", "税込", "税別", "は", "が", "の"];
+const GAP_LATIN = /^(?:is|was|of|at|each|excl|excluding|incl|including|tax)$/u;
+/** A sentence ends at 。 or at a full stop before a space or the line's end ($0.080 is one amount). */
+const SENTENCE_END = /。|\.(?=\s|$)/u;
+/** A unit after the amount belongs to it up to the next comma: "$0.080 per envelope, excluding tax". */
+const CLAUSE_END = /[,、，]/u;
+const KEY_VALUE_CELLS = 2;
+const ROLE_ORDER: readonly DiscountRole[] = ["list", "price"];
+
+const wordsOf = (words: readonly DiscountWord[], role: DiscountRole): string[] => words.filter((word) => word.role === role).map((word) => word.pattern);
+
+const LATIN_END = /[a-z]$/u;
+
+/** A word as it stands in a lowercased text: a Latin word whole (per is not in "upper"), anything else as written. */
+const wordPattern = (word: string): string => {
+  const written = escapeRegExp(plain(word).toLowerCase());
+  return LATIN_END.test(word.toLowerCase()) ? `(?<![a-z0-9])${written}(?![a-z0-9])` : written;
+};
+
+/**
+ * A discount column heading holds a rate word outside its price words (割引 is not read in 割引後の単価) and no not word;
+ * else it is a list price, then a price.
+ */
+const roleOf = (heading: string, words: readonly DiscountWord[]): DiscountRole | undefined => {
+  const key = plain(heading).toLowerCase();
+  const held = (role: DiscountRole, text = key): boolean => wordsOf(words, role).some((word) => holds(text, word));
+  const outsidePrices = wordsOf(words, "price").reduce((left, word) => left.replace(new RegExp(wordPattern(word), "gu"), " "), key);
+  if (held("rate", outsidePrices)) return held("not") ? "not" : "rate";
+  return ROLE_ORDER.find((role) => held(role));
+};
+
+/** The discount as written: 10%, 1割5分. Undefined for anything else and for 100% and more. */
+export const discountIn = (text: string): StatedRate | undefined => {
+  const written = plain(text);
+  const percent = PERCENT_RATE.exec(written);
+  const tenths = TENTHS_RATE.exec(written);
+  if (percent !== null) {
+    const value = Number(`${percent[1] ?? ""}.${percent[2] ?? "0"}`);
+    return value < HUNDRED ? { value, decimals: percent[2]?.length ?? 0, written } : undefined;
+  }
+  if (tenths === null) return undefined;
+  const value = Number(tenths[1]) * TENTH + Number(tenths[2] ?? 0);
+  return { value, decimals: 0, written };
+};
+
+/** Each unit after a per mark that is not part of a number (1枚, not the 1 of 10枚): where it starts, where it ends, and the unit. */
+const unitsIn = (text: string, words: readonly DiscountWord[]): { readonly start: number; readonly end: number; readonly unit: string }[] => {
+  const key = text.toLowerCase();
+  return wordsOf(words, "per").flatMap((mark) =>
+    [...key.matchAll(new RegExp(wordPattern(mark), "gu"))].flatMap((match) => {
+      const after = match.index + match[0].length;
+      const unit = UNIT_WORD.exec(key.slice(after));
+      if (unit?.[1] === undefined || DIGIT_BEFORE.test(key.slice(0, match.index))) return [];
+      return [{ start: match.index, end: after + unit[0].length, unit: unit[1] }];
+    }),
+  );
+};
+
+/** The one unit a price is of (1枚, "per envelope", 円/枚); undefined when none or two. */
+export const unitOf = (text: string, words: readonly DiscountWord[]): string | undefined => {
+  const units = [...new Set(unitsIn(text, words).map((found) => found.unit))];
+  return units.length === 1 ? units[0] : undefined;
+};
+
+const priceIn = (text: string, unit: string | undefined): Price | undefined => {
+  const value = valueIn(text);
+  return value === undefined || value.value <= 0 ? undefined : { value: value.value, marks: value.marks, unit, text: plain(text) };
+};
+
+/** Only marks and filler words: 「は」, ": ", " is ", " (excl. tax): ". */
+const isGap = (text: string): boolean =>
+  text
+    .toLowerCase()
+    .split(GAP_MARKS)
+    .every((part) => part === "" || GAP_LATIN.test(part) || GAP_WORDS.reduce((left, word) => left.replaceAll(word, ""), part) === "");
+
+const withoutUnits = (text: string, words: readonly DiscountWord[]): string =>
+  unitsIn(text, words)
+    .toSorted((left, right) => right.start - left.start)
+    .reduce((left, found) => left.slice(0, found.start) + left.slice(found.end), text);
+
+/** Each price a line states as the list price: the amount right after a list word, with only fillers and a unit between. */
+const sentencePrices = (line: MoneyLine, words: readonly DiscountWord[]): Price[] => {
+  const key = line.text.toLowerCase();
+  return wordsOf(words, "list").flatMap((word) =>
+    [...key.matchAll(new RegExp(wordPattern(word), "gu"))].flatMap((match) => {
+      const from = match.index + match[0].length;
+      const amount = line.amounts.find((found) => found.offset >= from);
+      if (amount === undefined) return [];
+      const gap = line.text.slice(from, amount.offset);
+      if (!isGap(withoutUnits(gap, words))) return [];
+      const rest = line.text.slice(amount.offset + amount.written.length).split(SENTENCE_END)[0] ?? "";
+      const price = priceIn(amount.written, unitOf(gap, words) ?? unitOf(rest.split(CLAUSE_END)[0] ?? "", words));
+      return price === undefined ? [] : [price];
+    }),
+  );
+};
+
+/** A table row that is a list price: its first cell holds a list word; the price is the price column's cell, or a two-cell row's second. */
+const rowPrice = (row: readonly TableCell[], words: readonly DiscountWord[], priceColumn: number | undefined, unit: string | undefined): Price[] => {
+  const [label] = row;
+  if (label === undefined || roleOf(label.text, words) !== "list") return [];
+  const keyValue = row.length === KEY_VALUE_CELLS ? row[1] : undefined;
+  const cell = priceColumn === undefined ? keyValue : row[priceColumn];
+  const price = cell === undefined ? undefined : priceIn(cell.text, unitOf(label.text, words) ?? unit);
+  return price === undefined ? [] : [price];
+};
+
+const onlyIndex = (indexes: readonly number[]): number | undefined => (indexes.length === 1 ? indexes[0] : undefined);
+
+const columnsOf = (table: ChangeTable, words: readonly DiscountWord[]): Columns | undefined => {
+  const roles = table.header.map((cell) => roleOf(cell.text, words));
+  const at = (role: DiscountRole): number[] => roles.flatMap((found, index) => (found === role ? [index] : []));
+  const [rate, price, lists] = [onlyIndex(at("rate")), onlyIndex(at("price")), at("list")];
+  if (rate === undefined || price === undefined || lists.length > 1) return undefined;
+  const list = lists[0];
+  const [priceUnit, listUnit] = [
+    unitOf(table.header[price]?.text ?? "", words),
+    list === undefined ? undefined : unitOf(table.header[list]?.text ?? "", words),
+  ];
+  return { rate, price, list, priceUnit, listUnit };
+};
+
+/** The one list price the document states in a sentence or a table row; undefined when none, or two different ones. */
+const statedListPrice = (text: DiscountText, words: readonly DiscountWord[]): Price | undefined => {
+  const fromTables = text.tables.flatMap((table) => {
+    const columns = columnsOf(table, words);
+    return bodyRows(table).flatMap((row) => rowPrice(row, words, columns?.price, columns?.priceUnit));
+  });
+  const prices = [...text.lines.flatMap((line) => sentencePrices(line, words)), ...fromTables];
+  const distinct = new Set(prices.map((price) => `${String(price.value)}|${price.marks}|${price.unit ?? ""}`));
+  return distinct.size === 1 ? prices[0] : undefined;
+};
+
+/** Whether the stated rate is the discount within its own rounding, or the tier price is the list less the rate within the price's. */
+export const discountMatches = (list: number, tier: number, stated: number, decimals: number, tierStep: number): boolean => {
+  const computed = (1 - tier / list) * HUNDRED;
+  const rateStep = DECIMAL_BASE ** -decimals;
+  const epsilon = 1e-9;
+  return Math.abs(computed - stated) < rateStep - epsilon || Math.abs(list * (1 - stated / HUNDRED) - tier) < tierStep - epsilon;
+};
+
+/** The row's list price: its list column's cell, else the stated one; undefined when its unit is not the tier price's. */
+const listPriceOf = (row: readonly TableCell[], columns: Columns, stated: Price | undefined): Price | undefined => {
+  const listCell = columns.list === undefined ? undefined : row[columns.list];
+  const list = listCell === undefined ? stated : priceIn(listCell.text, columns.listUnit);
+  const otherUnit = list?.unit !== undefined && columns.priceUnit !== undefined && !sameUnit(list.unit, columns.priceUnit);
+  return otherUnit ? undefined : list;
+};
+
+const rowIssue = (row: readonly TableCell[], columns: Columns, stated: Price | undefined): StructureIssue[] => {
+  const [rateCell, priceCell] = [row[columns.rate], row[columns.price]];
+  const list = listPriceOf(row, columns, stated);
+  const rate = rateCell === undefined ? undefined : discountIn(rateCell.text);
+  const tier = priceCell === undefined ? undefined : valueIn(priceCell.text);
+  if (rateCell === undefined || list === undefined || rate === undefined || tier === undefined || tier.marks !== list.marks) return [];
+  // A price not below the list price is no tier price: an invoice's price before its discount, another unit, a surcharge.
+  if (tier.value >= list.value || discountMatches(list.value, tier.value, rate.value, rate.decimals, tier.step)) return [];
+  const computed = ((1 - tier.value / list.value) * HUNDRED).toFixed(rate.decimals);
+  const values = { written: rate.written, expected: `${computed}%`, list: list.text, price: plain(priceCell?.text ?? "") };
+  return [{ offset: offsetOf(rateCell), values }];
+};
+
+/** Each discount in a tier table that its row's price and the list price do not give. */
+export const discountRateMismatches = (text: DiscountText, words: readonly DiscountWord[]): StructureIssue[] => {
+  if (words.length === 0) return [];
+  const stated = statedListPrice(text, words);
+  return text.tables.flatMap((table) => {
+    const columns = columnsOf(table, words);
+    return columns === undefined ? [] : bodyRows(table).flatMap((row) => rowIssue(row, columns, stated));
+  });
+};

package/src/structure/formula-amount.ts

@@ -0,0 +1,236 @@
+import type { StructureIssue } from "./issues.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { alternation, intervalOf, type Interval, type StatedAmount } from "./stated-multiple.ts";
+import { statedTaxRates, type TaxPriceWord } from "./tax-price.ts";
+import { roundedMatches } from "./tax.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * formula-amount-mismatch: a row whose label writes the formula of its amount (仲介手数料（売買代金の3%＋60,000円、消費税込み）
+ * | 1,650,000円, "Commission (5% of the sale price) | $16,200.00") is worked out from the amount the document labels with that
+ * name (売買代金 | 48,000,000円) and compared with the row's amount. A label that says the tax is included adds the rate
+ * the label states, else the one rate the document states beside a tax word, else the profile's rate. The words come from the
+ * lexicons. Pure.
+ */
+
+export type FormulaWords = {
+  /** Words between a name and its rate (売買代金の3%). */
+  readonly nameRate: readonly string[];
+  /** Words between a rate and its name (3% of the sale price). */
+  readonly rateName: readonly string[];
+  /** Words before a fixed amount added to the rate's part (＋60,000円, plus $500). */
+  readonly plus: readonly string[];
+  /** The marks of a percent (%, ％, percent). */
+  readonly percent: readonly string[];
+  /** The words of a price with tax and of a tax rate (税込み, 消費税), as tax-mismatch reads them. */
+  readonly tax: readonly TaxPriceWord[];
+  /** The names of a tax (消費税, VAT) and the words that say it is included (込み, included): 消費税8%込み, VAT included. */
+  readonly taxNames: readonly string[];
+  readonly includedWords: readonly string[];
+  /** Words that say a tax is left out although a word of inclusion stands in them (not included, 含まない). */
+  readonly notIncluded: readonly string[];
+};
+
+export type FormulaText = {
+  readonly text: string;
+  readonly amounts: readonly StatedAmount[];
+  /** The tax rate a label's tax-included word means when neither the label nor the document states one (the profile's). */
+  readonly defaultTaxRate: number | undefined;
+};
+
+/** The rate and the name it is of, with where they stand in the label. */
+type Formula = { readonly start: number; readonly end: number; readonly rate: number; readonly name: string };
+type Named = Omit<Formula, "rate">;
+
+/** A line ending in one amount after a separator, and the label before that separator. */
+type Row = { readonly line: Line; readonly label: string; readonly amount: StatedAmount };
+
+/** What the row's amount is worked out from. */
+type Terms = { readonly formula: Formula; readonly base: StatedAmount; readonly fixed: StatedAmount | undefined; readonly tax: number };
+
+const CENTS = 100;
+const HUNDRED = 100;
+const NAME_MAX = 40;
+const AFTER_AMOUNT = /^[\s|｜]*$/u;
+const SEPARATOR = /[|｜:：]\s*$/u;
+const NAME_EDGE = "()（）、,，;；|｜:：「」『』";
+const LAST_EDGE = new RegExp(`[${escapeRegExp(NAME_EDGE)}][^${escapeRegExp(NAME_EDGE)}]*$`, "u");
+const LIST_MARK = /^(?:[-*+・]|\d+[.)])\s+/u;
+const DIGITS = /[0-9０-９]/u;
+const NUMBER = /\d[\d,]*(?:\.\d+)?/u;
+/** Four digits or more with no comma: the row groups none, so the expected amount is not grouped either. */
+const UNGROUPED = /\d{4}/u;
+
+const numberOf = (written: string): number => Number(written.normalize("NFKC"));
+
+const percentPattern = (words: FormulaWords): RegExp | undefined => {
+  const marks = alternation(words.percent);
+  return marks === undefined ? undefined : new RegExp(`(?<![0-9０-９.,．，])([0-9０-９]+(?:[.．][0-9０-９]+)?)\\s?(?:${marks})`, "giu");
+};
+
+const amountsWithin = (amounts: readonly StatedAmount[], start: number, end: number): StatedAmount[] =>
+  amounts.filter((amount) => amount.offset >= start && amount.end <= end);
+
+/** The line's last amount, with only a separator before it and nothing after it, and the text before that separator. */
+const rowOf = (text: string, line: Line, amounts: readonly StatedAmount[]): Row | undefined => {
+  const end = line.start + line.text.length;
+  const amount = amountsWithin(amounts, line.start, end).at(-1);
+  if (amount === undefined || amount.scale !== undefined || !AFTER_AMOUNT.test(text.slice(amount.end, end))) return undefined;
+  const before = text.slice(line.start, amount.offset);
+  const separator = SEPARATOR.exec(before);
+  return separator === null ? undefined : { line, label: before.slice(0, separator.index), amount };
+};
+
+const isName = (name: string): boolean => name !== "" && name.length <= NAME_MAX && !DIGITS.test(name);
+
+/** 売買代金の3%: the name runs back from the word to the nearest bracket, comma or cell edge. */
+const nameBefore = (label: string, rateStart: number, words: FormulaWords): Named | undefined => {
+  const head = label.slice(0, rateStart).trimEnd();
+  const word = words.nameRate.find((each) => head.toLowerCase().endsWith(each.toLowerCase()));
+  if (word === undefined) return undefined;
+  const upTo = head.slice(0, head.length - word.length);
+  const edge = LAST_EDGE.exec(upTo);
+  const from = edge === null ? 0 : edge.index + 1;
+  const raw = upTo.slice(from).replace(LIST_MARK, "");
+  const name = raw.trim();
+  return isName(name) ? { start: upTo.length - raw.trimStart().length, end: rateStart, name } : undefined;
+};
+
+/** 3% of the sale price: the name runs on from the word to a bracket, a comma, a plus word or a tax phrase (incl. tax). */
+const nameAfter = (label: string, rateEnd: number, words: FormulaWords): Named | undefined => {
+  const joiner = alternation(words.rateName);
+  const word = joiner === undefined ? null : new RegExp(`^\\s*(?:${joiner})\\s+`, "iu").exec(label.slice(rateEnd));
+  if (word === null) return undefined;
+  const from = rateEnd + word[0].length;
+  const taxPhrases = words.tax.filter((each) => each.role !== "rate").map((each) => each.pattern);
+  const stops = [`[${escapeRegExp(NAME_EDGE)}]`, alternation([...words.plus, ...taxPhrases]) ?? "(?!)"];
+  const stop = new RegExp(stops.join("|"), "iu").exec(label.slice(from));
+  const name = label.slice(from, stop === null ? label.length : from + stop.index).trim();
+  return isName(name) ? { start: from, end: from + name.length, name } : undefined;
+};
+
+/** The one rate in the label that names what it is of; two such rates are not read. */
+const formulaIn = (label: string, words: FormulaWords): Formula | undefined => {
+  const pattern = percentPattern(words);
+  if (pattern === undefined) return undefined;
+  const found = [...label.matchAll(pattern)].flatMap((match) => {
+    const rateEnd = match.index + match[0].length;
+    const named = nameBefore(label, match.index, words) ?? nameAfter(label, rateEnd, words);
+    if (named === undefined) return [];
+    return [{ start: Math.min(named.start, match.index), end: Math.max(named.end, rateEnd), rate: numberOf(match[1] ?? ""), name: named.name }];
+  });
+  const others = [...label.matchAll(pattern)].length - found.length;
+  return found.length === 1 && others <= statedTaxRates([label], words.tax).length ? found[0] : undefined;
+};
+
+/**
+ * The amount right after a plus word after the formula (＋60,000円), or none. Undefined when the label holds any other
+ * amount, or a plus word with no amount after it: the formula is then not all written in the label.
+ */
+const fixedOf = (text: string, row: Row, formula: Formula, amounts: readonly StatedAmount[], words: FormulaWords): StatedAmount[] | undefined => {
+  const inLabel = amountsWithin(amounts, row.line.start, row.line.start + row.label.length);
+  const plus = alternation(words.plus);
+  const after = row.line.start + formula.end;
+  const gap = plus === undefined ? null : new RegExp(`^\\s*(?:${plus})\\s*`, "iu").exec(text.slice(after, row.line.start + row.label.length));
+  const fixed = gap === null ? undefined : inLabel.find((amount) => amount.offset === after + gap[0].length);
+  if (gap !== null && fixed === undefined) return undefined;
+  const parts = fixed === undefined ? [] : [fixed];
+  return inLabel.length === parts.length ? parts : undefined;
+};
+
+/**
+ * A word of a price with tax (税込み, incl. tax), or a tax's name with a word of inclusion (消費税8%込み, VAT included); not
+ * when the label also says the tax is left out (税別, excl. tax, tax not included).
+ */
+const isTaxIncluded = (label: string, words: FormulaWords): boolean => {
+  const lower = label.normalize("NFKC").toLowerCase();
+  const holds = (word: string): boolean => lower.includes(word.normalize("NFKC").toLowerCase());
+  const roleHeld = (role: TaxPriceWord["role"]): boolean => words.tax.some((word) => word.role === role && holds(word.pattern));
+  if (roleHeld("excluded") || words.notIncluded.some(holds)) return false;
+  return roleHeld("included") || (words.taxNames.some(holds) && words.includedWords.some(holds));
+};
+
+/** 0 without a tax-included word; else the label's one rate, the document's one rate, or the profile's. Undefined when unknown. */
+const taxRateOf = (row: Row, others: readonly string[], text: FormulaText, words: FormulaWords): number | undefined => {
+  if (!isTaxIncluded(row.label, words)) return 0;
+  const inLabel = statedTaxRates([row.label], words.tax);
+  if (inLabel.length > 0) return inLabel.length === 1 ? inLabel[0] : undefined;
+  const stated = statedTaxRates(others, words.tax);
+  if (stated.length > 0) return stated.length === 1 ? stated[0] : undefined;
+  return text.defaultTaxRate;
+};
+
+/** The amount the document labels with the name (売買代金 | 48,000,000円, Sale price: $324,000), when every such label agrees. */
+const baseOf = (text: string, lines: readonly Line[], row: Row, name: string, amounts: readonly StatedAmount[]): StatedAmount | undefined => {
+  const label = new RegExp(`^[ \\t]*(?:[-*+][ \\t]+)?(?:[|｜][ \\t]*)?(?:\\*\\*)?${escapeRegExp(name)}(?:\\*\\*)?[ \\t]*[|｜:：][ \\t]*`, "iu");
+  const found = lines.flatMap((line) => {
+    const match = line === row.line ? null : label.exec(line.text);
+    const amount = match === null ? undefined : amounts.find((each) => each.offset === line.start + match[0].length);
+    return amount === undefined || amount.currency !== row.amount.currency ? [] : [amount];
+  });
+  const [first] = found;
+  return found.every((amount) => amount.value === first?.value && amount.scale === first.scale) ? first : undefined;
+};
+
+/** Before tax: rate × base + fixed. The base is the interval its written digits allow; a formula's fixed part is exact (＋6万円 is 60,000). */
+const beforeTax = (text: string, terms: Terms): Interval => {
+  const base = intervalOf(terms.base, text.slice(terms.base.offset, terms.base.end));
+  const fixed = terms.fixed?.value ?? 0;
+  return { low: (base.low * terms.formula.rate) / HUNDRED + fixed, high: (base.high * terms.formula.rate) / HUNDRED + fixed };
+};
+
+const ROUNDINGS: readonly ((value: number) => number)[] = [(value) => value, Math.floor, Math.round, Math.ceil];
+
+/** Whether the written amount is the formula's, rounded down, to nearest or up, before tax or after it, to the unit or the cent. */
+export const formulaMatches = (written: number, before: Interval, tax: number): boolean => {
+  const withTax = (value: number): number => (value * (HUNDRED + tax)) / HUNDRED;
+  // A base written with a word of scale (4,800万円) is a range; any amount in it, rounded to the unit, is right.
+  if (before.low < before.high && written >= Math.floor(withTax(before.low)) && written <= Math.ceil(withTax(before.high))) return true;
+  const candidates = [before.low, before.high].flatMap((value) => ROUNDINGS.map((round) => withTax(round(value))));
+  return candidates.some((candidate) => roundedMatches(Math.round(written * CENTS), candidate * CENTS));
+};
+
+/** The expected amount as the row writes it: its unit, its grouping and its decimals. */
+const shownLike = (written: string, value: number): string => {
+  const decimals = NUMBER.exec(written.normalize("NFKC"))?.[0].split(".")[1]?.length ?? 0;
+  const grouped = written.includes(",") || !UNGROUPED.test(written.normalize("NFKC"));
+  const number = value.toLocaleString("en-US", { minimumFractionDigits: decimals, maximumFractionDigits: decimals, useGrouping: grouped });
+  return written.normalize("NFKC").replace(NUMBER, number);
+};
+
+const issueOf = (text: string, row: Row, terms: Terms): StructureIssue[] => {
+  const before = beforeTax(text, terms);
+  if (formulaMatches(row.amount.value, before, terms.tax)) return [];
+  const expected = (((before.low + before.high) / 2) * (HUNDRED + terms.tax)) / HUNDRED;
+  const values = {
+    written: text.slice(row.amount.offset, row.amount.end),
+    expected: shownLike(text.slice(row.amount.offset, row.amount.end), Math.round(expected)),
+    formula: text.slice(row.line.start + terms.formula.start, terms.fixed?.end ?? row.line.start + terms.formula.end),
+    name: terms.formula.name,
+    base: text.slice(terms.base.offset, terms.base.end),
+  };
+  return [{ offset: row.amount.offset, values }];
+};
+
+const termsOf = (input: FormulaText, lines: readonly Line[], row: Row, words: FormulaWords): Terms | undefined => {
+  const formula = formulaIn(row.label, words);
+  if (formula === undefined) return undefined;
+  const fixedList = fixedOf(input.text, row, formula, input.amounts, words);
+  const [fixed] = fixedList ?? [];
+  if (fixedList === undefined || (fixed !== undefined && fixed.currency !== row.amount.currency)) return undefined;
+  const base = baseOf(input.text, lines, row, formula.name, input.amounts);
+  const others = lines.filter((line) => line !== row.line).map((line) => line.text);
+  const tax = taxRateOf(row, others, input, words);
+  return base === undefined || tax === undefined ? undefined : { formula, base, fixed, tax };
+};
+
+/** Every row whose label writes its formula and whose amount is not what the formula gives on the named amount. */
+export const formulaAmountMismatches = (input: FormulaText, words: FormulaWords): StructureIssue[] => {
+  if (words.percent.length === 0 || words.nameRate.length + words.rateName.length === 0) return [];
+  const lines = linesOf(input.text);
+  return lines.flatMap((line) => {
+    const row = rowOf(input.text, line, input.amounts);
+    const terms = row === undefined ? undefined : termsOf(input, lines, row, words);
+    return row === undefined || terms === undefined ? [] : issueOf(input.text, row, terms);
+  });
+};

package/src/structure/generic-role.ts

@@ -0,0 +1,8 @@
+/**
+ * A role word in the plural with nothing before it at the head of a sentence (Customers who register …, Buyers may …) is
+ * the ordinary noun, capitalised because it opens the sentence. A contract that calls a party by its role writes it in the
+ * singular (Vendor shall …) or with an article (the Vendors).
+ */
+const PLURAL = /^s(?![\p{L}\p{N}'’])/u;
+
+export const isGenericPlural = (bare: boolean, after: string): boolean => bare && PLURAL.test(after);