chaffjs 0.30.0 → 0.32.0

package/src/structure/net-amount.ts

@@ -0,0 +1,243 @@
+/**
+ * net-amount-mismatch: the deciding half. A net amount (差引支給額, Net pay) or a taxable amount (課税対象額, Taxable income)
+ * against the gross amount (総支給額, Gross pay) minus the total of deductions (控除合計, Total deductions) written in the same
+ * table or the same section, or minus the parts of the deductions added up (手付金, 融資金). Which words name them is data
+ * (lexicon net-amount-label, grouped gross / deduction / deduction-part / net / taxable); nothing here knows a word of payroll or tax. Pure.
+ */
+import { keyOf, labelKey, noteOf, readNumber } from "./ratio.ts";
+import { withoutPeriod, type TotalQualifier } from "./total-line.ts";
+
+export const NET_ROLES = ["gross", "deduction", "deduction-part", "net", "taxable"] as const;
+export type NetRole = (typeof NET_ROLES)[number];
+
+/** A period word; group names its term, so "Fall" and "for the fall" are one term. */
+export type NetPeriod = TotalQualifier & { readonly group?: string | undefined };
+
+export type NetWords = {
+  readonly labels: Readonly<Record<NetRole, readonly string[]>>;
+  /** Words of the term an amount is for (net-amount-period: 前期分の, Fall, for the fall), cut off a label before it is read. */
+  readonly periods: readonly NetPeriod[];
+  /** Names read only with a period on them (Charges, as Fall charges): alone, the word is too common to name a role. */
+  readonly periodLabels?: Readonly<Partial<Record<NetRole, readonly string[]>>> | undefined;
+  /** Words of magnitude (千, million): an amount written in them is rounded. */
+  readonly magnitudes: readonly string[];
+  readonly percentUnits: readonly string[];
+};
+
+/** An amount as written in a cell or after a label: the text around its number is its unit. */
+export type NetAmount = {
+  readonly start: number;
+  readonly value: number;
+  readonly decimals: number;
+  readonly prefix: string;
+  readonly suffix: string;
+  /** What the amount is compared on: the marks around the number and the note of its label (Net pay (USD)). */
+  readonly unit: string;
+  /** The amount as written, and whether its number groups thousands with commas. */
+  readonly written: string;
+  readonly grouped: boolean;
+};
+
+/** label is the role's word, its note aside: amounts of one label are one value, and parts of different labels add up. */
+export type LabelledAmount = NetAmount & { readonly role: NetRole; readonly period?: string | undefined; readonly label?: string };
+
+export type NetIssue = { readonly offset: number; readonly values: Readonly<Record<string, string>> };
+
+const DECIMAL_BASE = 10;
+const HALF = 0.5;
+
+const roleOfKey = (key: string, words: NetWords, afterPeriod = false): NetRole | undefined =>
+  NET_ROLES.find((role) => [...words.labels[role], ...(afterPeriod ? (words.periodLabels?.[role] ?? []) : [])].some((pattern) => keyOf(pattern) === key));
+
+/** A label read: the role it names and, when a period was cut off it, which term that period is. */
+export type LabelRead = { readonly role: NetRole; readonly period?: string };
+
+const withPeriodCut = (key: string, period: NetPeriod, words: NetWords): LabelRead[] => {
+  const rest = withoutPeriod(key, { ...period, pattern: keyOf(period.pattern) });
+  const role = rest === undefined || rest === "" ? undefined : roleOfKey(rest, words, true);
+  return role === undefined ? [] : [{ role, period: period.group ?? keyOf(period.pattern) }];
+};
+
+/** The role a label names: the word alone or with a period on its side (前期分の納入額), its note in brackets aside. */
+export const readLabel = (label: string, words: NetWords): LabelRead | undefined => {
+  const key = labelKey(label);
+  const role = roleOfKey(key, words);
+  return role === undefined ? words.periods.flatMap((period) => withPeriodCut(key, period, words))[0] : { role };
+};
+
+export const roleOf = (label: string, words: NetWords): NetRole | undefined => readLabel(label, words)?.role;
+
+/** A note that may name a unit: no digit in it (手付金（契約時100万円支払済） describes), and a magnitude or a currency code. */
+const CURRENCY_CODE = /^[(（]\s*[A-Z]{3}\s*[)）]$/u;
+const DIGIT_IN_NOTE = /\d/u;
+
+/**
+ * The part of a label's note that is a unit. An amount without marks takes its unit from the note (総支給額（千円）). An
+ * amount with its own mark keeps only a note naming a magnitude or a currency (Gross pay ($ million), Net pay (USD)); any
+ * other note says what the amount is (手付金（契約時にお支払い済み）, Loan proceeds (from the buyer's lender)) and is not its unit.
+ */
+const unitNote = (marks: string, labelNote: string, words: Pick<NetWords, "magnitudes">): string => {
+  const note = keyOf(labelNote);
+  if (marks === "") return note;
+  const raw = labelNote.normalize("NFKC").trim();
+  const namesUnit = CURRENCY_CODE.test(raw) || words.magnitudes.some((word) => note.includes(keyOf(word)));
+  return namesUnit && !DIGIT_IN_NOTE.test(raw) ? note : "";
+};
+
+/** One plain number with its marks ("256,287円", "$4,301.01"); a percentage, a signed or a bracketed value is not an amount. */
+export const amountOf = (text: string, start: number, labelNote: string, words: Pick<NetWords, "percentUnits" | "magnitudes">): NetAmount | undefined => {
+  const cell = readNumber(text);
+  if (cell === undefined || words.percentUnits.some((unit) => keyOf(unit) === keyOf(cell.suffix))) return undefined;
+  const [prefix, suffix] = [keyOf(cell.prefix), keyOf(cell.suffix)];
+  const unit = `${prefix}|${suffix}|${unitNote(prefix + suffix, labelNote, words)}`;
+  return { start, value: cell.value, decimals: cell.decimals, prefix, suffix, unit, written: text.trim(), grouped: text.normalize("NFKC").includes(",") };
+};
+
+/** The one value of a role: all its amounts the same value in the same unit; undefined when there is none or they differ. */
+const onlyAmount = (amounts: readonly LabelledAmount[], role: NetRole): LabelledAmount | undefined => {
+  const mine = amounts.filter((amount) => amount.role === role);
+  const [first] = mine;
+  if (first === undefined) return undefined;
+  return mine.every((amount) => amount.value === first.value && amount.unit === first.unit) ? (mine.at(-1) ?? first) : undefined;
+};
+
+/** The parts of the deductions added up: one value per label (手付金 and 融資金), all in one unit; undefined otherwise. */
+const partsTotal = (amounts: readonly LabelledAmount[]): LabelledAmount | undefined => {
+  const parts = amounts.filter((amount) => amount.role === "deduction-part");
+  const labels = [...new Set(parts.map((amount) => amount.label ?? ""))];
+  const perLabel = labels.map((label) =>
+    onlyAmount(
+      parts.filter((amount) => (amount.label ?? "") === label),
+      "deduction-part",
+    ),
+  );
+  const values = perLabel.filter((amount): amount is LabelledAmount => amount !== undefined);
+  const [first] = values;
+  if (first === undefined || values.length !== perLabel.length || values.some((value) => value.unit !== first.unit)) return undefined;
+  const value = values.reduce((total, part) => total + part.value, 0);
+  return { ...first, value, decimals: Math.max(...values.map((part) => part.decimals)) };
+};
+
+/**
+ * What is taken off the gross: the total of deductions when the scope names one (控除合計), so parts written beside it are
+ * not counted twice; otherwise the parts added up (売買代金 − 手付金 − 融資金 = 残代金).
+ */
+const deductionOf = (amounts: readonly LabelledAmount[]): LabelledAmount | undefined =>
+  amounts.some((amount) => amount.role === "deduction") ? onlyAmount(amounts, "deduction") : partsTotal(amounts);
+
+/**
+ * The amount gross minus deductions is compared with: the net, or the taxable amount when the scope names no net. A scope
+ * that names both is a payslip whose deductions are what is paid out, not what tax is figured on, so its taxable amount
+ * is not compared.
+ */
+const resultOf = (amounts: readonly LabelledAmount[], netNamed: boolean): LabelledAmount | undefined => onlyAmount(amounts, netNamed ? "net" : "taxable");
+
+/** A mark of currency and no word of magnitude: the amount is exact. Anything else may be rounded to its last digit. */
+export const isExact = (amount: NetAmount, words: Pick<NetWords, "magnitudes">): boolean =>
+  amount.prefix + amount.suffix !== "" && !words.magnitudes.some((word) => `${amount.prefix} ${amount.suffix}`.includes(keyOf(word)));
+
+/**
+ * How far the written net may be from gross minus deductions. Exact amounts must agree to their last digit. Rounded ones
+ * (千円, $ million, a bare number whose unit is in a heading) may be off by one step of the coarsest last digit: each of
+ * the three is rounded on its own, and a difference of one step is what rounding down or to nearest can leave.
+ */
+export const allowedGap = (amounts: readonly NetAmount[], words: NetWords): number => {
+  const finest = Math.max(...amounts.map((amount) => amount.decimals));
+  const coarsest = Math.min(...amounts.map((amount) => amount.decimals));
+  return amounts.every((amount) => isExact(amount, words)) ? HALF * DECIMAL_BASE ** -finest : DECIMAL_BASE ** -coarsest + HALF * DECIMAL_BASE ** -finest;
+};
+
+const DIGIT = /\p{Nd}/u;
+const FULL_WIDTH_DIGIT = /[０-９]/u;
+/** The distance from an ASCII digit, comma or point to its full-width form (0 → ０, , → ，). */
+const FULL_WIDTH_OFFSET = 0xfee0;
+
+const toFullWidth = (number: string): string => [...number].map((char) => String.fromCodePoint((char.codePointAt(0) ?? 0) + FULL_WIDTH_OFFSET)).join("");
+
+/** The expected net, written the way the net is: the marks around its number, its digits, its decimals, its grouping. */
+export const shown = (value: number, like: NetAmount, decimals: number): string => {
+  const ascii = value.toLocaleString("en-US", { minimumFractionDigits: decimals, maximumFractionDigits: decimals, useGrouping: like.grouped });
+  const number = FULL_WIDTH_DIGIT.test(like.written) ? toFullWidth(ascii) : ascii;
+  const digits = [...like.written].flatMap((char, index) => (DIGIT.test(char) ? [index] : []));
+  const [first = 0, last = like.written.length - 1] = [digits[0], digits.at(-1)];
+  return `${like.written.slice(0, first)}${number}${like.written.slice(last + 1)}`;
+};
+
+/**
+ * One scope (a table column, a table row, a section's labelled lines): gross, deductions and net (or taxable) each found,
+ * each with one value, all in one unit. The net is reported when it is not gross minus deductions beyond rounding.
+ * netNamed is whether the scope has a net label, even one whose value is not a plain amount (a net written as —).
+ */
+export const netMismatch = (
+  amounts: readonly LabelledAmount[],
+  words: NetWords,
+  netNamed = amounts.some((amount) => amount.role === "net"),
+): NetIssue | undefined => {
+  const [gross, deduction, net] = [onlyAmount(amounts, "gross"), deductionOf(amounts), resultOf(amounts, netNamed)];
+  if (gross === undefined || deduction === undefined || net === undefined) return undefined;
+  if (new Set([gross, deduction, net].flatMap((amount) => amount.period ?? [])).size > 1) return undefined;
+  if (gross.unit !== deduction.unit || gross.unit !== net.unit) return undefined;
+  const expected = gross.value - deduction.value;
+  if (!Number.isSafeInteger(Math.round(gross.value * DECIMAL_BASE ** gross.decimals))) return undefined;
+  if (expected < 0 || Math.abs(expected - net.value) <= allowedGap([gross, deduction, net], words)) return undefined;
+  const decimals = Math.max(gross.decimals, deduction.decimals, net.decimals);
+  return { offset: net.start, values: { written: net.written, expected: shown(expected, net, decimals) } };
+};
+
+/** A table line read as its cells, each without its edge marks, by where it starts. */
+export type NetCell = { readonly start: number; readonly text: string };
+
+const namesNet = (labels: readonly NetCell[], words: NetWords): boolean => labels.some((label) => roleOf(label.text, words) === "net");
+const labelCellsOf = (lines: readonly LabelledLine[]): NetCell[] => lines.map((line) => ({ start: 0, text: line.label }));
+
+const labelledCells = (labels: readonly NetCell[], values: readonly NetCell[], words: NetWords): LabelledAmount[] =>
+  labels.flatMap((label, column) => {
+    const read = readLabel(label.text, words);
+    const value = values[column];
+    const amount = read === undefined || value === undefined ? undefined : amountOf(value.text, value.start, noteOf(label.text), words);
+    return read === undefined || amount === undefined ? [] : [{ ...amount, ...read, label: labelKey(label.text) }];
+  });
+
+/** A table whose header names the three columns: each body row of the same width is one scope. */
+const byColumns = (header: readonly NetCell[], rows: readonly (readonly NetCell[])[], words: NetWords): NetIssue[] =>
+  rows.flatMap((row) => {
+    if (row.length !== header.length) return [];
+    const issue = netMismatch(labelledCells(header, row, words), words, namesNet(header, words));
+    return issue === undefined ? [] : [issue];
+  });
+
+/** A table whose rows are labelled in their first cell: each column after the labels is one scope. */
+const byRows = (rows: readonly (readonly NetCell[])[], words: NetWords): NetIssue[] => {
+  const labelled = rows.filter((row) => row[0] !== undefined && roleOf(row[0].text, words) !== undefined);
+  const width = labelled[0]?.length ?? 0;
+  if (labelled.length === 0 || labelled.some((row) => row.length !== width)) return [];
+  return Array.from({ length: width - 1 }, (_, index) => index + 1).flatMap((column) => {
+    const amounts = labelled.flatMap((row) => labelledCells([row[0] ?? { start: 0, text: "" }], [row[column] ?? { start: 0, text: "" }], words));
+    const issue = netMismatch(
+      amounts,
+      words,
+      namesNet(
+        labelled.flatMap((row) => row.slice(0, 1)),
+        words,
+      ),
+    );
+    return issue === undefined ? [] : [issue];
+  });
+};
+
+/** One table, read both ways: its header naming the columns, and its first column naming the rows. */
+export const tableNetMismatches = (header: readonly NetCell[], rows: readonly (readonly NetCell[])[], words: NetWords): NetIssue[] => {
+  const issues = [...byColumns(header, rows, words), ...byRows(rows, words)];
+  return issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
+};
+
+/** A line that is a label and its amount (総支給額：117,380円, - Net pay: $1,396.41). */
+export type LabelledLine = { readonly label: string; readonly value: NetCell };
+
+/** The labelled lines of one section: each label that names a role, with its amount. */
+export const sectionNetMismatch = (lines: readonly LabelledLine[], words: NetWords): NetIssue | undefined =>
+  netMismatch(
+    lines.flatMap((line) => labelledCells([{ start: 0, text: line.label }], [line.value], words)),
+    words,
+    namesNet(labelCellsOf(lines), words),
+  );

