chaffjs 0.32.0 → 0.34.0

package/src/structure/fenced-lines.ts

@@ -0,0 +1,28 @@
+import { codeFences } from "../detectors/code-fences.ts";
+
+const FENCE_MARK = /`{3}|~{3}/u;
+
+const NONE: ReadonlySet<number> = new Set();
+
+/** The index of the line holding an offset of the joined lines. */
+const lineIndexAt = (starts: readonly number[], offset: number): number => starts.findLastIndex((start) => start <= offset);
+
+/**
+ * The indexes of the lines of fenced code blocks (``` or ~~~), the fences included. A table or a list written in one is an
+ * example, not the document's own values. The blocks are the ones the Markdown parser reads (code-fences.ts): a fence in
+ * a list item is one, a line indented as code or a fence in a quotation is not, and an unclosed fence runs to the end.
+ */
+export const fencedLineIndexes = (texts: readonly string[]): ReadonlySet<number> => {
+  if (!texts.some((text) => FENCE_MARK.test(text))) return NONE;
+  const starts: number[] = [];
+  texts.reduce((start, text) => {
+    starts.push(start);
+    return start + text.length + 1;
+  }, 0);
+  const fenced = new Set<number>();
+  codeFences(texts.join("\n")).forEach((fence) => {
+    const last = lineIndexAt(starts, Math.max(fence.start, fence.end - 1));
+    for (let index = lineIndexAt(starts, fence.start); index <= last; index += 1) fenced.add(index);
+  });
+  return fenced;
+};

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/installment-fee.ts

