chaffjs 0.31.0 → 0.32.0

package/src/structure/deductible-limit.ts

@@ -0,0 +1,255 @@
+import { escapeRegExp } from "../orthography.ts";
+import { keyOf, proseValues, type AmountWords, type ProseFigure, type ProseQuantity } from "./ratio.ts";
+
+/**
+ * deductible-exceeds-limit: the deciding half. In one sentence naming one deductible (免責金額, excess) and one limit
+ * (支払限度額, the most we pay), each with one amount of money right after it, a deductible larger than the limit for a
+ * comparable basis (1回, a claim, 1品, a single item) means the benefit pays nothing. The words are lexicons; nothing here
+ * knows a word of insurance. Pure.
+ */
+
+/** A basis an amount is stated for (1回, a visit, 1品). rank orders the bases that nest: a claim holds one item or more. */
+export type BasisWord = { readonly pattern: string; readonly basis: string; readonly rank?: number | undefined };
+
+export type DeductibleWords = {
+  readonly deductibles: readonly string[];
+  readonly limits: readonly string[];
+  /** Phrases holding a deductible word without naming a deductible ("in excess of", 自己負担限度額). */
+  readonly notDeductibles: readonly string[];
+  /** Phrases holding a limit word without naming the most paid ("maximum excess"). */
+  readonly notLimits: readonly string[];
+  readonly bases: readonly BasisWord[];
+  readonly approximate: { readonly before: readonly string[]; readonly after: readonly string[] };
+  readonly rangeMarks: readonly string[];
+  /** Words of magnitude and what they multiply by (万 is 10000, million). */
+  readonly multipliers: readonly { readonly word: string; readonly value: number }[];
+  readonly amounts: AmountWords;
+  /** Which currency each mark names ($ and US$ are both USD; 円 and ¥ are both JPY). */
+  readonly currencies: readonly { readonly pattern: string; readonly currency: string }[];
+};
+
+export type Basis = { readonly basis: string; readonly rank?: number | undefined };
+
+/** An amount as stated: its value in the currency's own unit, the currency (with the magnitude word taken out), the basis. */
+export type StatedAmount = { readonly value: number; readonly currency: string; readonly basis?: Basis | undefined };
+
+export type DeductibleIssue = { readonly offset: number; readonly values: Readonly<Record<string, string>> };
+
+/**
+ * Whether a deductible on one basis can be held against a limit on another. A limit with no basis is the most ever paid, so
+ * every deductible is held against it. The same basis is. A deductible on a basis that holds the limit's (an excess per
+ * claim, a limit per item) is: a claim for one item meets the whole excess and at most one item's limit. A deductible with no
+ * basis is charged on one claim, so it is held against a limit on any basis that nests. Bases that do not nest (a day, a
+ * year) are compared only with themselves.
+ */
+export const basesComparable = (deductible: Basis | undefined, limit: Basis | undefined): boolean => {
+  if (limit === undefined) return true;
+  if (deductible === undefined) return limit.rank !== undefined;
+  if (deductible.basis === limit.basis) return true;
+  return deductible.rank !== undefined && limit.rank !== undefined && deductible.rank > limit.rank;
+};
+
+/** A deductible larger than the limit, in the same currency, on comparable bases. An equal one is not reported. */
+export const deductibleExceeds = (deductible: StatedAmount, limit: StatedAmount): boolean =>
+  deductible.currency === limit.currency && basesComparable(deductible.basis, limit.basis) && deductible.value > limit.value;
+
+/** How far after its word an amount may start (「免責金額は1回」, "the most we pay for a single item is"). */
+const MAX_GAP = 24;
+/** How far around a word and its amount the basis is looked for, in characters. */
+const BASIS_REACH = 16;
+/** Marks that end a clause: a basis is not read across them. */
+const CLAUSE_BREAK = /[、,;；，。.]/u;
+const LATIN = /^[A-Za-z]/u;
+const DIGIT_START = /^\d/u;
+const DIGIT_BEFORE = /[\d.,]$/u;
+const CJK_LETTER = /[\p{sc=Han}\p{sc=Katakana}ー]/u;
+const LETTER = /\p{L}/u;
+
+type Hit = { readonly start: number; readonly end: number; readonly kind: "deductible" | "limit"; readonly word: string };
+type Spot = { readonly start: number; readonly end: number };
+
+/** Where a word stands: a Latin word as a whole word in any case, any other word not inside a longer kanji or katakana word. */
+const spansOf = (text: string, word: string, cjkBounded: boolean): Spot[] => {
+  if (word === "") return [];
+  const latin = LATIN.test(word);
+  const pattern = new RegExp(latin ? `(?<![\\p{L}\\p{N}])${escapeRegExp(word)}(?![\\p{L}\\p{N}])` : escapeRegExp(word), latin ? "giu" : "gu");
+  return [...text.matchAll(pattern)]
+    .filter((match) => {
+      const [before, after] = [text.charAt(match.index - 1), text.charAt(match.index + match[0].length)];
+      if (DIGIT_START.test(word) && DIGIT_BEFORE.test(text.slice(0, match.index))) return false;
+      return latin || !cjkBounded || !(CJK_LETTER.test(before) || CJK_LETTER.test(after));
+    })
+    .map((match) => ({ start: match.index, end: match.index + match[0].length }));
+};
+
+const within = (outer: Spot) => (inner: Spot) => outer.start <= inner.start && inner.end <= outer.end;
+
+/** The deductible and limit words of a sentence, without those inside a not-phrase or inside a longer word found. */
+const hitsIn = (text: string, words: DeductibleWords): Hit[] => {
+  const nots = {
+    deductible: words.notDeductibles.flatMap((word) => spansOf(text, word, false)),
+    limit: words.notLimits.flatMap((word) => spansOf(text, word, false)),
+  };
+  const all = [
+    ...words.deductibles.flatMap((word) => spansOf(text, word, true).map((at): Hit => ({ ...at, kind: "deductible", word: text.slice(at.start, at.end) }))),
+    ...words.limits.flatMap((word) => spansOf(text, word, true).map((at): Hit => ({ ...at, kind: "limit", word: text.slice(at.start, at.end) }))),
+  ];
+  return all.filter(
+    (hit) =>
+      !nots[hit.kind].some((not) => within(not)(hit)) &&
+      !all.some((other) => other !== hit && within(other)(hit) && other.end - other.start > hit.end - hit.start),
+  );
+};
+
+/** The written text of an amount: its currency mark before, its number, its unit after (as long as the unit read). */
+type Written = Spot & { readonly figure: ProseFigure };
+
+const writtenOf = (figure: ProseFigure): Written => ({ start: figure.writtenStart, end: figure.writtenEnd, figure });
+
+const lower = (text: string): string => text.toLowerCase();
+
+/** A mark at the end of before (or the start of after) standing as a word of its own when it is Latin. */
+const endsWithMark = (before: string, mark: string): boolean => {
+  const at = lower(before).lastIndexOf(lower(mark));
+  return at >= 0 && at + mark.length === before.length && !(LATIN.test(mark) && LETTER.test(before.charAt(at - 1)));
+};
+const startsWithMark = (after: string, mark: string): boolean =>
+  lower(after).startsWith(lower(mark)) && !(LATIN.test(mark) && LETTER.test(after.charAt(mark.length)));
+
+/** A rough amount (約5,000円, about $80, 5,000円程度) or one end of a range (1,000〜5,000円, $50 - $80). A limit word is not rough. */
+const isRoughOrRange = (text: string, written: Written, words: DeductibleWords): boolean => {
+  const before = text.slice(0, written.start).trimEnd();
+  const after = text.slice(written.end).trimStart();
+  const limitWords = new Set(words.limits.map(lower));
+  const rough = [
+    ...words.approximate.before.filter((mark) => !limitWords.has(lower(mark)) && endsWithMark(before, mark)),
+    ...words.approximate.after.filter((mark) => startsWithMark(after, mark)),
+  ];
+  return rough.length > 0 || words.rangeMarks.some((mark) => before.endsWith(mark) || after.startsWith(mark));
+};
+
+/** The currency a mark names, or the mark itself when no lexicon entry names one. */
+const currencyOf = (mark: string, words: DeductibleWords): string => words.currencies.find((entry) => keyOf(entry.pattern) === mark)?.currency ?? mark;
+
+/** The value with its word of magnitude multiplied in, and the currency its marks name ("|万円" 30 is 300000 JPY, "us$|" is USD). */
+const scaled = (figure: ProseFigure, words: DeductibleWords): { value: number; currency: string } => {
+  const multiplier = words.multipliers.find((entry) => figure.suffix.startsWith(keyOf(entry.word)));
+  const bare = multiplier === undefined ? figure.suffix : figure.suffix.slice(keyOf(multiplier.word).length).trimStart();
+  const marks = [figure.mark, bare].filter((mark) => mark !== "").map((mark) => currencyOf(mark, words));
+  return { value: figure.value * (multiplier?.value ?? 1), currency: [...new Set(marks)].join("|") };
+};
+
+/** The only amount of money between a word and the next word (or the end), close to it. */
+const amountAfter = (hit: Hit, hits: readonly Hit[], figures: readonly ProseFigure[], text: string): Written | undefined => {
+  const until = Math.min(text.length, ...hits.filter((other) => other.start >= hit.end).map((other) => other.start));
+  const between = figures.filter((figure) => figure.start >= hit.end && figure.start < until);
+  const only = between.length === 1 ? between[0] : undefined;
+  if (only === undefined || only.start - hit.end > MAX_GAP) return undefined;
+  return writtenOf(only);
+};
+
+const lastBreakBefore = (text: string, at: number): number => {
+  const before = text.slice(0, at);
+  const breaks = [...before.matchAll(new RegExp(CLAUSE_BREAK.source, "gu"))].map((match) => match.index + 1);
+  return Math.max(0, ...breaks);
+};
+
+const firstBreakAfter = (text: string, at: number): number => {
+  const found = CLAUSE_BREAK.exec(text.slice(at));
+  return found === null ? text.length : at + found.index;
+};
+
+/** The bases written in the clause around a word and its amount, outside the amount itself. */
+const basesIn = (text: string, region: Spot, words: DeductibleWords, taken: Spot): BasisWord[] => {
+  const slice = text.slice(region.start, region.end);
+  return words.bases.flatMap((entry) =>
+    spansOf(slice, entry.pattern, false)
+      .map((at) => ({ start: region.start + at.start, end: region.start + at.end }))
+      .filter((at) => !(at.start < taken.end && taken.start < at.end))
+      .map(() => entry),
+  );
+};
+
+type Read = { readonly hit: Hit; readonly written: Written; readonly stated: StatedAmount };
+
+const SPACES = /^\s*/u;
+
+/** Where the bases written right after an amount end ("$80 a visit", "$80 a visit a day"), or the amount's end when none is. */
+const adjacentEnd = (text: string, end: number, words: DeductibleWords): number => {
+  const from = end + (SPACES.exec(text.slice(end))?.[0].length ?? 0);
+  const rest = text.slice(from);
+  const lengths = words.bases.flatMap((entry) =>
+    spansOf(rest, entry.pattern, false)
+      .filter((at) => at.start === 0)
+      .map((at) => at.end),
+  );
+  return lengths.length === 0 ? end : adjacentEnd(text, from + Math.max(...lengths), words);
+};
+
+/**
+ * The clause around a word and its amount where its basis is read. Between the first amount and the second word, only a basis
+ * right after the amount is the first's ("$80 a visit and the most we pay"); any other belongs to the second word
+ * (「300,000円で1品あたりの支払限度額」).
+ */
+const regionsOf = (text: string, first: Written, second: { hit: Hit; written: Written }, firstHit: Hit, words: DeductibleWords): [Spot, Spot] => {
+  const split = adjacentEnd(text, first.end, words);
+  const opening = { start: Math.max(firstHit.start - BASIS_REACH, lastBreakBefore(text, firstHit.start)), end: split };
+  const closing = {
+    start: Math.max(split, second.hit.start - BASIS_REACH, lastBreakBefore(text, second.hit.start)),
+    end: Math.min(second.written.end + BASIS_REACH, firstBreakAfter(text, second.written.end)),
+  };
+  return [opening, closing];
+};
+
+/** The amount as stated, with the one basis written around it; two different bases leave it unread. */
+const statedOf = (text: string, written: Written, region: Spot, words: DeductibleWords): StatedAmount | undefined => {
+  const found = basesIn(text, region, words, written);
+  if (new Set(found.map((entry) => entry.basis)).size > 1) return undefined;
+  const first = found[0];
+  return { ...scaled(written.figure, words), basis: first === undefined ? undefined : { basis: first.basis, rank: first.rank } };
+};
+
+/** Both words with their amounts and bases, in the order written; undefined when either amount is not read. */
+const readPair = (text: string, hits: readonly [Hit, Hit], figures: readonly ProseFigure[], words: DeductibleWords): Read[] | undefined => {
+  const [first, second] = hits.toSorted((left, right) => left.start - right.start);
+  if (first === undefined || second === undefined) return undefined;
+  const [firstWritten, secondWritten] = [amountAfter(first, hits, figures, text), amountAfter(second, hits, figures, text)];
+  if (firstWritten === undefined || secondWritten === undefined) return undefined;
+  if ([firstWritten, secondWritten].some((written) => isRoughOrRange(text, written, words))) return undefined;
+  const [opening, closing] = regionsOf(text, firstWritten, { hit: second, written: secondWritten }, first, words);
+  const [firstStated, secondStated] = [statedOf(text, firstWritten, opening, words), statedOf(text, secondWritten, closing, words)];
+  if (firstStated === undefined || secondStated === undefined) return undefined;
+  return [
+    { hit: first, written: firstWritten, stated: firstStated },
+    { hit: second, written: secondWritten, stated: secondStated },
+  ];
+};
+
+/**
+ * One sentence (text, starting at offset in the document; quantities are the tree's, in document offsets) with exactly one
+ * deductible word and one limit word, each with one amount of money right after it, read as stated and compared. Any other
+ * shape is not read.
+ */
+export const sentenceDeductibleOverLimit = (
+  text: string,
+  offset: number,
+  quantities: readonly ProseQuantity[],
+  words: DeductibleWords,
+): DeductibleIssue | undefined => {
+  const hits = hitsIn(text, words);
+  const deductibleHits = hits.filter((hit) => hit.kind === "deductible");
+  const limitHits = hits.filter((hit) => hit.kind === "limit");
+  const [deductibleHit, limitHit] = [deductibleHits[0], limitHits[0]];
+  if (deductibleHits.length !== 1 || limitHits.length !== 1 || deductibleHit === undefined || limitHit === undefined) return undefined;
+  const local = quantities.map((quantity) => ({ ...quantity, start: quantity.start - offset, end: quantity.end - offset }));
+  const { figures } = proseValues(text, 0, local, words.amounts);
+  const pair = readPair(text, [deductibleHit, limitHit], figures, words);
+  const deductible = pair?.find((read) => read.hit === deductibleHit);
+  const limit = pair?.find((read) => read.hit === limitHit);
+  if (deductible === undefined || limit === undefined || !deductibleExceeds(deductible.stated, limit.stated)) return undefined;
+  const shown = (read: Read): string => text.slice(read.written.start, read.written.end);
+  return {
+    offset: offset + deductible.written.start,
+    values: { deductibleWord: deductible.hit.word, deductible: shown(deductible), limitWord: limit.hit.word, limit: shown(limit) },
+  };
+};

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/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);