package/src/structure/net-gross-weight.ts

@@ -0,0 +1,97 @@
+// net-over-gross: one row of a weight table (a packing list) with the net weight (the goods alone) and the gross weight
+// (with the packing), each in a column its heading words name. Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { bodyRows, offsetOf, sameUnit } from "./order-quantity.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+export type WeightRole = "net" | "gross";
+export type WeightWord = { readonly pattern: string; readonly role: WeightRole };
+export type MassUnit = { readonly pattern: string; readonly factor: number };
+/** The heading words of each column, the words after a number that make it no exact weight (以上, "or more"), and the mass units. */
+export type WeightWords = { readonly columns: readonly WeightWord[]; readonly qualifiers: readonly string[]; readonly units: readonly MassUnit[] };
+export type WeightColumns = { readonly net: number; readonly gross: number };
+
+const ROLES: readonly WeightRole[] = ["net", "gross"];
+const LATIN = /[a-z]/u;
+/** Spaces and punctuation: "Net wt." beside "Gross weight", 「正味重量（kg）」 beside "総重量 (kg)" say the same besides. */
+const SPACES_AND_MARKS = /[\s\p{P}]+/gu;
+/** Converted weights are compared to this many decimal places, so 0.1 kg and 100 g are one weight. */
+const COMPARE_DECIMALS = 6;
+
+const wordsHeld = (key: string, words: readonly WeightWord[], role: WeightRole): WeightWord[] =>
+  words.filter((word) => word.role === role && holds(key, word.pattern));
+
+export const withoutWord = (key: string, word: string): string => {
+  const written = plain(word).toLowerCase();
+  if (!LATIN.test(written)) return key.replaceAll(written, "");
+  return key.replace(new RegExp(`(?<![a-z0-9])${escapeRegExp(written)}(?![a-z0-9])`, "gu"), "");
+};
+
+type Heading = { readonly role: WeightRole; readonly rest: string };
+
+/**
+ * The role a heading names, and what it says besides ("(kg)", "per carton"). A heading naming both ("Net / Gross weight")
+ * keeps the other role's word besides, so it never pairs with a heading of the other role.
+ */
+const headingOf = (heading: string, words: readonly WeightWord[]): Heading | undefined => {
+  const key = plain(heading).toLowerCase();
+  const role = ROLES.find((candidate) => wordsHeld(key, words, candidate).length > 0);
+  if (role === undefined) return undefined;
+  const rest = wordsHeld(key, words, role).reduce((left, word) => withoutWord(left, word.pattern), key);
+  return { role, rest: rest.replace(SPACES_AND_MARKS, "") };
+};
+
+/**
+ * The one net and the one gross column. A table with two of either, or whose two headings say different things besides
+ * net and gross ("Net weight per piece" beside "Gross weight per carton"), is not read.
+ */
+export const weightColumnsOf = (headings: readonly string[], words: readonly WeightWord[]): WeightColumns | undefined => {
+  const read = headings.map((heading) => headingOf(heading, words));
+  const all = (role: WeightRole): number[] => read.flatMap((found, index) => (found?.role === role ? [index] : []));
+  const [net, gross] = [all("net"), all("gross")];
+  const [netIndex, grossIndex] = [net[0], gross[0]];
+  if (net.length !== 1 || gross.length !== 1 || netIndex === undefined || grossIndex === undefined) return undefined;
+  const [netHeading, grossHeading] = [read[netIndex], read[grossIndex]];
+  if (netHeading === undefined || grossHeading === undefined || netHeading.rest !== grossHeading.rest) return undefined;
+  return { net: netIndex, gross: grossIndex };
+};
+
+type Weight = { readonly value: number; readonly unit: string; readonly cell: TableCell };
+
+/** A plain weight: a number with what is written after it (kg), no sign, bracket or word before it, and no bound after it. */
+const weightIn = (cell: TableCell | undefined, qualifiers: readonly string[]): Weight | undefined => {
+  const value = cell === undefined ? undefined : valueIn(cell.text);
+  if (cell === undefined || value === undefined) return undefined;
+  const [before = "", after = ""] = value.marks.split("|");
+  const unit = after.toLowerCase();
+  if (before !== "" || qualifiers.some((word) => holds(unit, word))) return undefined;
+  return { value: value.value, unit, cell };
+};
+
+const factorOf = (unit: string, units: readonly MassUnit[]): number | undefined => units.find((known) => known.pattern.toLowerCase() === unit)?.factor;
+
+const rounded = (value: number): number => Number(value.toFixed(COMPARE_DECIMALS));
+
+/** Net larger than gross: in one unit as written, or both converted by the mass units (g, kg, t). Undefined when they cannot be compared. */
+const netExceeds = (net: Weight, gross: Weight, units: readonly MassUnit[]): boolean | undefined => {
+  if (sameUnit(net.unit, gross.unit)) return net.value > gross.value;
+  const [netFactor, grossFactor] = [factorOf(net.unit, units), factorOf(gross.unit, units)];
+  if (netFactor === undefined || grossFactor === undefined) return undefined;
+  return rounded(net.value * netFactor) > rounded(gross.value * grossFactor);
+};
+
+/** Each row (the totals row too) whose net weight is larger than its gross weight. */
+export const netOverGross = (tables: readonly ChangeTable[], words: WeightWords): StructureIssue[] =>
+  tables.flatMap((table) => {
+    const columns = weightColumnsOf(
+      table.header.map((cell) => cell.text),
+      words.columns,
+    );
+    if (columns === undefined) return [];
+    return bodyRows(table).flatMap((row) => {
+      const [net, gross] = [weightIn(row[columns.net], words.qualifiers), weightIn(row[columns.gross], words.qualifiers)];
+      if (net === undefined || gross === undefined || netExceeds(net, gross, words.units) !== true) return [];
+      return [{ offset: offsetOf(net.cell), values: { net: plain(net.cell.text), gross: plain(gross.cell.text) } }];
+    });
+  });

