chaffjs 0.31.0 → 0.33.0

package/src/structure/table-scale.ts

@@ -0,0 +1,239 @@
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf, type Line } from "./lines.ts";
+
+/**
+ * A results table that mixes scales without saying so: a cell written in another scale unit than the table's (110,000千円 among
+ * 百万円), or, under a stated unit, one row entered a thousand times too large (52,000 among 1,200 and 84 under 単位：百万円).
+ * The scale units, the caption marks and the total labels come from the language packages. Pure.
+ */
+export type ScaleUnit = { readonly word: string; readonly value: number };
+
+export type TableScaleWords = {
+  /** Words of scale written in a cell or a caption (百万円, million, millions), with the number they multiply by. */
+  readonly units: readonly ScaleUnit[];
+  /** What marks a line as a table's caption of unit (単位, in, of). */
+  readonly captionMarks: readonly string[];
+  /** Row labels of a total (合計, Total): a total row is large by nature. */
+  readonly totalLabels: readonly string[];
+};
+
+export type TableScaleSlip = {
+  /** "unit": the cell is written in another scale unit; "row": the row is a thousand times its neighbours. */
+  readonly kind: "unit" | "row";
+  readonly item: string;
+  readonly cell: Cell;
+  /** The table's scale as written: the caption's word, or the word most cells carry. */
+  readonly tableUnit: string;
+  /** For "row": the row's first figure divided by the factor, as it would read in the table's unit. */
+  readonly reading?: number | undefined;
+};
+
+/** A cell read as one number with, at most, a scale unit after it. */
+export type ScaleCell = { readonly number: number; readonly digits: string; readonly unit: ScaleUnit | undefined };
+
+/** A row a thousand times its neighbours: the factor between thousands and millions, or millions and billions. */
+export const ROW_FACTOR = 1000;
+/** The row's figure must be at least this many times the largest of the other rows in its column. */
+const LARGER_THAN_OTHERS = 10;
+/** A row is compared on at least this many columns, and with at least this many other rows. */
+const MIN_COLUMNS = 2;
+const MIN_OTHER_ROWS = 2;
+/** A caption of unit is a short line; a longer one is a sentence about the figures. */
+const MAX_CAPTION_LENGTH = 40;
+/** How many blank lines may stand between the caption and the table. */
+const CAPTION_REACH = 2;
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+const DIGIT = /\p{Nd}/u;
+/** Currency marks and minus signs written before the figure ($, ¥, △52, -$52). */
+const LEAD = /^(?:US\$|[$¥€£\-−△▲\s])+/u;
+const NEGATIVE = /[-−△▲]/u;
+const DIGITS = /^(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?/u;
+/** An accounting negative: the figure in brackets, (52,000). */
+const BRACKETED = /^[(（]([^()（）]+)[)）]$/u;
+const CURRENCY_TAIL = /^[\p{L} ]*$/u;
+
+const boundaryAt = (text: string, index: number): boolean => {
+  const char = text[index];
+  return char === undefined || !LETTER.test(char);
+};
+
+/** The longest unit written at index, when it is a whole word (a Latin word must not run on: million in millions is not). */
+const unitAt = (text: string, index: number, units: readonly ScaleUnit[]): ScaleUnit | undefined => {
+  const lower = text.toLowerCase();
+  return units
+    .filter((unit) => lower.startsWith(unit.word.toLowerCase(), index))
+    .filter((unit) => !LATIN.test(unit.word) || (boundaryAt(text, index - 1) && boundaryAt(text, index + unit.word.length)))
+    .toSorted((left, right) => right.word.length - left.word.length)[0];
+};
+
+/** Every unit written in the text, longest first at each place, without overlaps (百万円 is not also 万円). */
+export const unitsIn = (text: string, units: readonly ScaleUnit[]): ScaleUnit[] => {
+  const found: ScaleUnit[] = [];
+  const step = (index: number): void => {
+    if (index >= text.length) return;
+    const unit = unitAt(text, index, units);
+    if (unit !== undefined) found.push(unit);
+    step(index + (unit?.word.length ?? 1));
+  };
+  step(0);
+  return found;
+};
+
+/** The unit after a figure, with nothing after it but a currency word (円, US dollars); null when there is no unit. */
+const unitAfter = (rest: string, units: readonly ScaleUnit[]): ScaleUnit | null | undefined => {
+  if (rest === "") return null;
+  const unit = unitAt(rest, 0, units);
+  return unit !== undefined && CURRENCY_TAIL.test(rest.slice(unit.word.length)) ? unit : undefined;
+};
+
+const negated = (cell: ScaleCell | undefined): ScaleCell | undefined => (cell === undefined || cell.number < 0 ? undefined : { ...cell, number: -cell.number });
+
+/** A cell's number and its scale unit; undefined when the cell is not one figure (7.0%, 1,200人, —). */
+export const scaleCellOf = (text: string, units: readonly ScaleUnit[]): ScaleCell | undefined => {
+  const plain = withoutEdgeMarks(text.trim());
+  const bracketed = BRACKETED.exec(plain)?.[1];
+  if (bracketed !== undefined) return negated(scaleCellOf(bracketed, units));
+  const lead = LEAD.exec(plain)?.[0] ?? "";
+  const digits = DIGITS.exec(plain.slice(lead.length))?.[0];
+  if (digits === undefined) return undefined;
+  const unit = unitAfter(plain.slice(lead.length + digits.length).trim(), units);
+  if (unit === undefined) return undefined;
+  const number = Number(digits.replaceAll(",", "")) * (NEGATIVE.test(lead) ? -1 : 1);
+  return { number, digits, unit: unit ?? undefined };
+};
+
+const hasMark = (text: string, mark: string): boolean => {
+  const lower = text.toLowerCase();
+  const word = mark.toLowerCase();
+  const at = lower.indexOf(word);
+  if (at === -1) return false;
+  return !LATIN.test(mark) || (boundaryAt(text, at - 1) && boundaryAt(text, at + word.length)) || hasMark(text.slice(at + word.length), mark);
+};
+
+/** The unit a line states for the table under it: a short line with no figure, a caption mark and one scale unit. */
+export const captionUnitOf = (text: string, words: TableScaleWords): ScaleUnit | undefined => {
+  const line = text.trim();
+  if (line.length === 0 || line.length > MAX_CAPTION_LENGTH || DIGIT.test(line) || line.startsWith("|")) return undefined;
+  if (!words.captionMarks.some((mark) => hasMark(line, mark))) return undefined;
+  const found = unitsIn(line, words.units);
+  const values = new Set(found.map((unit) => unit.value));
+  return values.size === 1 ? found[0] : undefined;
+};
+
+const captionOf = (lines: readonly Line[], header: Line, words: TableScaleWords): ScaleUnit | undefined => {
+  const index = lines.indexOf(header);
+  const before = lines.slice(Math.max(0, index - CAPTION_REACH - 1), index).toReversed();
+  const caption = before.find((line) => line.text.trim() !== "");
+  return caption === undefined ? undefined : captionUnitOf(caption.text, words);
+};
+
+type ReadCell = { readonly cell: Cell; readonly read: ScaleCell; readonly column: number };
+type ReadRow = { readonly item: string; readonly cells: readonly ReadCell[] };
+
+const rowsOf = (rows: readonly Line[], units: readonly ScaleUnit[]): ReadRow[] =>
+  rows.map((row) => {
+    const [first, ...rest] = cellsOf(row);
+    const cells = rest.flatMap((cell, column): ReadCell[] => {
+      const read = scaleCellOf(cell.text, units);
+      return read === undefined ? [] : [{ cell, read, column }];
+    });
+    return { item: withoutEdgeMarks((first?.text ?? "").trim()), cells };
+  });
+
+/** The unit most cells carry, when at least two do and no other unit is as common. */
+const usualUnitOf = (rows: readonly ReadRow[]): ScaleUnit | undefined => {
+  const counts = new Map<number, { unit: ScaleUnit; count: number }>();
+  rows.forEach((row) =>
+    row.cells.forEach(({ read }) => {
+      if (read.unit === undefined) return;
+      const seen = counts.get(read.unit.value);
+      counts.set(read.unit.value, { unit: seen?.unit ?? read.unit, count: (seen?.count ?? 0) + 1 });
+    }),
+  );
+  const [top, second] = [...counts.values()].toSorted((left, right) => right.count - left.count);
+  return top !== undefined && top.count >= MIN_OTHER_ROWS && (second === undefined || second.count < top.count) ? top.unit : undefined;
+};
+
+/**
+ * Whether a cell's unit departs from the table's. Under a stated unit, any other unit does. Without one, only a smaller unit
+ * with a figure of one table unit or more (110,000千円 among 百万円): a larger unit for a large figure ($2.4 billion among
+ * $130 million) is a normal way of writing.
+ */
+const departs = (read: ScaleCell, table: ScaleUnit, stated: boolean): boolean => {
+  if (read.unit === undefined || read.unit.value === table.value) return false;
+  if (stated) return true;
+  return read.unit.value < table.value && Math.abs(read.number) * read.unit.value >= table.value;
+};
+
+const unitSlips = (rows: readonly ReadRow[], table: ScaleUnit, stated: boolean): TableScaleSlip[] =>
+  rows.flatMap((row) => {
+    const odd = row.cells.find(({ read }) => departs(read, table, stated));
+    return odd === undefined ? [] : [{ kind: "unit" as const, item: row.item, cell: odd.cell, tableUnit: table.word }];
+  });
+
+const isTotal = (item: string, labels: readonly string[]): boolean => labels.some((label) => item.toLowerCase().startsWith(label.toLowerCase()));
+
+/** A row's figure that reads as entered in a unit a thousand times smaller: whole thousands, at least one thousand. */
+const wholeThousands = (read: ScaleCell): boolean =>
+  read.unit === undefined && !read.digits.includes(".") && Math.abs(read.number) >= ROW_FACTOR && read.number % ROW_FACTOR === 0;
+
+type BareRow = { readonly row: ReadRow; readonly figures: ReadonlyMap<number, ReadCell> };
+
+const bareRowsOf = (rows: readonly ReadRow[]): BareRow[] =>
+  rows.map((row) => ({ row, figures: new Map(row.cells.filter((entry) => entry.read.unit === undefined).map((entry) => [entry.column, entry])) }));
+
+/**
+ * Whether one figure stands a thousand times above its column: at least ten times the largest other figure, and a thousandth
+ * of it no larger than that figure, so it reads as one of them once divided.
+ */
+const standsAbove = (figure: ScaleCell, others: readonly number[]): boolean => {
+  const largest = Math.max(...others.map((value) => Math.abs(value)));
+  return others.length >= MIN_OTHER_ROWS && Math.abs(figure.number) >= LARGER_THAN_OTHERS * largest && Math.abs(figure.number) / ROW_FACTOR <= largest;
+};
+
+const rowStandsAbove = (candidate: BareRow, rows: readonly BareRow[]): boolean => {
+  const figures = [...candidate.figures.entries()];
+  return (
+    figures.length >= MIN_COLUMNS &&
+    figures.every(([column, figure]) => {
+      const others = rows.flatMap((row) => {
+        const other = row === candidate ? undefined : row.figures.get(column);
+        return other === undefined ? [] : [other.read.number];
+      });
+      return wholeThousands(figure.read) && standsAbove(figure.read, others);
+    })
+  );
+};
+
+/**
+ * The one row, under a stated unit, entered a thousand times too large. Every figure of the row must be whole thousands (a row
+ * multiplied by a thousand always is; a genuinely large row, such as total assets, almost never is in every column), stand ten
+ * times above every other row of its column, and fall among them once divided. A total row and a row whose label carries its
+ * own unit in brackets (従業員数（人）) are left alone, and so is a table where more than one row stands out (each in its own columns).
+ */
+const rowSlips = (rows: readonly ReadRow[], table: ScaleUnit, words: TableScaleWords): TableScaleSlip[] => {
+  const bare = bareRowsOf(rows);
+  const standing = bare.filter((row) => !isTotal(row.row.item, words.totalLabels) && !/[(（]/u.test(row.row.item) && rowStandsAbove(row, bare));
+  const [only] = standing;
+  if (only === undefined || standing.length > 1) return [];
+  const first = [...only.figures.values()][0];
+  return first === undefined ? [] : [{ kind: "row", item: only.row.item, cell: first.cell, tableUnit: table.word, reading: first.read.number / ROW_FACTOR }];
+};
+
+const tableSlips = (lines: readonly Line[], table: { header: Line; rows: Line[] }, words: TableScaleWords): TableScaleSlip[] => {
+  const rows = rowsOf(table.rows, words.units);
+  const caption = captionOf(lines, table.header, words);
+  const unit = caption ?? usualUnitOf(rows);
+  if (unit === undefined) return [];
+  const units = unitSlips(rows, unit, caption !== undefined);
+  return caption === undefined ? units : [...units, ...rowSlips(rows, caption, words)];
+};
+
+/** Every table of the text that mixes scales, and the cells or rows that depart. */
+export const tableScaleSlips = (text: string, words: TableScaleWords): TableScaleSlip[] => {
+  const lines = linesOf(text);
+  return tablesOf(lines).flatMap((table) => tableSlips(lines, table, words));
+};

package/src/structure/tax-price.ts

@@ -0,0 +1,136 @@
+// tax-mismatch in a price list: one row's tax-included price that is not its tax-excluded price plus the rate. The two
+// columns are the ones whose headings are the same apart from the excluded / included words and a rate (「1箱の価格（税抜）」,
+// 「1箱の価格（税込・10%）」); the rate is the included heading's, else the one rate the document states beside a tax word. Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { withoutWord } from "./net-gross-weight.ts";
+import { bodyRows, offsetOf } from "./order-quantity.ts";
+import { roundedMatches } from "./tax.ts";
+
+/** excluded: a price before tax. included: a price with tax. rate: a word beside which a rate in a sentence is the tax rate. */
+export type TaxPriceRole = "excluded" | "included" | "rate";
+export type TaxPriceWord = { readonly pattern: string; readonly role: TaxPriceRole };
+/** The document's tables and its lines outside tables. */
+export type TaxPriceText = { readonly tables: readonly ChangeTable[]; readonly lines: readonly string[] };
+export type TaxPricePair = { readonly excluded: number; readonly included: number; readonly rate: number | undefined };
+
+const RATE = /(\d{1,2}(?:\.\d{1,2})?)[ \t]?%/gu;
+const MAX_RATE = 100;
+const CENTS = 100;
+const SPACES = /\s+/gu;
+/** Spaces and punctuation: 「（税込・10%）」 and "(incl. 8% tax)" say nothing besides once the words are out; $ and € still do. */
+const SPACES_AND_MARKS = /[\s\p{P}]+/gu;
+/** What may stand between a tax word and its rate: 「消費税率は10%」, "sales tax of 8%", "VAT: 20%". */
+const FILLER_MARKS: ReadonlySet<string> = new Set([":", "：", "=", "（", "(", "は", "が", "の"]);
+const FILLER_WORDS: readonly string[] = [" of", " at", " is"];
+const AFTER_RATE = /^[\s)）]+/u;
+const NUMBER = /\d[\d,]*(?:\.\d+)?/u;
+const LATIN_LETTER = /[a-z]/u;
+
+const ratesIn = (text: string): number[] =>
+  [...text.matchAll(RATE)].map((match) => Number(match[1])).filter((rate) => Number.isFinite(rate) && rate > 0 && rate < MAX_RATE);
+
+type Heading = { readonly role: "excluded" | "included"; readonly rest: string; readonly rate: number | undefined };
+
+const heldWords = (key: string, words: readonly TaxPriceWord[], role: TaxPriceRole): string[] =>
+  words
+    .filter((word) => word.role === role && holds(key, word.pattern))
+    .map((word) => word.pattern)
+    .toSorted((left, right) => right.length - left.length);
+
+/** The role a heading names, what it says besides, and its one rate. A heading naming both roles is not read. */
+const headingOf = (heading: string, words: readonly TaxPriceWord[]): Heading | undefined => {
+  const key = plain(heading).toLowerCase();
+  const rates = ratesIn(key);
+  const withoutRate = key.replace(RATE, " ").replace(SPACES, " ");
+  const [excluded, included] = [heldWords(withoutRate, words, "excluded"), heldWords(withoutRate, words, "included")];
+  if (excluded.length > 0 === included.length > 0) return undefined;
+  const role = excluded.length > 0 ? "excluded" : "included";
+  const rest = [...excluded, ...included].reduce((left, word) => withoutWord(left, word), withoutRate);
+  return { role, rest: rest.replace(SPACES_AND_MARKS, ""), rate: rates.length === 1 ? rates[0] : undefined };
+};
+
+/** Each included column with the one excluded column whose heading says the same besides, and the included heading's rate. */
+export const taxPricePairsOf = (headings: readonly string[], words: readonly TaxPriceWord[]): TaxPricePair[] => {
+  const read = headings.map((heading) => headingOf(heading, words));
+  const columnsOf = (role: Heading["role"], rest: string): number[] =>
+    read.flatMap((found, index) => (found?.role === role && found.rest === rest ? [index] : []));
+  return read.flatMap((found, included) => {
+    if (found?.role !== "included" || columnsOf("included", found.rest).length !== 1) return [];
+    const [excluded, ...others] = columnsOf("excluded", found.rest);
+    return excluded === undefined || others.length > 0 ? [] : [{ excluded, included, rate: found.rate }];
+  });
+};
+
+const withoutFillers = (text: string): string => {
+  const trimmed = text.trimEnd();
+  const last = trimmed.at(-1);
+  if (last !== undefined && FILLER_MARKS.has(last)) return withoutFillers(trimmed.slice(0, -1));
+  const word = FILLER_WORDS.find((filler) => trimmed.endsWith(filler));
+  return word === undefined ? trimmed : withoutFillers(trimmed.slice(0, -word.length));
+};
+
+const besideWord = (line: string, at: number, end: number, word: string): boolean => {
+  const written = plain(word).toLowerCase();
+  const before = withoutFillers(line.slice(0, at).toLowerCase());
+  const after = line.slice(end).toLowerCase().replace(AFTER_RATE, "");
+  const standsAlone = (next: string | undefined): boolean => !LATIN_LETTER.test(written) || next === undefined || !LATIN_LETTER.test(next);
+  return (before.endsWith(written) && standsAlone(before.at(-written.length - 1))) || (after.startsWith(written) && standsAlone(after[written.length]));
+};
+
+/** The distinct rates the lines state right beside a rate word: 「消費税10%」, "8% sales tax", "tax rate of 8%". */
+export const statedTaxRates = (lines: readonly string[], words: readonly TaxPriceWord[]): number[] => {
+  const rateWords = words.filter((word) => word.role === "rate").map((word) => word.pattern);
+  const rates = lines.flatMap((written) => {
+    const line = plain(written);
+    return [...line.matchAll(RATE)].flatMap((match) => {
+      const end = match.index + match[0].length;
+      return rateWords.some((word) => besideWord(line, match.index, end, word)) ? ratesIn(match[0]) : [];
+    });
+  });
+  return [...new Set(rates)];
+};
+
+/** The tax-included price as the cell writes it: its unit, its grouping and its decimals. */
+const shownLike = (written: string, exactCents: number, decimals: number): string => {
+  const number = (Math.round(exactCents) / CENTS).toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+    useGrouping: written.includes(","),
+  });
+  return written.replace(NUMBER, number);
+};
+
+const decimalsOf = (text: string): number => NUMBER.exec(text)?.[0].split(".")[1]?.length ?? 0;
+
+const rowIssue = (excludedCell: TableCell | undefined, includedCell: TableCell | undefined, rate: number): StructureIssue[] => {
+  const [excluded, included] = [excludedCell && valueIn(excludedCell.text), includedCell && valueIn(includedCell.text)];
+  if (includedCell === undefined || excluded === undefined || included === undefined || excluded.marks !== included.marks) return [];
+  if (excluded.value <= 0) return [];
+  // price × (100 + rate)% in cents is price × (100 + rate); the price is not rounded first ($0.335 at 10% is $0.3685).
+  const exactCents = excluded.value * (CENTS + rate);
+  if (roundedMatches(Math.round(included.value * CENTS), exactCents, included.step >= 1)) return [];
+  const written = plain(includedCell.text);
+  const values = { written, expected: shownLike(written, exactCents, decimalsOf(written)), rate: `${String(rate)}%`, base: plain(excludedCell?.text ?? "") };
+  return [{ offset: offsetOf(includedCell), values }];
+};
+
+/**
+ * Each row of a price list whose tax-included price is not its tax-excluded price plus the rate, rounded down, to nearest or
+ * up. A pair is not read when the document states a rate other than its own (a reduced rate beside the standard one): which
+ * items take which is not written in the columns.
+ */
+export const taxIncludedPriceMismatches = (text: TaxPriceText, words: readonly TaxPriceWord[]): StructureIssue[] => {
+  if (words.length === 0) return [];
+  const stated = statedTaxRates(text.lines, words);
+  return text.tables.flatMap((table) =>
+    taxPricePairsOf(
+      table.header.map((cell) => cell.text),
+      words,
+    ).flatMap((pair) => {
+      const rate = pair.rate ?? stated[0];
+      if (rate === undefined || stated.some((other) => other !== rate)) return [];
+      return bodyRows(table).flatMap((row) => rowIssue(row[pair.excluded], row[pair.included], rate));
+    }),
+  );
+};

