chaffjs 0.30.0 → 0.32.0

package/src/structure/line-amount-rate.ts

@@ -0,0 +1,178 @@
+/**
+ * ポイントの明細で、利用金額 × 還元率が獲得ポイントと合わない行。見出しの語（points-earned-column）から利用金額・還元率・
+ * 獲得ポイントの列を見つける。還元率は 3%（利用金額の 3/100）か、見出しが何あたりかを言う数（Points per $1 の 3）で、
+ * 還元率の列が無い表は、表の前の同じ節の文が言う率（100円ごとに10ポイント）を使う。利用金額と獲得ポイントは単位が違ってよい
+ * のは、獲得ポイントの升がポイントの単位（points-unit）で書かれたときだけ。端数は切り捨て・四捨五入・切り上げのどれでもよく、
+ * 何円ごとに何ポイントと数える切り捨て（18,450円の 3% を 184 × 3）も合っていると読む。Pure.
+ */
+import type { StructureIssue } from "./issues.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { TABLE_ROW } from "./runs.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { cellNumber } from "./line-amount.ts";
+import { roundedMatches } from "./tax.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+export type PointsRole = "base" | "rate" | "earned";
+/** A column heading and its role; a rate heading's per is the amount a bare rate is per (Points per $1: 1). */
+export type PointsColumnWord = { readonly pattern: string; readonly role: PointsRole; readonly per: number | undefined };
+export type PointsWords = {
+  readonly columns: readonly PointsColumnWord[];
+  /** What a points amount is written in (ポイント, points). */
+  readonly units: readonly string[];
+  /** What joins a points amount to the money it is per in a sentence (ごとに, for every). */
+  readonly joiners: readonly string[];
+};
+
+/**
+ * value points per `per` of the base's unit: 3% is 3 per 100, 10 points for every $1 is 10 per 1. A rate stated in a
+ * sentence keeps the marks of its money ("$|"), and goes only with a base written with the same ones.
+ */
+export type PointsRate = { readonly value: number; readonly per: number; readonly written: string; readonly marks?: string };
+
+type Columns = { readonly base: number; readonly earned: number; readonly rate: (PointsColumnWord & { readonly index: number }) | undefined };
+type CellNumber = NonNullable<ReturnType<typeof cellNumber>>;
+
+const CENTS = 100;
+const PERCENT = 100;
+const NUMBER = /\d[\d,]*(?:\.\d+)?/u;
+
+const key = (text: string): string => text.normalize("NFKC").replace(/[*_`]/gu, "").trim().toLowerCase();
+
+const valueOf = (written: string): number => Number(written.replaceAll(",", ""));
+
+/**
+ * Whether the written points are the base times the rate: rounded down, to nearest or up, or counted per whole step of
+ * the base (100円ごとに3ポイント gives 184 × 3 for 18,450円).
+ */
+export const pointsMatch = (written: number, base: number, rate: PointsRate): boolean => {
+  const writtenCents = Math.round(written * CENTS);
+  if (roundedMatches(writtenCents, (base * rate.value * CENTS) / rate.per)) return true;
+  return Math.abs(Math.floor(base / rate.per) * rate.value * CENTS - writtenCents) < 1;
+};
+
+const columnOf = (header: readonly Cell[], words: PointsWords, role: PointsRole): (PointsColumnWord & { index: number })[] =>
+  header.flatMap((cell, index) => {
+    const word = words.columns.find((entry) => entry.role === role && key(entry.pattern) === key(cell.text));
+    return word === undefined ? [] : [{ ...word, index }];
+  });
+
+/** The base and earned columns (one each) and the rate column (one or none); undefined when the table is not one. */
+const columnsOf = (header: readonly Cell[], words: PointsWords): Columns | undefined => {
+  const [bases, earned, rates] = [columnOf(header, words, "base"), columnOf(header, words, "earned"), columnOf(header, words, "rate")];
+  const [base, points] = [bases[0], earned[0]];
+  if (bases.length !== 1 || earned.length !== 1 || rates.length > 1 || base === undefined || points === undefined) return undefined;
+  return { base: base.index, earned: points.index, rate: rates[0] };
+};
+
+const isPointsUnit = (mark: string, words: PointsWords): boolean => words.units.some((unit) => key(unit) === key(mark));
+
+/** Points written bare or in a points unit, or in the base's own unit (a cashback in yen); a base in points is not money. */
+const unitsFit = (base: CellNumber, earned: CellNumber, words: PointsWords): boolean => {
+  if (isPointsUnit(base.after, words) || isPointsUnit(base.before, words)) return false;
+  if (earned.before === base.before && earned.after === base.after) return true;
+  return earned.before === "" && (earned.after === "" || isPointsUnit(earned.after, words));
+};
+
+/** A rate cell: 3% is per 100; a bare number (or one in points) is per what its heading says, and unread when it says nothing. */
+export const rateIn = (written: string, per: number | undefined, words: PointsWords): PointsRate | undefined => {
+  const rate = cellNumber({ start: 0, text: written });
+  if (rate === undefined || rate.before !== "" || rate.value <= 0) return undefined;
+  if (rate.after === "%") return { value: rate.value, per: PERCENT, written: rate.written };
+  const bare = rate.after === "" || isPointsUnit(rate.after, words);
+  return bare && per !== undefined ? { value: rate.value, per, written: rate.written } : undefined;
+};
+
+/** Another cell in a points unit (a bonus): the earned points may not be the base times the rate alone. */
+const hasOtherPoints = (cells: readonly Cell[], columns: Columns, words: PointsWords): boolean =>
+  cells.some((cell, index) => {
+    if (index === columns.base || index === columns.earned || index === columns.rate?.index) return false;
+    const number = cellNumber(cell);
+    return number !== undefined && isPointsUnit(number.after, words);
+  });
+
+const shownLike = (earned: CellNumber, exact: number): string => {
+  const decimals = earned.decimals;
+  const number = (Math.floor(exact * 10 ** decimals) / 10 ** decimals).toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+    useGrouping: earned.grouped,
+  });
+  return earned.written.replace(NUMBER, number);
+};
+
+/** The row's rate: its rate cell's, or with no rate column the one the section states. */
+const rowRate = (cells: readonly Cell[], columns: Columns, stated: PointsRate | undefined, words: PointsWords): PointsRate | undefined => {
+  if (columns.rate === undefined) return stated;
+  const cell = cells[columns.rate.index];
+  return cell === undefined ? undefined : rateIn(cell.text, columns.rate.per, words);
+};
+
+const rowIssue = (cells: readonly Cell[], columns: Columns, stated: PointsRate | undefined, words: PointsWords): StructureIssue[] => {
+  const [baseCell, earnedCell] = [cells[columns.base], cells[columns.earned]];
+  const base = baseCell === undefined ? undefined : cellNumber(baseCell);
+  const earned = earnedCell === undefined ? undefined : cellNumber(earnedCell);
+  const rate = rowRate(cells, columns, stated, words);
+  if (base === undefined || earned === undefined || rate === undefined || !unitsFit(base, earned, words)) return [];
+  if (rate.marks !== undefined && rate.marks !== marksOf(base)) return [];
+  if (hasOtherPoints(cells, columns, words) || pointsMatch(earned.value, base.value, rate)) return [];
+  const expected = shownLike(earned, (base.value * rate.value) / rate.per);
+  return [{ offset: earned.offset, values: { written: earned.written, quantity: base.written, price: rate.written, expected } }];
+};
+
+const WHOLE = "\\d{1,3}(?:,\\d{3})+|\\d+";
+/** What may stand between the money, the joiner and the points: spaces and a comma. */
+const GAP = "[\\s、,]*";
+
+const marksOf = (money: CellNumber): string => `${money.before}|${money.after}`;
+
+const alternatives = (words: readonly string[]): string =>
+  words
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+/** "100円ごとに10ポイント" (money, joiner, points) and "10 points for every $1" (points, joiner, money), next to each other. */
+const statementPatterns = (base: CellNumber, words: PointsWords): RegExp[] => {
+  const money = `${escapeRegExp(base.before)}\\s*(?<money>${WHOLE})(?![.,]?\\d)\\s*${escapeRegExp(base.after)}`;
+  const points = `(?<pointsText>(?<![\\d,.])(?<points>${WHOLE})\\s*(?:${alternatives(words.units)}))`;
+  const joiner = `(?:${alternatives(words.joiners)})`;
+  return [`${money}${GAP}${joiner}${GAP}${points}`, `${points}${GAP}${joiner}${GAP}${money}`].map((pattern) => new RegExp(pattern, "giu"));
+};
+
+/** The one rate a line states (10 points for every $1), undefined when it states none or more than one. */
+export const statedRateIn = (text: string, base: CellNumber, words: PointsWords): PointsRate | undefined => {
+  if ((base.before === "" && base.after === "") || words.units.length === 0 || words.joiners.length === 0) return undefined;
+  const statements = statementPatterns(base, words).flatMap((pattern) => [...text.normalize("NFKC").matchAll(pattern)]);
+  const groups = statements.length === 1 ? statements[0]?.groups : undefined;
+  const [value, per, written] = [groups?.["points"], groups?.["money"], groups?.["pointsText"]];
+  if (value === undefined || per === undefined || written === undefined || valueOf(per) <= 0) return undefined;
+  return { value: valueOf(value), per: valueOf(per), written: `${written}/${base.before}${per}${base.after}`, marks: marksOf(base) };
+};
+
+/** The rate the prose of the table's section states before it, when every statement there gives the same one. */
+const sectionRate = (prose: readonly Line[], from: number, to: number, base: CellNumber, words: PointsWords): PointsRate | undefined => {
+  const rates = prose.filter((line) => line.start >= from && line.start < to).flatMap((line) => statedRateIn(line.text, base, words) ?? []);
+  return new Set(rates.map((rate) => `${String(rate.value)}/${String(rate.per)}`)).size === 1 ? rates[0] : undefined;
+};
+
+const firstBase = (rows: readonly Line[], columns: Columns): CellNumber | undefined =>
+  rows.flatMap((row) => {
+    const cell = cellsOf(row)[columns.base];
+    return cell === undefined ? [] : (cellNumber(cell) ?? []);
+  })[0];
+
+/** Each row of a points table whose earned points are not the base times the rate. headings: where each heading starts. */
+export const pointsMismatches = (source: string, headings: readonly number[], words: PointsWords): StructureIssue[] => {
+  if (words.columns.length === 0) return [];
+  const lines = linesOf(source);
+  const prose = lines.filter((line) => !TABLE_ROW.test(line.text) && line.text.trim() !== "");
+  return tablesOf(lines).flatMap(({ header, rows }) => {
+    const columns = columnsOf(cellsOf(header), words);
+    if (columns === undefined) return [];
+    const from = Math.max(0, ...headings.filter((start) => start <= header.start));
+    const base = firstBase(rows, columns);
+    const stated = columns.rate === undefined && base !== undefined ? sectionRate(prose, from, header.start, base, words) : undefined;
+    return rows.flatMap((row) => rowIssue(cellsOf(row), columns, stated, words));
+  });
+};

package/src/structure/line-amount-unit.ts

@@ -33,3 +33,19 @@ export const quantityUnit = (word: string, units: readonly UnitWord[]): string |
  */
 export const unitsAgree = (quantity: string | undefined, pricePer: string | undefined): boolean =>
   pricePer === undefined || quantity === "" || quantity === pricePer;
+
+/**
+ * The unit a price heading is per. A heading that names no unit a quantity counts (Rate, whose period is unstated) is per
+ * the quantity heading's unit when that is one a price can be per (Hours, Miles); otherwise it stays as it is, so a bare
+ * Rate beside a plain Quantity column is still not multiplied by "2 days". A unit only a quantity heading counts (a
+ * head count: Per student beside Students) is stated too, so Per student beside Days stays per a person.
+ */
+export const priceHeadingUnit = (
+  priceUnit: string | undefined,
+  quantityHeadingUnit: string | undefined,
+  rateUnits: readonly string[],
+  headingUnits: readonly string[],
+): string | undefined => {
+  if (priceUnit === undefined || rateUnits.includes(priceUnit) || headingUnits.includes(priceUnit)) return priceUnit;
+  return quantityHeadingUnit !== undefined && rateUnits.includes(quantityHeadingUnit) ? quantityHeadingUnit : priceUnit;
+};

package/src/structure/line-amount.ts

@@ -3,13 +3,18 @@ import { linesOf, type Line } from "./lines.ts";
 import { CELL_SEPARATOR } from "./bare-numbers.ts";
 import { TABLE_RULE } from "./runs.ts";
 import { roundedMatches } from "./tax.ts";
-import { perUnitPrice, quantityUnit, unitsAgree, type UnitWord } from "./line-amount-unit.ts";
+import { holds } from "./change-rate-table.ts";
+import { roleOf, type QuantityRole, type QuantityWord } from "./order-quantity.ts";
+import { hasSuperscriptPower } from "../facts/superscript-power.ts";
+import { perUnitPrice, priceHeadingUnit, quantityUnit, unitsAgree, type UnitWord } from "./line-amount-unit.ts";
 
 /**
  * 明細の表で、数量 × 単価が金額と合わない行。見出しの行から数量・単価・金額の列を語（quantity-column、unit-price-column、
  * line-amount-column）で見つけ、本体の行ごとに数量の升の頭の数と単価の升の数を掛け、金額の升の数と比べる。
  * 単価と金額は、数の前後に書いた印（$、円、万円）が同じときだけ比べる。端数は切り捨て・四捨五入・切り上げのどれでもよい。
- * 単価が何かあたり（$100/hour、月額、Rate の列）なら、数量がその単位か単位の無い数のときだけ比べる。Pure.
+ * 単価が何かあたり（$100/hour、月額、Rate の列）なら、数量がその単位か単位の無い数のときだけ比べる。何あたりか言わない
+ * Rate の列は、数量の見出しが単位を言えば（Hours、Miles）その単位あたりと読む。発注・納品・残の数量の列（order-quantity-column）
+ * が並ぶ納品書では、どれか一つの数量で金額になれば合っていると読む。商品カタログでは入数 × 単価を1箱の価格と比べる。Pure.
  */
 export type LineAmountWords = {
   readonly quantity: readonly string[];
@@ -19,14 +24,25 @@ export type LineAmountWords = {
   readonly units: readonly UnitWord[];
   /** Marks saying a price is per a unit (per-unit-mark). */
   readonly perUnitMarks: readonly UnitWord[];
-  /** Column headings that say the unit of their column (Hours, Rate). */
+  /** Column headings that say the unit of their column (Hours, Rate, 年額). */
   readonly headerUnits: readonly UnitWord[];
+  /** Measure units written after a number (m³, km²): a quantity cell may end in one even when it holds a digit. */
+  readonly measureUnits: readonly string[];
+  /** Heading words of a delivery note's ordered, delivered and backordered counts (order-quantity-column). */
+  readonly orderRoles: readonly QuantityWord[];
+  /** Headings of a catalog's count per pack (入数, Pack of) and of its pack price (1箱の価格, Pack price). */
+  readonly packCount: readonly string[];
+  readonly packPrice: readonly string[];
+  /** Headings of the column naming the goods (品名, Description): a number in a name is no discount. */
+  readonly itemName: readonly string[];
+  /** Words saying an amount includes tax (税込, incl.): such a column restates the amount and does not change it. */
+  readonly taxIncluded: readonly string[];
 };
 
-type Cell = { readonly start: number; readonly text: string };
+export type Cell = { readonly start: number; readonly text: string };
 
 /** A number with what is written before and after it in one cell: "$1,500.00" is $ 1500 "", "15万円" is "" 15 万円. */
-type CellNumber = {
+export type CellNumber = {
   readonly before: string;
   readonly value: number;
   readonly after: string;
@@ -41,7 +57,7 @@ const ONE_NUMBER = /^([^\d]*?)(\d{1,3}(?:,\d{3})+|\d+)(\.\d+)?([^\d]*)$/u;
 const LEADING_NUMBER = /^(\d{1,3}(?:,\d{3})+|\d+)(\.\d+)?(?![\d,])/u;
 const NEGATIVE = /[-−▲△(（]/u;
 
-const cellsOf = (line: Line): Cell[] => {
+export const cellsOf = (line: Line): Cell[] => {
   const bounds = [-1, ...[...line.text.matchAll(CELL_SEPARATOR)].map((match) => match.index), line.text.length];
   const cells = bounds.slice(1).map((end, index) => {
     const from = (bounds[index] ?? 0) + 1;
@@ -51,7 +67,7 @@ const cellsOf = (line: Line): Cell[] => {
   return cells.slice(trimmed.startsWith("|") ? 1 : 0, trimmed.endsWith("|") ? cells.length - 1 : cells.length);
 };
 
-const plain = (text: string): string => text.normalize("NFKC").replace(/[*_`]/gu, "").trim();
+export const plain = (text: string): string => text.normalize("NFKC").replace(/[*_`]/gu, "").trim();
 
 /** The one number of a price cell with its marks, undefined when the cell holds none, more, or a negative one. */
 export const cellNumber = (cell: Cell): CellNumber | undefined => {
@@ -71,11 +87,19 @@ export const cellNumber = (cell: Cell): CellNumber | undefined => {
   };
 };
 
-/** The number a quantity cell starts with ("4", "3人日", "2.5 hours"), undefined when it does not, or holds another ("2 x 3"). */
-export const quantityOf = (cell: Cell): number | undefined => {
+const isMeasureUnit = (word: string, measureUnits: readonly string[]): boolean => measureUnits.some((unit) => plain(unit).toLowerCase() === word.toLowerCase());
+
+/**
+ * The number a quantity cell starts with ("4", "3人日", "2.5 hours", "16m³"), undefined when it does not, or holds another
+ * ("2 x 3", "10³"). A digit after the number is allowed only as part of a measure unit (m³ and ㎥ normalise to m3).
+ */
+export const quantityOf = (cell: Cell, measureUnits: readonly string[]): number | undefined => {
+  if (hasSuperscriptPower(cell.text)) return undefined;
   const text = plain(cell.text);
   const match = LEADING_NUMBER.exec(text);
-  if (match === null || /\d/u.test(text.slice(match[0].length))) return undefined;
+  if (match === null) return undefined;
+  const rest = text.slice(match[0].length).trim();
+  if (/\d/u.test(rest) && !isMeasureUnit(rest, measureUnits)) return undefined;
   return Number(`${(match[1] ?? "").replaceAll(",", "")}${match[2] ?? ""}`);
 };
 
@@ -83,70 +107,198 @@ export const quantityOf = (cell: Cell): number | undefined => {
 const quantityWord = (cell: Cell): string => plain(cell.text).replace(LEADING_NUMBER, "").trim();
 
 const columnNamed = (header: readonly Cell[], names: readonly string[]): number => {
-  const wanted = names.map((name) => name.toLowerCase());
+  const wanted = names.map((name) => plain(name).toLowerCase());
   return header.findIndex((cell) => wanted.includes(plain(cell.text).toLowerCase()));
 };
 
-type Columns = { readonly quantity: number; readonly unitPrice: number; readonly amount: number };
+/** What a quantity column counts: a plain quantity (数量), or a delivery note's ordered, delivered or backordered count. */
+type QuantityKind = "quantity" | QuantityRole;
+
+/** A quantity column, the unit its heading says (Hours), and the unit the price is per beside it (undefined when none is said). */
+type QuantityColumn = { readonly index: number; readonly kind: QuantityKind; readonly unit: string | undefined; readonly priceUnit: string | undefined };
+
+type Table = {
+  readonly quantities: readonly QuantityColumn[];
+  readonly unitPrice: number;
+  readonly amount: number;
+  /** The unit an amount heading says its quantity must count (年額 is months × a monthly price), undefined when it says none. */
+  readonly amountCounts: string | undefined;
+  /** Columns whose numbers do not change the amount (an item's name, the amount restated with tax, an order beside a pack price). */
+  readonly ignored: readonly number[];
+};
 
-/** A table's columns, and the units its quantity and price headings say (undefined when they say none). */
-type Table = { readonly columns: Columns; readonly quantityUnit: string | undefined; readonly priceUnit: string | undefined };
+/** The column a mismatch is shown against: a delivery note bills what was delivered, then a plain quantity, then what was ordered. */
+const SHOWN_FIRST: readonly QuantityKind[] = ["delivered", "quantity", "ordered", "backordered"];
 
 const headerUnit = (cell: Cell | undefined, words: LineAmountWords): string | undefined =>
-  cell === undefined ? undefined : words.headerUnits.find((word) => word.pattern.toLowerCase() === plain(cell.text).toLowerCase())?.unit;
+  cell === undefined ? undefined : words.headerUnits.find((word) => plain(word.pattern).toLowerCase() === plain(cell.text).toLowerCase())?.unit;
+
+const kindOf = (cell: Cell, words: LineAmountWords): QuantityKind | undefined => {
+  if (columnNamed([cell], words.quantity) === 0) return "quantity";
+  const role = roleOf(cell.text, words.orderRoles);
+  return role === "both" ? undefined : role;
+};
+
+const namesQuantity = (cell: Cell, words: LineAmountWords): boolean => words.quantity.some((word) => holds(plain(cell.text).toLowerCase(), word));
+
+/**
+ * The quantity columns: each heading named as a quantity (数量), and each naming an ordered, delivered or backordered
+ * count (発注数量, Qty delivered). A role word alone ("Ordered", "Delivered") may head a date, so it is read only in a
+ * table with a backordered column, which is always a count. Two columns of one kind leave no way to choose, so such a
+ * table is not read.
+ */
+const quantityColumnsOf = (header: readonly Cell[], words: LineAmountWords): Omit<QuantityColumn, "priceUnit">[] | undefined => {
+  const kinds = header.map((cell) => kindOf(cell, words));
+  const countsRemainder = kinds.includes("backordered");
+  const columns = header.flatMap((cell, index) => {
+    const kind = kinds[index];
+    if (kind === undefined || (kind !== "quantity" && !countsRemainder && !namesQuantity(cell, words))) return [];
+    return [{ index, kind, unit: headerUnit(cell, words) }];
+  });
+  return columns.length === 0 || new Set(columns.map((column) => column.kind)).size < columns.length ? undefined : columns;
+};
+
+const headingHolds = (cell: Cell, names: readonly string[]): boolean => names.some((name) => holds(plain(cell.text).toLowerCase(), name));
+
+/** A heading without its bracketed note: "1箱の価格（税込・10%）" and "Pack price (excl. tax)" are "1箱の価格" and "pack price". */
+const headingBase = (cell: Cell): string =>
+  plain(cell.text)
+    .replace(/\([^()]*\)/gu, "")
+    .trim()
+    .toLowerCase();
+
+/**
+ * The columns whose numbers say nothing about the amount: an item's name (A5), and the amount again with tax — a heading
+ * that says tax is included and is the amount heading but for its bracketed note (1箱の価格（税込） beside 1箱の価格（税抜）).
+ * "金額のうち値引き" is no such heading, so its numbers still keep the row from being compared.
+ */
+const ignoredColumnsOf = (header: readonly Cell[], amount: number, words: LineAmountWords): number[] => {
+  const amountCell = header[amount];
+  return header.flatMap((cell, index) => {
+    const restated = amountCell !== undefined && index !== amount && headingHolds(cell, words.taxIncluded) && headingBase(cell) === headingBase(amountCell);
+    return restated || columnNamed([cell], words.itemName) === 0 ? [index] : [];
+  });
+};
+
+const distinct = (indexes: readonly number[]): boolean => indexes.every((index) => index >= 0) && new Set(indexes).size === indexes.length;
+
+/** The units quantity headings count (Hours: hour, Students: person). */
+const quantityHeadingUnits = (words: LineAmountWords): string[] =>
+  words.headerUnits.flatMap((word) => (columnNamed([{ start: 0, text: word.pattern }], words.quantity) === 0 ? [word.unit] : []));
 
 const tableOf = (header: readonly Cell[], words: LineAmountWords): Table | undefined => {
-  const columns = { quantity: columnNamed(header, words.quantity), unitPrice: columnNamed(header, words.unitPrice), amount: columnNamed(header, words.amount) };
-  if (Object.values(columns).some((index) => index < 0) || new Set(Object.values(columns)).size < 3) return undefined;
-  return { columns, quantityUnit: headerUnit(header[columns.quantity], words), priceUnit: headerUnit(header[columns.unitPrice], words) };
+  const quantities = quantityColumnsOf(header, words);
+  const [unitPrice, amount] = [columnNamed(header, words.unitPrice), columnNamed(header, words.amount)];
+  if (quantities === undefined || !distinct([unitPrice, amount])) return undefined;
+  if (quantities.some((column) => column.index === unitPrice || column.index === amount)) return undefined;
+  const priceUnit = headerUnit(header[unitPrice], words);
+  const rateUnits = words.units.map((word) => word.unit);
+  const headingUnits = quantityHeadingUnits(words);
+  const columns = quantities.map((column) => ({ ...column, priceUnit: priceHeadingUnit(priceUnit, column.unit, rateUnits, headingUnits) }));
+  return { quantities: columns, unitPrice, amount, amountCounts: headerUnit(header[amount], words), ignored: ignoredColumnsOf(header, amount, words) };
+};
+
+/**
+ * A catalog's pack: count per pack × unit price = pack price. The count is no order quantity, so it is read only beside
+ * a pack price heading; an order's quantity and amount columns beside them (数量 × 1箱の価格 = 金額) do not change the pack price.
+ * An amount column without an order quantity is not known to be an order's, so its numbers still keep the row out.
+ */
+const packTableOf = (header: readonly Cell[], words: LineAmountWords): Table | undefined => {
+  const [count, unitPrice, amount] = [columnNamed(header, words.packCount), columnNamed(header, words.unitPrice), columnNamed(header, words.packPrice)];
+  if (!distinct([count, unitPrice, amount])) return undefined;
+  const quantities = header.flatMap((cell, index) => (kindOf(cell, words) === undefined ? [] : [index]));
+  const lineAmount = columnNamed(header, words.amount);
+  const order = quantities.length > 0 && lineAmount >= 0 ? [...quantities, lineAmount] : quantities;
+  const priceUnit = headerUnit(header[unitPrice], words);
+  const quantity: QuantityColumn = { index: count, kind: "quantity", unit: undefined, priceUnit };
+  return { quantities: [quantity], unitPrice, amount, amountCounts: undefined, ignored: [...order, ...ignoredColumnsOf(header, amount, words)] };
 };
 
 /** The unit the quantity cell counts: its own word, else its heading's ("Hours"). */
-const rowQuantityUnit = (cell: Cell, table: Table, words: LineAmountWords): string | undefined => {
+const rowQuantityUnit = (cell: Cell, column: QuantityColumn, words: LineAmountWords): string | undefined => {
   const unit = quantityUnit(quantityWord(cell), words.units);
-  return unit === "" && table.quantityUnit !== undefined ? table.quantityUnit : unit;
+  return unit === "" && column.unit !== undefined ? column.unit : unit;
 };
 
 /** quantity × price, written the way the amount cell writes its number (grouping, decimals, marks). */
-const shownExpected = (amount: CellNumber, exactCents: number): string => {
+export const shownExpected = (amount: CellNumber, exactCents: number): string => {
   const exact = exactCents / CENTS;
   const decimals = Number.isInteger(Math.round(exact * CENTS) / CENTS) && amount.decimals === 0 ? 0 : Math.max(amount.decimals, 2);
   const number = exact.toLocaleString("en-US", { minimumFractionDigits: decimals, maximumFractionDigits: decimals, useGrouping: amount.grouped });
   return `${amount.before}${number}${amount.after}`;
 };
 
+/**
+ * Whether the row's quantity can turn its price into the amount. A price per a unit goes with a quantity in that unit
+ * or a bare number; an amount heading that says what its quantity counts (年額: months) takes only a quantity in that
+ * unit, so 5 seats or 2 hours beside a monthly or hourly price is not compared with a year's amount.
+ */
+const quantityFits = (reading: Reading, table: Table, perUnit: string | undefined, words: LineAmountWords): boolean => {
+  const unit = rowQuantityUnit(reading.cell, reading.column, words);
+  return unitsAgree(unit, perUnit ?? reading.column.priceUnit) && (table.amountCounts === undefined || unit === table.amountCounts);
+};
+
+const usedColumns = (table: Table): number[] => [...table.quantities.map((column) => column.index), table.unitPrice, table.amount];
+
+const hasDigit = (cell: Cell): boolean => /\d/u.test(plain(cell.text));
+
 /** Another cell than the item name with a number in it (a discount, a tax rate): the amount may not be quantity × price alone. */
-const hasOtherNumber = (cells: readonly Cell[], columns: Columns): boolean =>
-  cells.some((cell, index) => index > 0 && !Object.values(columns).includes(index) && /\d/u.test(plain(cell.text)));
+const hasOtherNumber = (cells: readonly Cell[], table: Table): boolean =>
+  cells.some((cell, index) => index > 0 && !usedColumns(table).includes(index) && !table.ignored.includes(index) && hasDigit(cell));
 
-const rowIssue = (row: Line, table: Table, words: LineAmountWords): StructureIssue[] => {
-  const { columns } = table;
-  const cells = cellsOf(row);
-  if (hasOtherNumber(cells, columns)) return [];
-  const quantityCell = cells[columns.quantity];
-  const priceCell = cells[columns.unitPrice];
-  const amountCell = cells[columns.amount];
-  if (quantityCell === undefined || priceCell === undefined || amountCell === undefined) return [];
-  const quantity = quantityOf(quantityCell);
-  const price = cellNumber(priceCell);
-  const amount = cellNumber(amountCell);
-  if (quantity === undefined || price === undefined || amount === undefined) return [];
+type Reading = { readonly column: QuantityColumn; readonly cell: Cell; readonly quantity: number };
+
+/**
+ * The row's quantities, one per quantity column whose cell holds one; a cell without a number (an empty remainder) is
+ * skipped. Undefined when a cell holds digits that are no quantity ("6 x 2"), or when no column holds one.
+ */
+const readingsOf = (cells: readonly Cell[], table: Table, words: LineAmountWords): Reading[] | undefined => {
+  const readings = table.quantities.flatMap((column) => {
+    const cell = cells[column.index];
+    return cell === undefined ? [] : [{ column, cell, quantity: quantityOf(cell, words.measureUnits) }];
+  });
+  if (readings.some(({ cell, quantity }) => quantity === undefined && hasDigit(cell))) return undefined;
+  const read = readings.flatMap(({ column, cell, quantity }) => (quantity === undefined ? [] : [{ column, cell, quantity }]));
+  return read.length === 0 ? undefined : read;
+};
+
+const shownFirst = (readings: readonly Reading[]): Reading | undefined =>
+  readings.toSorted((left, right) => SHOWN_FIRST.indexOf(left.column.kind) - SHOWN_FIRST.indexOf(right.column.kind))[0];
+
+type Priced = { readonly price: CellNumber; readonly amount: CellNumber; readonly perUnit: string | undefined };
+
+/** The row's price and amount, when both are one number written with the same marks (a per-unit mark taken off the price). */
+const pricedOf = (cells: readonly Cell[], table: Table, words: LineAmountWords): Priced | undefined => {
+  const [priceCell, amountCell] = [cells[table.unitPrice], cells[table.amount]];
+  const price = priceCell === undefined ? undefined : cellNumber(priceCell);
+  const amount = amountCell === undefined ? undefined : cellNumber(amountCell);
+  if (price === undefined || amount === undefined) return undefined;
   const perUnit = perUnitPrice(price.before, price.after, words.perUnitMarks);
   const marks = perUnit ?? price;
-  if (marks.before !== amount.before || marks.after !== amount.after) return [];
-  if (!unitsAgree(rowQuantityUnit(quantityCell, table, words), perUnit?.unit ?? table.priceUnit)) return [];
-  const exactCents = quantity * price.value * CENTS;
-  if (roundedMatches(Math.round(amount.value * CENTS), exactCents, amount.decimals === 0)) return [];
-  return [
-    {
-      offset: amount.offset,
-      values: { written: amount.written, quantity: plain(quantityCell.text), price: price.written, expected: shownExpected(amount, exactCents) },
-    },
-  ];
+  return marks.before === amount.before && marks.after === amount.after ? { price, amount, perUnit: perUnit?.unit } : undefined;
+};
+
+/**
+ * A row is reported only when no quantity column times the price gives the amount: a delivery note may bill what was
+ * ordered or what was delivered, and either is right. The finding shows the column SHOWN_FIRST names.
+ */
+const rowIssue = (row: Line, table: Table, words: LineAmountWords): StructureIssue[] => {
+  const cells = cellsOf(row);
+  const readings = hasOtherNumber(cells, table) ? undefined : readingsOf(cells, table, words);
+  const priced = readings === undefined ? undefined : pricedOf(cells, table, words);
+  if (readings === undefined || priced === undefined) return [];
+  const { price, amount, perUnit } = priced;
+  if (!readings.every((reading) => quantityFits(reading, table, perUnit, words))) return [];
+  const centsOf = (reading: Reading): number => reading.quantity * price.value * CENTS;
+  if (readings.some((reading) => roundedMatches(Math.round(amount.value * CENTS), centsOf(reading), amount.decimals === 0))) return [];
+  const shown = shownFirst(readings);
+  if (shown === undefined) return [];
+  const values = { written: amount.written, quantity: plain(shown.cell.text), price: price.written, expected: shownExpected(amount, centsOf(shown)) };
+  return [{ offset: amount.offset, values }];
 };
 
 /** Each table: its header row and its body rows. */
-const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] =>
+export const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] =>
   lines.flatMap((line, index) => {
     const header = lines[index - 1];
     if (!TABLE_RULE.test(line.text) || header === undefined || !header.text.includes("|")) return [];
@@ -157,6 +309,6 @@ const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] =>
 
 export const lineAmountMismatches = (source: string, words: LineAmountWords): StructureIssue[] =>
   tablesOf(linesOf(source)).flatMap(({ header, rows }) => {
-    const table = tableOf(cellsOf(header), words);
-    return table === undefined ? [] : rows.flatMap((row) => rowIssue(row, table, words));
+    const readings = [tableOf(cellsOf(header), words), packTableOf(cellsOf(header), words)];
+    return readings.flatMap((table) => (table === undefined ? [] : rows.flatMap((row) => rowIssue(row, table, words))));
   });