@@ -0,0 +1,201 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+import {
+  alternation,
+  describe,
+  hasWord,
+  intervalOf,
+  isPlainGap,
+  isRough,
+  isTotalOf,
+  lineBounds,
+  occurrences,
+  sentenceAround,
+  sumOf,
+  writtenLike,
+  type InstallmentAmount,
+  type InstallmentWords,
+  type Part,
+} from "./installment-total.ts";
+
+/**
+ * installment-total-mismatch, the fee form: numbered instalments listed one per row or item (第1回：32,000円, | 1st
+ * payment | £150 |, Final payment: $60) that do not add up to the fee stated in the same section (旅行代金は、1人あたり
+ * 62,000円; "The trip costs £300 per student"). Compared only when the section states one fee, every instalment of the
+ * series is read (numbered 1, 2, … with no gap or repeat, each with one plain amount), the section names a payment
+ * (積立金, instalments), and every amount is in the fee's currency. A deposit counts only as an item of the series; one
+ * named anywhere else stops the comparison. An instalment as large as the fee says the fee is per payment (a monthly
+ * fee), not split, and is not compared. Words come from the lexicons. Pure.
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+export type InstallmentSeriesWords = {
+  /** Item labels with {n} for the instalment's number (第{n}回, {n} payment, Instalment {n}). */
+  readonly numbered: readonly string[];
+  /** Item labels of the last instalment, numbered after the others (最終回, Final payment). */
+  readonly finals: readonly string[];
+  /** Numbers written as words that {n} may be (first, 一) and their values. */
+  readonly ordinals: readonly { readonly word: string; readonly value: number }[];
+  /** Letters after a number that make it an ordinal (1st). */
+  readonly ordinalSuffixes: readonly string[];
+  /** Words that say the section is about paying (積立金, instalment); one must stand in the section. */
+  readonly payments: readonly string[];
+  /** A deposit (申込金, deposit): an item of the series, or a reason not to compare. */
+  readonly deposits: readonly string[];
+  /** Words that state the fee (旅行代金, costs). */
+  readonly fees: readonly string[];
+  /** Words that may stand between a fee word and its amount (1人あたり, per student). */
+  readonly feeLinks: readonly string[];
+};
+
+/** One read item of a series: its number (undefined for a deposit, Infinity for a final one) and its amount. */
+type Item = { readonly line: Span; readonly number: number | undefined; readonly amount: InstallmentAmount | undefined };
+
+/** What may stand before an item label on its line: a table bar, a list mark, spaces. */
+const ITEM_LEAD = /^[\s|｜\-*+・•]*$/u;
+const DIGITS = "[0-9０-９]+";
+const FINAL = Number.POSITIVE_INFINITY;
+
+const numberPattern = (series: InstallmentSeriesWords): string => {
+  const suffix = alternation(series.ordinalSuffixes);
+  const words = alternation(series.ordinals.map((entry) => entry.word));
+  const digits = suffix === undefined ? DIGITS : `${DIGITS}(?:${suffix})?`;
+  return words === undefined ? digits : `${digits}|${words}`;
+};
+
+const numberOf = (written: string, series: InstallmentSeriesWords): number | undefined => {
+  const digits = /^[0-9０-９]+/u.exec(written)?.[0];
+  if (digits !== undefined) return Number(digits.normalize("NFKC"));
+  return series.ordinals.find((entry) => entry.word.toLowerCase() === written.toLowerCase())?.value;
+};
+
+const labelRegExp = (label: string, number: string): RegExp => {
+  const [before = "", after = ""] = label.split("{n}").map(escapeRegExp);
+  const edgeStart = /^[A-Za-z]/u.test(label) ? "(?<![A-Za-z])" : "";
+  const edgeEnd = /[A-Za-z]$/u.test(label) ? "(?![A-Za-z])" : "";
+  return new RegExp(`${edgeStart}${before}(${number})${after}${edgeEnd}`, "giu");
+};
+
+type Label = Span & { readonly number: number | undefined };
+
+const numberedLabels = (text: string, series: InstallmentSeriesWords): Label[] =>
+  series.numbered.flatMap((label) =>
+    [...text.matchAll(labelRegExp(label, numberPattern(series)))].map((match) => ({
+      start: match.index,
+      end: match.index + match[0].length,
+      number: numberOf(match[1] ?? "", series),
+    })),
+  );
+
+const wordLabels = (text: string, words: readonly string[], number: number | undefined): Label[] =>
+  occurrences(text, words).map((span) => ({ ...span, number }));
+
+const startsItem = (text: string, label: Span): boolean => ITEM_LEAD.test(text.slice(lineBounds(text, label.start).start, label.start));
+
+/** The longest label at each place wins (Final payment over a bare payment), and only labels that open a row or an item. */
+const itemLabels = (text: string, series: InstallmentSeriesWords): Label[] => {
+  const all = [...numberedLabels(text, series), ...wordLabels(text, series.finals, FINAL), ...wordLabels(text, series.deposits, undefined)];
+  const longest = all.filter(
+    (label) =>
+      !all.some((other) => other !== label && other.start <= label.start && other.end >= label.end && other.end - other.start > label.end - label.start),
+  );
+  return longest.filter((label) => startsItem(text, label)).toSorted((left, right) => left.start - right.start);
+};
+
+/** A label's amount: the one amount of its line, after a gap of separators, links and payment words; else unread. */
+const itemOf = (text: string, label: Label, amounts: readonly InstallmentAmount[], words: InstallmentWords, series: InstallmentSeriesWords): Item => {
+  const line = lineBounds(text, label.start);
+  const onLine = amounts.filter((amount) => amount.offset >= label.end && amount.end <= line.end);
+  const [amount] = onLine;
+  const read =
+    onLine.length === 1 &&
+    amount !== undefined &&
+    isPlainGap(text.slice(label.end, amount.offset), [...words.links, ...series.payments]) &&
+    !isRough(text, { start: amount.offset, end: amount.end }, words);
+  return { line, number: label.number, amount: read ? amount : undefined };
+};
+
+/** Whether the numbered items run 1, 2, …, k (a final one only last), each read; deposits may stand anywhere. */
+export const isWholeSeries = (items: readonly Item[]): boolean => {
+  const numbers = items.flatMap((item) => (item.number === undefined ? [] : [item.number]));
+  const finalAt = numbers.indexOf(FINAL);
+  const counted = numbers.filter((number) => number !== FINAL);
+  const inOrder = counted.every((number, index) => number === index + 1);
+  const finalLast = finalAt === -1 || finalAt === numbers.length - 1;
+  return items.length >= 2 && counted.length >= 1 && inOrder && finalLast && items.every((item) => item.amount !== undefined);
+};
+
+/** The sections of the text: from one heading to the next; the whole text when there are none. */
+export const sectionsOf = (text: string, headingStarts: readonly number[]): Span[] => {
+  const starts = [0, ...headingStarts.filter((start) => start > 0 && start < text.length).toSorted((left, right) => left - right)];
+  return starts.map((start, index) => ({ start, end: starts[index + 1] ?? text.length }));
+};
+
+/** Every fee the section states: a fee word, then only separators, links and per-person words before an amount. */
+export const feesIn = (
+  text: string,
+  section: Span,
+  amounts: readonly InstallmentAmount[],
+  words: InstallmentWords,
+  series: InstallmentSeriesWords,
+): InstallmentAmount[] => {
+  const body = text.slice(section.start, section.end);
+  return occurrences(body, series.fees).flatMap((span) => {
+    const at = { start: section.start + span.start, end: section.start + span.end };
+    const sentence = sentenceAround(text, at);
+    const amount = amounts.find((candidate) => candidate.offset >= at.end && candidate.end <= sentence.end);
+    if (amount === undefined || !isPlainGap(text.slice(at.end, amount.offset), [...words.links, ...series.feeLinks])) return [];
+    return [amount];
+  });
+};
+
+const within = (span: Span, section: Span): boolean => span.start >= section.start && span.end <= section.end;
+
+const sameAmount = (left: InstallmentAmount, right: InstallmentAmount): boolean => left.value === right.value && left.currency === right.currency;
+
+const partOf = (text: string, amount: InstallmentAmount): Part => ({ count: 1, amount, written: text.slice(amount.offset, amount.end) });
+
+/** The comparison of one section: its series of instalments against its one fee; undefined when anything is not read. */
+const sectionIssue = (
+  text: string,
+  section: Span,
+  items: readonly Item[],
+  amounts: readonly InstallmentAmount[],
+  words: InstallmentWords,
+  series: InstallmentSeriesWords,
+): StructureIssue | undefined => {
+  const own = items.filter((item) => within(item.line, section));
+  if (!isWholeSeries(own) || !hasWord(text.slice(section.start, section.end), series.payments)) return undefined;
+  const fees = feesIn(text, section, amounts, words, series).filter((fee) => !own.some((item) => within({ start: fee.offset, end: fee.end }, item.line)));
+  const [fee] = fees;
+  if (fee === undefined || !fees.every((other) => sameAmount(other, fee)) || isRough(text, { start: fee.offset, end: fee.end }, words)) return undefined;
+  const parts = own.flatMap((item) => (item.amount === undefined ? [] : [partOf(text, item.amount)]));
+  const [first] = parts;
+  if (first === undefined || parts.some((part) => part.amount.currency !== fee.currency || part.amount.value >= fee.value)) return undefined;
+  const written = text.slice(fee.offset, fee.end);
+  const sum = sumOf(parts);
+  const stated = fee.scale === undefined ? { low: fee.value, high: fee.value } : intervalOf(fee, written);
+  if (isTotalOf(stated, sum)) return undefined;
+  return { offset: first.amount.offset, values: { payments: describe(parts), sum: writtenLike((sum.low + sum.high) / 2, first), total: written } };
+};
+
+/** Whether a deposit is named outside the items of a series: then whether it is part of the fee cannot be read. */
+const depositOutside = (text: string, items: readonly Item[], series: InstallmentSeriesWords): boolean =>
+  occurrences(text, series.deposits).some((span) => !items.some((item) => item.number === undefined && within(span, item.line)));
+
+/** Every section whose numbered instalments do not add up to its stated fee; reported at the first instalment. */
+export const installmentFeeMismatches = (
+  text: string,
+  amounts: readonly InstallmentAmount[],
+  headingStarts: readonly number[],
+  words: InstallmentWords,
+  series: InstallmentSeriesWords,
+): StructureIssue[] => {
+  const items = itemLabels(text, series).map((label) => itemOf(text, label, amounts, words, series));
+  if (items.length < 2 || depositOutside(text, items, series)) return [];
+  return sectionsOf(text, headingStarts).flatMap((section) => {
+    const issue = sectionIssue(text, section, items, amounts, words, series);
+    return issue === undefined ? [] : [issue];
+  });
+};