package/src/structure/tax.ts

@@ -15,6 +15,8 @@ export type TaxWords = {
   readonly totals: readonly string[];
   /** 税の行が内税だと分かる語（うち、included）。 */
   readonly included: readonly string[];
+  /** 率で掛かる料金の行の頭の語（サービス料、Service charge）。税はその料金を足した額に掛かってもよい。 */
+  readonly charges: readonly string[];
 };
 
 const RATE = /(\d{1,2}(?:\.\d{1,2})?)[ \t]?[%％]/u;
@@ -22,6 +24,8 @@ const PERCENT = new Set(["%", "％"]);
 /** A sign or an opening bracket right before an amount (-$200, ▲500, (1,200)): the amount may be negative. */
 const SIGNED = /[-−▲△(（][ \t]?(?:[$€£¥￥][ \t]?)?$/u;
 const CENTS = 100;
+/** More charge rows than this in a row give too many ways to tax them, so there is no base. */
+const MAX_CHARGES = 4;
 const MAX_RATE = 100;
 
 type Row = { readonly line: Line; readonly text: string; readonly amounts: readonly Amount[] };
@@ -41,6 +45,8 @@ const rateOf = (text: string): number | undefined => {
 const isTaxRow = (row: Row, words: TaxWords): boolean =>
   isTotalLabel(row.text, words.labels) && !words.included.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
 
+const isChargeRow = (row: Row, words: TaxWords): boolean => isTotalLabel(row.text, words.charges) && rateOf(row.text) !== undefined;
+
 /** The list marker at the start of a line (- $500) is not a sign. */
 const isSigned = (source: string, row: Row, amount: Amount): boolean => {
   const before = source.slice(row.line.start, amount.offset);
@@ -58,21 +64,40 @@ const amountAt = (source: string, row: Row, column: number, unit: string): Amoun
   return matching.length === 1 && only !== undefined && !isSigned(source, row, only) ? only : undefined;
 };
 
+const sumOf = (values: readonly number[]): number => values.reduce((sum, value) => sum + value, 0);
+
+/** The amounts of the rows in the column and unit of the tax, undefined when a row has none (or more than one). */
+const valuesAt = (source: string, rows: readonly Row[], column: number, unit: string): number[] | undefined => {
+  const amounts = rows.map((row) => amountAt(source, row, column, unit));
+  return amounts.some((amount) => amount === undefined) ? undefined : amounts.flatMap((amount) => (amount === undefined ? [] : [amount.value]));
+};
+
 /**
- * The base the tax is on: the last total row above, or the sum of the item rows above when there is no total row. A row
- * with an amount between the total and the tax (a discount, shipping) may or may not be taxed, so there is no base.
+ * The base with each set of the charges above it added, the full sum last: a tax may be on the subtotal alone or with some
+ * charges (hotels tax the service charge; a gratuity may be untaxed).
  */
-const baseOf = (source: string, above: readonly Row[], tax: Amount, column: number, words: TaxWords): Amount | undefined => {
-  const lastTotalIndex = above.findLastIndex((row) => isTotalLabel(row.text, words.totals));
-  const lastTotal = above[lastTotalIndex];
+const withCharges = (base: number, charges: readonly number[]): number[] =>
+  charges.length > MAX_CHARGES ? [] : charges.reduce<number[]>((sums, charge) => [...sums, ...sums.map((sum) => sum + charge)], [0]).map((sum) => base + sum);
+
+/**
+ * The bases the rate may be on: the last total row above, or the sum of the item rows above when there is no total row,
+ * each with and without the rate charge rows (a service charge) right above the row. Any other row with an amount between
+ * the total and the row (a discount, shipping) may or may not be taxed, so there is no base.
+ */
+const basesOf = (source: string, above: readonly Row[], tax: Amount, column: number, words: TaxWords): number[] => {
+  const chargeStart = above.findLastIndex((row) => !isChargeRow(row, words)) + 1;
+  const charges = valuesAt(source, above.slice(chargeStart), column, tax.unit);
+  if (charges === undefined) return [];
+  const before = above.slice(0, chargeStart);
+  const lastTotalIndex = before.findLastIndex((row) => isTotalLabel(row.text, words.totals));
+  const lastTotal = before[lastTotalIndex];
   if (lastTotal !== undefined) {
-    const between = above.slice(lastTotalIndex + 1);
-    return between.some((row) => row.amounts.length > 0) ? undefined : amountAt(source, lastTotal, column, tax.unit);
+    const total = amountAt(source, lastTotal, column, tax.unit);
+    const between = before.slice(lastTotalIndex + 1);
+    return total === undefined || between.some((row) => row.amounts.length > 0) ? [] : withCharges(total.value, charges);
   }
-  const items = above.map((row) => amountAt(source, row, column, tax.unit));
-  if (items.length === 0 || items.some((item) => item === undefined)) return undefined;
-  const values = items.flatMap((item) => (item === undefined ? [] : [item.value]));
-  return { offset: tax.offset, end: tax.end, unit: tax.unit, value: values.reduce((sum, value) => sum + value, 0) };
+  const items = valuesAt(source, before, column, tax.unit);
+  return items === undefined || items.length === 0 ? [] : withCharges(sumOf(items), charges);
 };
 
 /**
@@ -94,21 +119,31 @@ const issueOf = (source: string, rows: readonly Row[], index: number, rate: numb
   const tax = row?.amounts.length === 1 ? row.amounts[0] : undefined;
   if (row === undefined || tax === undefined || isSigned(source, row, tax)) return [];
   const column = columnOf(source, row.line, tax.offset);
-  const base = baseOf(source, rows.slice(0, index), tax, column, words);
-  if (base === undefined || taxMatches(Math.round(tax.value * CENTS), base.value, rate)) return [];
-  const expectedCents = Math.round(base.value * rate);
+  const bases = basesOf(source, rows.slice(0, index), tax, column, words);
+  const base = bases.at(-1);
+  if (base === undefined || bases.some((candidate) => taxMatches(Math.round(tax.value * CENTS), candidate, rate))) return [];
+  const expectedCents = Math.round(base * rate);
   const shown = shownTotal(source, tax, expectedCents);
   return [{ offset: tax.offset, values: { written: shown.written ?? "", expected: shown.sum ?? "", rate: `${String(rate)}%` } }];
 };
 
-const runIssues = (source: string, rows: readonly Row[], words: TaxWords): StructureIssue[] => {
-  const taxRows = rows.flatMap((row, index) => {
-    const rate = isTaxRow(row, words) ? rateOf(row.text) : undefined;
+type RateRow = { readonly index: number; readonly rate: number };
+
+const rateRowsOf = (rows: readonly Row[], isRateRow: (row: Row) => boolean): RateRow[] =>
+  rows.flatMap((row, index) => {
+    const rate = isRateRow(row) ? rateOf(row.text) : undefined;
     return rate === undefined ? [] : [{ index, rate }];
   });
-  if (new Set(taxRows.map((row) => row.rate)).size > 1) return [];
-  return taxRows.flatMap(({ index, rate }) => issueOf(source, rows, index, rate, words));
+
+/** Tax rows of different rates split the base (a reduced rate), so none is compared; a charge row is not a tax row. */
+const runIssues = (source: string, rows: readonly Row[], words: TaxWords): StructureIssue[] => {
+  const taxRows = rateRowsOf(rows, (row) => isTaxRow(row, words) && !isChargeRow(row, words));
+  const firstTax = taxRows[0]?.index ?? rows.length;
+  // A charge below a tax row (a suggested gratuity under the total) is often on the amount before tax, so it is not read.
+  const chargeRows = rateRowsOf(rows, (row) => isChargeRow(row, words)).filter((row) => row.index < firstTax);
+  const comparable = new Set(taxRows.map((row) => row.rate)).size > 1 ? chargeRows : [...taxRows, ...chargeRows];
+  return comparable.flatMap(({ index, rate }) => issueOf(source, rows, index, rate, words));
 };
 
 export const taxMismatches = (source: string, amounts: readonly Amount[], words: TaxWords): StructureIssue[] =>
-  words.labels.length === 0 ? [] : runsOf(source).flatMap((run) => runIssues(source, rowsOf(source, run, amounts), words));
+  words.labels.length + words.charges.length === 0 ? [] : runsOf(source).flatMap((run) => runIssues(source, rowsOf(source, run, amounts), words));