package/src/structure/order-quantity.ts

@@ -0,0 +1,125 @@
+// delivered-over-ordered and backorder-mismatch: one row of a quantity table (a delivery note, a backorder list) with the
+// ordered, delivered and backordered quantities, each in a column its heading words name. Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+
+export type QuantityRole = "ordered" | "delivered" | "backordered";
+export type QuantityWord = { readonly pattern: string; readonly role: QuantityRole };
+export type QuantityColumns = { readonly ordered: number; readonly delivered: number; readonly backordered?: number };
+/** The heading words of each column, and the words after a number that make it no exact count (以上, "or more"). */
+export type QuantityWords = { readonly columns: readonly QuantityWord[]; readonly qualifiers: readonly string[] };
+
+/** Backordered first: 「発注残」 holds 発注 and 「未納品数」 holds 納品数, "Back ordered" holds "ordered", and both are what is left. */
+const ROLE_ORDER: readonly QuantityRole[] = ["backordered", "delivered", "ordered"];
+
+/** A heading that names both ordered and delivered ("Ordered / Delivered") says neither: it is no column to read. */
+const BOTH = "both";
+
+export const roleOf = (heading: string, words: readonly QuantityWord[]): QuantityRole | typeof BOTH | undefined => {
+  const key = plain(heading).toLowerCase();
+  const named = ROLE_ORDER.filter((role) => words.some((word) => word.role === role && holds(key, word.pattern)));
+  if (!named.includes("backordered") && named.includes("delivered") && named.includes("ordered")) return BOTH;
+  return named[0];
+};
+
+/**
+ * The one ordered and the one delivered column, and the one backordered column when there is one. Two delivered columns
+ * (前回 and 今回, "Previously" and "Now") say neither alone what is left, so a table with two is not read.
+ */
+export const quantityColumnsOf = (headings: readonly string[], words: readonly QuantityWord[]): QuantityColumns | undefined => {
+  const roles = headings.map((heading) => roleOf(heading, words));
+  const all = (role: QuantityRole): number[] => roles.flatMap((found, index) => (found === role ? [index] : []));
+  const [ordered, delivered, backordered] = [all("ordered"), all("delivered"), all("backordered")];
+  if (roles.includes(BOTH) || ordered.length !== 1 || delivered.length !== 1 || backordered.length > 1) return undefined;
+  const [orderedIndex = 0, deliveredIndex = 0] = [ordered[0], delivered[0]];
+  return { ordered: orderedIndex, delivered: deliveredIndex, ...(backordered[0] === undefined ? {} : { backordered: backordered[0] }) };
+};
+
+type Count = { readonly value: number; readonly unit: string; readonly cell: TableCell };
+
+/**
+ * A plain count: a whole number with what is written after it (冊, boxes), no sign, bracket, decimals or mark before it,
+ * and no word after it that makes it a bound or a guess (10以上, "12 or more").
+ */
+const countIn = (cell: TableCell | undefined, qualifiers: readonly string[]): Count | undefined => {
+  const value = cell === undefined ? undefined : valueIn(cell.text);
+  if (cell === undefined || value === undefined || value.step !== 1) return undefined;
+  const [before = "", after = ""] = value.marks.split("|");
+  const unit = after.toLowerCase();
+  if (before !== "" || qualifiers.some((word) => holds(unit, word))) return undefined;
+  return { value: value.value, unit, cell };
+};
+
+/** The plural forms of an English unit: "reams", "boxes", "copies". */
+const pluralsOf = (unit: string): string[] => [
+  `${unit}s`,
+  ...(/(?:s|x|z|ch|sh|o)$/u.test(unit) ? [`${unit}es`] : []),
+  ...(/[^aeiou]y$/u.test(unit) ? [`${unit.slice(0, -1)}ies`] : []),
+];
+
+/** One unit, written singular or plural: "box" and "boxes", "copy" and "copies". */
+export const sameUnit = (left: string, right: string): boolean => left === right || pluralsOf(left).includes(right) || pluralsOf(right).includes(left);
+
+export const offsetOf = (cell: TableCell): number => cell.start + (cell.text.length - cell.text.trimStart().length);
+
+/** The counts of a row's columns, when every one is a count in one unit; undefined when any cell says something else. */
+const countsOf = (row: readonly TableCell[], indexes: readonly number[], qualifiers: readonly string[]): Count[] | undefined => {
+  const counts = indexes.map((index) => countIn(row[index], qualifiers));
+  const read = counts.flatMap((count) => (count === undefined ? [] : [count]));
+  const [first] = read;
+  if (read.length !== indexes.length || first === undefined || !read.every((count) => sameUnit(count.unit, first.unit))) return undefined;
+  return read;
+};
+
+export const bodyRows = (table: ChangeTable): (readonly TableCell[])[] => table.rows.filter((row) => row.length === table.header.length);
+
+const columnsOfTable = (table: ChangeTable, words: QuantityWords): QuantityColumns | undefined =>
+  quantityColumnsOf(
+    table.header.map((cell) => cell.text),
+    words.columns,
+  );
+
+/** Each row whose delivered quantity is larger than its ordered quantity. */
+export const deliveredOverOrdered = (tables: readonly ChangeTable[], words: QuantityWords): StructureIssue[] =>
+  tables.flatMap((table) => {
+    const columns = columnsOfTable(table, words);
+    if (columns === undefined) return [];
+    return bodyRows(table).flatMap((row) => {
+      const [ordered, delivered] = countsOf(row, [columns.ordered, columns.delivered], words.qualifiers) ?? [];
+      if (ordered === undefined || delivered === undefined || delivered.value <= ordered.value) return [];
+      return [{ offset: offsetOf(delivered.cell), values: { delivered: plain(delivered.cell.text), ordered: plain(ordered.cell.text) } }];
+    });
+  });
+
+/** The expected count written the way the backordered cell writes its own: thousands commas and the unit after it. */
+const shownCount = (value: number, written: Count): string => {
+  const text = plain(written.cell.text);
+  return text.replace(/^[\d,]+/u, value.toLocaleString("en-US", { useGrouping: text.includes(",") }));
+};
+
+/** Another column of the row holds a count in the same unit (opening stock, previously delivered): the remainder may count it too. */
+const countsElsewhere = (row: readonly TableCell[], used: readonly number[], unit: string, qualifiers: readonly string[]): boolean =>
+  row.some((cell, index) => {
+    const count = used.includes(index) ? undefined : countIn(cell, qualifiers);
+    return count !== undefined && sameUnit(count.unit, unit);
+  });
+
+/**
+ * Each row whose backordered quantity is not the ordered less the delivered. A row that delivered more than was ordered is
+ * left to delivered-over-ordered: what is left of it is no count.
+ */
+export const backorderMismatches = (tables: readonly ChangeTable[], words: QuantityWords): StructureIssue[] =>
+  tables.flatMap((table) => {
+    const columns = columnsOfTable(table, words);
+    if (columns?.backordered === undefined) return [];
+    const backorderedColumn = columns.backordered;
+    return bodyRows(table).flatMap((row) => {
+      const used = [columns.ordered, columns.delivered, backorderedColumn];
+      const [ordered, delivered, backordered] = countsOf(row, used, words.qualifiers) ?? [];
+      if (ordered === undefined || delivered === undefined || backordered === undefined || delivered.value > ordered.value) return [];
+      if (countsElsewhere(row, used, ordered.unit, words.qualifiers)) return [];
+      const expected = ordered.value - delivered.value;
+      if (backordered.value === expected) return [];
+      return [{ offset: offsetOf(backordered.cell), values: { backordered: plain(backordered.cell.text), computed: shownCount(expected, backordered) } }];
+    });
+  });