package/src/structure/installment-total.ts

@@ -87,7 +87,7 @@ const wordPattern = (word: string): string => {
 };
 
 /** One alternation of the words, longest first so 初回お支払額 wins over 初回. Undefined when there are none. */
-const alternation = (words: readonly string[]): string | undefined =>
+export const alternation = (words: readonly string[]): string | undefined =>
   words.length === 0
     ? undefined
     : words
@@ -95,7 +95,7 @@ const alternation = (words: readonly string[]): string | undefined =>
         .map(wordPattern)
         .join("|");
 
-const occurrences = (text: string, words: readonly string[]): Span[] => {
+export const occurrences = (text: string, words: readonly string[]): Span[] => {
   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 }));
@@ -109,7 +109,7 @@ const withoutWords = (text: string, words: readonly string[]): string => {
 /** Whether only separators and these words stand in a gap on one line (「：」, "の", " of "). */
 export const isPlainGap = (gap: string, words: readonly string[]): boolean => !gap.includes("\n") && withoutWords(gap, words).replace(SEPARATORS, "") === "";
 
-const lineBounds = (text: string, offset: number): Span => {
+export const lineBounds = (text: string, offset: number): Span => {
   const end = text.indexOf("\n", offset);
   return { start: text.lastIndexOf("\n", offset - 1) + 1, end: end === -1 ? text.length : end };
 };
@@ -142,7 +142,7 @@ const countPattern = (words: InstallmentWords): string => {
   return numberWords === undefined ? DIGITS : `${DIGITS}|${numberWords}`;
 };
 
-const hasWord = (text: string, words: readonly string[]): boolean => occurrences(text, words).length > 0;
+export const hasWord = (text: string, words: readonly string[]): boolean => occurrences(text, words).length > 0;
 
 /** How far around a value its marks are looked for. */
 const MARK_REACH = 16;
@@ -166,7 +166,7 @@ const opensRange = (text: string, value: Span, connectors: readonly string[]): b
   return connectors.some((connector) => after.startsWith(connector.toLowerCase()) && /^\s*[$€£¥￥0-9０-９]/u.test(after.slice(connector.length)));
 };
 
-const isRough = (text: string, value: Span, words: InstallmentWords): boolean =>
+export const isRough = (text: string, value: Span, words: InstallmentWords): boolean =>
   isMarked(text, value, words.markers) || opensRange(text, value, words.connectors);
 
 type Label = Span & { readonly kind: LabelKind };
@@ -315,7 +315,7 @@ export const writtenLike = (value: number, part: Part): string => {
   return part.amount.scale === undefined ? part.written.replace(/[0-9０-９][0-9０-９,，.．]*/u, digits) : digits;
 };
 
-const describe = (parts: readonly Part[]): string =>
+export const describe = (parts: readonly Part[]): string =>
   parts.map((part) => (part.count === 1 ? part.written : `${part.written} × ${String(part.count)}`)).join(" + ");
 
 const regularOf = (parts: readonly Part[]): Part | undefined => parts.toSorted((left, right) => right.count - left.count)[0];