package/src/structure/party-role.ts

@@ -1,4 +1,5 @@
 import type { BodyText, DefinedTerm } from "./definition-use.ts";
+import { isGenericPlural } from "./generic-role.ts";
 
 /**
  * 当事者を、定めた呼び名でなく立場の語で書いた所（「乙」と定めたあとの「受託者」、the "Supplier" のあとの the Vendor）。
@@ -64,7 +65,9 @@ const CLAUSE_START = /^[\s\d.()*+-]*$/u;
 /** 英語の立場の語は、冠詞か所有の語のあと（the Vendor）か、文の頭の大文字の語だけ。小文字の the vendor は普通の名詞。 */
 const englishRoleAt = (text: BodyText, at: number, role: string): boolean => {
   const before = text.text.slice(0, at);
-  return ENGLISH_ENDING.test(text.text.slice(at + role.length)) && (CLAUSE_START.test(before) || ENGLISH_LEAD.test(before.slice(-LEAD_REACH)));
+  const after = text.text.slice(at + role.length);
+  const bare = CLAUSE_START.test(before);
+  return ENGLISH_ENDING.test(after) && !isGenericPlural(bare, after) && (bare || ENGLISH_LEAD.test(before.slice(-LEAD_REACH)));
 };
 
 const standsAlone = (source: string, text: BodyText, at: number, role: string): boolean => {

package/src/structure/percent-sum.ts

@@ -16,6 +16,8 @@ export type ShareWords = {
   readonly columnLabels?: readonly string[];
   /** 行ごとの率を名指す語（前年比、達成率、growth）。表の上の文にあれば、columnLabels の列は足さない。 */
   readonly rates?: readonly string[];
+  /** 列の見出しの升にだけ効く、行ごとの率の語（還元率、Discount）。見出しでは rates の語も同じに読む。 */
+  readonly headerRates?: readonly string[];
   /** 足しても 100% にならない集計（複数回答）。 */
   readonly exceptions: readonly string[];
   /** 全体の残りを名指す語（その他、other）。一つの文の百分率のすぐ前にあれば、その文は内訳。 */
@@ -112,6 +114,7 @@ type Named = { readonly header: readonly string[]; readonly above: string; reado
 const namesShares = (named: Named, column: number, percentColumns: number, words: ShareWords): boolean => {
   const header = named.header[column] ?? "";
   if (named.header.length > 0 && includesAny(header, words.labels)) return true;
+  if (mentionsAny(header, [...(words.rates ?? []), ...(words.headerRates ?? [])])) return false;
   if (isShareColumn(header, words.columnLabels ?? []) && !mentionsAny(`${named.above} ${named.rows}`, words.rates ?? [])) return true;
   return (named.header.length === 0 || percentColumns === 1) && includesAny(named.above, words.labels);
 };