chaffjs 0.30.0 → 0.32.0

package/src/structure/scaled-quantities.ts

@@ -0,0 +1,239 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { measuredValues, type MeasureUnit } from "../facts/measures.ts";
+import { hasSuperscriptPower } from "../facts/superscript-power.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf, type Line } from "./lines.ts";
+import type { Mark } from "./time-marks.ts";
+
+/**
+ * A table with one column per number of servings or batch size (4人分 / 8人分, Serves 4 / Serves 8, ×1 / ×2), and the one
+ * row that does not grow by the columns' ratio while the others do. The words come from the language packages. Pure.
+ */
+export type ScaleWords = {
+  /** What marks a column as a number of servings (人分 after the number, Serves before it). */
+  readonly columns: readonly Mark[];
+  /** An amount that is left to the cook (少々, to taste): its row may stay as it is. */
+  readonly unscaled: readonly string[];
+  /** Spellings of one unit (teaspoon, teaspoons, tsp), each named by its group. */
+  readonly unitForms: readonly { readonly pattern: string; readonly group: string }[];
+  /** Units with a factor to a base unit (g and kg), so 1 kg and 1000 g read as one amount. */
+  readonly measures: readonly MeasureUnit[];
+};
+
+/** amount is in the base unit when the unit has a factor (1 kg is 1000); written is the number as written (1). */
+export type Amount = { readonly amount: number; readonly written: number; readonly unit: string };
+
+export type ScaleSlip = {
+  /** The row's first cell: the item. */
+  readonly item: Cell;
+  /** The cell that does not scale, and the column it is in. */
+  readonly cell: Cell;
+  readonly heading: string;
+  /** The cell it is compared with, and that column. */
+  readonly other: Cell;
+  readonly otherHeading: string;
+  /** What the cell would hold if it scaled like the other rows, in the unit it is written in. */
+  readonly expected: number;
+  readonly scaledRows: number;
+};
+
+/** Fewer rows than this that scale exactly are no evidence that the table scales at all. */
+export const MIN_SCALED_ROWS = 3;
+const SAME = 1e-9;
+const MIN_COLUMNS = 2;
+
+const NUMBER_TEXT = "[0-9]+(?:\\.[0-9]+)?";
+
+/** The number of servings a column heading names (4人分, Serves 8, ×2), or undefined. */
+export const servingsOf = (heading: string, marks: readonly Mark[]): number | undefined => {
+  const text = withoutEdgeMarks(heading.normalize("NFKC").trim()).toLowerCase();
+  const read = marks
+    .map((mark) => {
+      const word = escapeRegExp(mark.pattern.normalize("NFKC").toLowerCase());
+      const pattern = mark.position === "before" ? `^${word}\\s*(${NUMBER_TEXT})$` : `^(${NUMBER_TEXT})\\s*${word}$`;
+      return new RegExp(pattern, "u").exec(text)?.[1];
+    })
+    .find((number) => number !== undefined);
+  const servings = read === undefined ? undefined : Number(read);
+  return servings === undefined || !Number.isFinite(servings) || servings <= 0 ? undefined : servings;
+};
+
+/** A whole or decimal number (1,000 and 1.5), with a fraction after it (1 1/2) or as a fraction (1/2, ½). */
+const WHOLE = String.raw`[0-9]+(?:,[0-9]{3})*(?:\.[0-9]+)?`;
+const FRACTION = String.raw`(?:\s([0-9]+)[/⁄]([0-9]+)|[/⁄]([0-9]+))?`;
+const AMOUNT = new RegExp(String.raw`(?<![\p{N}.,/⁄])(${WHOLE})${FRACTION}(?![\p{N}/⁄])`, "gu");
+
+const valueOf = (match: RegExpMatchArray): number => {
+  const whole = Number((match[1] ?? "").replace(/,/gu, ""));
+  if (match[4] !== undefined) return whole / Number(match[4]);
+  return match[2] === undefined ? whole : whole + Number(match[2]) / Number(match[3]);
+};
+
+const LETTER_BEFORE = "(?<!\\p{L})";
+const LETTER_AFTER = "(?!\\p{L})";
+
+/** The cell's text with its number taken out and each spelling of a unit written as its group: "2 teaspoons" is "#teaspoon". */
+const unitKey = (text: string, numberAt: Span, forms: ScaleWords["unitForms"]): string => {
+  const rest = `${text.slice(0, numberAt.start)}#${text.slice(numberAt.end)}`.toLowerCase();
+  const groups = new Map(forms.map((form) => [form.pattern.toLowerCase(), form.group]));
+  const spellings = [...groups.keys()].filter((pattern) => pattern !== "").toSorted((left, right) => right.length - left.length);
+  const grouped =
+    spellings.length === 0
+      ? rest
+      : rest.replace(
+          new RegExp(`${LETTER_BEFORE}(?:${spellings.map(escapeRegExp).join("|")})${LETTER_AFTER}`, "gu"),
+          (spelling) => `<${groups.get(spelling) ?? spelling}>`,
+        );
+  return grouped.replace(/\s+/gu, "");
+};
+
+/** NFKC writes ½ as 1⁄2, so 1½ would read as 11⁄2: a space keeps the whole number apart (1 1⁄2). */
+const VULGAR_AFTER_DIGIT = /([0-9０-９])([¼½¾⅐-⅞])/gu;
+
+const normalized = (cellText: string): string => withoutEdgeMarks(cellText.replace(VULGAR_AFTER_DIGIT, "$1 $2").normalize("NFKC").trim());
+
+/** The lexicon's units as NFKC writes them (m² and ㎡ are m2), so they match a cell that has been through NFKC. */
+const nfkcMeasures = (measures: readonly MeasureUnit[]): MeasureUnit[] => measures.map((unit) => ({ ...unit, pattern: unit.pattern.normalize("NFKC") }));
+
+/** The cell's first number with a measure unit after it that ends the cell. A digit inside the unit (the 2 of m2) is not a second number. */
+const measuredAmount = (text: string, numbers: readonly RegExpMatchArray[], measures: readonly MeasureUnit[]): Amount | undefined => {
+  const [first] = numbers;
+  const [measured] = measuredValues(text, measures);
+  const factor = measured?.factors[0];
+  if (first === undefined || measured === undefined || factor === undefined) return undefined;
+  if (measured.start !== first.index || measured.end !== text.length) return undefined;
+  const unitStart = measured.end - measured.unit.length;
+  if (numbers.some((number) => number !== first && (number.index ?? 0) < unitStart)) return undefined;
+  return { amount: measured.amount * factor, written: measured.amount, unit: `=${measured.dimension}` };
+};
+
+/** One cell's amount and the unit it is in. undefined when the cell holds no number, or more than one (1と1/2, 2 (300 g), 10³). */
+export const amountOf = (cellText: string, words: ScaleWords): Amount | undefined => {
+  if (hasSuperscriptPower(cellText)) return undefined;
+  const text = normalized(cellText);
+  const numbers = [...text.matchAll(AMOUNT)];
+  const measured = measuredAmount(text, numbers, nfkcMeasures(words.measures));
+  if (measured !== undefined) return measured;
+  const [only] = numbers;
+  if (numbers.length !== 1 || only === undefined) return undefined;
+  const written = valueOf(only);
+  if (!Number.isFinite(written)) return undefined;
+  return { amount: written, written, unit: unitKey(text, { start: only.index, end: only.index + only[0].length }, words.unitForms) };
+};
+
+const isUnscaled = (text: string, unscaled: readonly string[]): boolean => {
+  const lower = text.normalize("NFKC").toLowerCase();
+  return unscaled.some((word) => word !== "" && lower.includes(word.normalize("NFKC").toLowerCase()));
+};
+
+type Column = { readonly index: number; readonly servings: number; readonly heading: string };
+
+type Row = { readonly item: Cell; readonly cells: readonly Cell[] };
+
+/** The rows of one table whose item is named, as cells. */
+const rowsOf = (rows: readonly Line[]): Row[] =>
+  rows.flatMap((line) => {
+    const cells = cellsOf(line);
+    const [item] = cells;
+    return item === undefined || withoutEdgeMarks(item.text) === "" ? [] : [{ item, cells }];
+  });
+
+type Pair = {
+  readonly row: Row;
+  readonly baseCell: Cell;
+  readonly cell: Cell;
+  readonly from: Amount;
+  readonly to: Amount;
+  readonly scales: boolean;
+};
+
+/** Each row's two cells, when both are amounts in one unit and the row is not left to the cook. */
+const readablePairs = (rows: readonly Row[], base: Column, other: Column, words: ScaleWords): Pair[] =>
+  rows.flatMap((row): Pair[] => {
+    const [baseCell, cell] = [row.cells[base.index], row.cells[other.index]];
+    if (baseCell === undefined || cell === undefined) return [];
+    if (isUnscaled(baseCell.text, words.unscaled) || isUnscaled(cell.text, words.unscaled)) return [];
+    const [from, to] = [amountOf(baseCell.text, words), amountOf(cell.text, words)];
+    if (from === undefined || to === undefined || from.unit !== to.unit) return [];
+    const scaled = (from.amount * other.servings) / base.servings;
+    return [{ row, baseCell, cell, from, to, scales: Math.abs(to.amount - scaled) <= SAME * Math.max(Math.abs(scaled), 1) }];
+  });
+
+type Departure = { readonly pair: Pair; readonly scaled: number };
+
+/** The one row of a column that departs from the base column while at least MIN_SCALED_ROWS others scale exactly. */
+const departureOf = (rows: readonly Row[], base: Column, other: Column, words: ScaleWords): Departure | undefined => {
+  const pairs = readablePairs(rows, base, other, words);
+  const departing = pairs.filter((pair) => !pair.scales);
+  const [only] = departing;
+  const scaled = pairs.length - departing.length;
+  return departing.length === 1 && only !== undefined && scaled >= MIN_SCALED_ROWS ? { pair: only, scaled } : undefined;
+};
+
+/** What `amount` would be if it were `ratio` times `from`, in the unit `amount` is written in. */
+export const expectedOf = (from: Amount, amount: Amount, ratio: number): number => {
+  const perWritten = amount.written === 0 || amount.amount === 0 ? 1 : amount.amount / amount.written;
+  return (from.amount * ratio) / perWritten;
+};
+
+const columnSlip = (base: Column, other: Column, { pair, scaled }: Departure): ScaleSlip => ({
+  item: pair.row.item,
+  cell: pair.cell,
+  heading: other.heading,
+  other: pair.baseCell,
+  otherHeading: base.heading,
+  expected: expectedOf(pair.from, pair.to, other.servings / base.servings),
+  scaledRows: scaled,
+});
+
+const baseSlip = (base: Column, other: Column, { pair, scaled }: Departure): ScaleSlip => ({
+  item: pair.row.item,
+  cell: pair.baseCell,
+  heading: base.heading,
+  other: pair.cell,
+  otherHeading: other.heading,
+  expected: expectedOf(pair.to, pair.from, base.servings / other.servings),
+  scaledRows: scaled,
+});
+
+type Found = { readonly other: Column; readonly departure: Departure | undefined };
+
+/** Whether the row's cells outside the first column scale with each other (a row fixed in every column does not). */
+const othersAgree = (found: readonly Found[]): boolean => {
+  const perServing = found.map(({ other, departure }) => (departure === undefined ? Number.NaN : departure.pair.to.amount / other.servings));
+  const [first] = perServing;
+  return first !== undefined && perServing.every((value) => Math.abs(value - first) <= SAME * Math.max(Math.abs(first), 1));
+};
+
+/**
+ * One table's slips. Each column is compared with the first servings column. When the same row departs in every other column
+ * (three or more columns) and those columns scale with each other, it is the first column's cell that is off, and that cell is
+ * reported once; a row that departs everywhere without that (the same amount in every column) may be fixed on purpose.
+ */
+const tableSlips = (columns: readonly Column[], rows: readonly Row[], words: ScaleWords): ScaleSlip[] => {
+  const [base, ...others] = columns;
+  if (base === undefined) return [];
+  const found: Found[] = others.map((other) => ({ other, departure: departureOf(rows, base, other, words) }));
+  const [first] = found;
+  const offRows = new Set(found.map(({ departure }) => departure?.pair.row));
+  if (others.length > 1 && offRows.size === 1 && first?.departure !== undefined) {
+    return othersAgree(found) ? [baseSlip(base, first.other, first.departure)] : [];
+  }
+  return found.flatMap(({ other, departure }) => (departure === undefined ? [] : [columnSlip(base, other, departure)]));
+};
+
+const columnsOf = (header: Line, marks: readonly Mark[]): Column[] =>
+  cellsOf(header).flatMap((cell, index): Column[] => {
+    const servings = index === 0 ? undefined : servingsOf(cell.text, marks);
+    return servings === undefined ? [] : [{ index, servings, heading: withoutEdgeMarks(cell.text.trim()) }];
+  });
+
+/** Every table of the source with two or more servings columns, and the cells in them that do not scale. */
+export const scaleSlips = (source: string, words: ScaleWords): ScaleSlip[] =>
+  tablesOf(linesOf(source)).flatMap((table) => {
+    const columns = columnsOf(table.header, words.columns);
+    const distinct = new Set(columns.map((column) => column.servings));
+    return distinct.size === columns.length && columns.length >= MIN_COLUMNS ? tableSlips(columns, rowsOf(table.rows), words) : [];
+  });

package/src/structure/serial-range.ts

@@ -0,0 +1,52 @@
+// serial-range-reversed: the serial, lot and batch codes that may be one end of a range (A2400〜A1800, SN-1200 to SN-0900),
+// read as the ends structure/amount-range.ts compares, and the ranges a serial label on their line makes ranges of codes. Pure.
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+import type { RangeAmount } from "./amount-range.ts";
+
+/** Fewer digits than this are a section or a grade (A1, B12), not a serial number. */
+const MIN_DIGITS = 3;
+
+/** One to four capital letters, an optional hyphen, the digits; not inside a longer word or number (XA2400, A2400B). */
+const CODE = new RegExp(`(?<![A-Za-zＡ-Ｚａ-ｚ0-9０-９_])([A-ZＡ-Ｚ]{1,4})([-‐－]?)([0-9０-９]{${MIN_DIGITS},})(?![A-Za-zＡ-Ｚａ-ｚ0-9０-９_])`, "gu");
+
+/**
+ * A code as one end of a range: two ends compare only when their letters, their hyphen and their number of digits agree
+ * (A2400 with A1800; not with B0100, A-1800 or A240).
+ */
+const rangeEndOf = (match: RegExpMatchArray): RangeAmount => {
+  const [whole, letters = "", hyphen = "", digits = ""] = match;
+  const offset = match.index ?? 0;
+  const width = digits.length;
+  return {
+    offset,
+    end: offset + whole.length,
+    currency: `${letters.normalize("NFKC")}|${hyphen === "" ? "" : "-"}|${width}`,
+    value: Number(digits.normalize("NFKC")),
+    scale: undefined,
+    position: "after",
+  };
+};
+
+/** The serial-shaped codes in the text, as range ends, in document order. */
+export const serialRangeEnds = (text: string): RangeAmount[] => [...text.matchAll(CODE)].map(rangeEndOf);
+
+/** A number pattern that never matches: a bare number never shares a code's letters (A2400〜1800 is not read). */
+export const NO_BARE_NUMBER = "(?!)";
+
+const LATIN = /^[A-Za-z]/u;
+
+const labelPattern = (label: string): RegExp => {
+  const escaped = escapeRegExp(label.toLowerCase());
+  return new RegExp(LATIN.test(label) ? `(?<![a-z0-9_])${escaped}(?![a-z0-9_])` : escaped, "u");
+};
+
+/** Whether a serial label stands on the line before the range (製造番号：A2400〜A1800, Lots L5240 through L5210). */
+const labelled = (text: string, offset: number, labels: readonly string[]): boolean => {
+  const before = text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset).toLowerCase();
+  return labels.some((label) => labelPattern(label).test(before));
+};
+
+/** The reversed ranges of codes that a serial label on their line names as serial, lot or batch numbers. */
+export const labelledRanges = (text: string, issues: readonly StructureIssue[], labels: readonly string[]): StructureIssue[] =>
+  issues.filter((issue) => labelled(text, issue.offset, labels));

package/src/structure/share-amount.ts

@@ -0,0 +1,206 @@
+// share-amount-mismatch: the amount a patient pays that is not the stated share (3割, 30%) of the total beside it. Two
+// shapes: a table whose headings name the total, the share and the amount, read row by row; and labelled lines
+// (「合計：10,000円」 then 「自己負担額（3割）：3,500円」) in one section, the total above the amount. Pure.
+import type { Line } from "./lines.ts";
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { bodyRows, offsetOf } from "./order-quantity.ts";
+import { taxMatches } from "./tax.ts";
+
+/** base: the total the share is of. share: a share, written as a rate (負担割合 3割) or as the amount (負担額 3,000円). paid: only the amount. */
+export type ShareRole = "base" | "share" | "paid";
+export type ShareWord = { readonly pattern: string; readonly role: ShareRole };
+/** An amount written in this unit may be rounded to this step (円: 10, the 10-yen rounding of a patient's share). */
+export type ShareRounding = { readonly unit: string; readonly step: number };
+export type ShareWords = { readonly labels: readonly ShareWord[]; readonly roundings: readonly ShareRounding[] };
+/** The document's tables, its lines outside tables, and where each heading starts (a section ends there). */
+export type ShareText = { readonly tables: readonly ChangeTable[]; readonly lines: readonly Line[]; readonly headings: readonly number[] };
+
+export type ShareRate = { readonly value: number; readonly written: string };
+export type Money = { readonly value: number; readonly decimals: number; readonly marks: string; readonly offset: number; readonly text: string };
+
+const ROLE_ORDER: readonly ShareRole[] = ["paid", "share", "base"];
+const PERCENT_RATE = /^(\d{1,2}(?:\.\d{1,2})?)\s*%$/u;
+/** 3割 is 30%: the Japanese share written in tenths. */
+const TENTHS_RATE = /^([1-9])\s*割$/u;
+const TENTH = 10;
+const MAX_RATE = 100;
+const CENTS = 100;
+const BRACKETED = /\(([^()]*)\)/gu;
+const NUMBER = /\d[\d,]*(?:\.(\d+))?/u;
+/** A line that is one label and one value: 「合計：10,000円」, "- Your share (30%): $350.00". */
+const SEPARATOR = /[:：]/u;
+const LIST_MARKER = /^\s*(?:[-*+]|\d{1,3}[.)])\s+/u;
+const KEY_VALUE_CELLS = 2;
+
+/** A share written as a rate: 30%, 30 %, 3割. Undefined for anything else, 0 and 100% and more. */
+export const shareRateIn = (text: string): ShareRate | undefined => {
+  const written = plain(text);
+  const percent = PERCENT_RATE.exec(written)?.[1];
+  const tenths = TENTHS_RATE.exec(written)?.[1];
+  const value = percent === undefined ? Number(tenths) * TENTH : Number(percent);
+  return Number.isFinite(value) && value > 0 && value < MAX_RATE ? { value, written } : undefined;
+};
+
+/** A rate written in brackets in a label: 「自己負担額（3割）」, "Your share (30%)". */
+const bracketedRate = (label: string): ShareRate | undefined => {
+  const rates = [...plain(label).matchAll(BRACKETED)].flatMap((match) => {
+    const rate = shareRateIn(match[1] ?? "");
+    return rate === undefined ? [] : [rate];
+  });
+  return rates.length === 1 ? rates[0] : undefined;
+};
+
+const roleOf = (label: string, words: readonly ShareWord[]): ShareRole | undefined => {
+  const key = plain(label).toLowerCase();
+  return ROLE_ORDER.find((role) => words.some((word) => word.role === role && holds(key, word.pattern)));
+};
+
+/** An amount: a number with what is written around it (10,000円, $600.00), not a rate. */
+const moneyIn = (text: string, offset: number): Money | undefined => {
+  const value = valueIn(text);
+  if (value === undefined || shareRateIn(text) !== undefined) return undefined;
+  const decimals = NUMBER.exec(plain(text))?.[1]?.length ?? 0;
+  return { value: value.value, decimals, marks: value.marks, offset, text: plain(text) };
+};
+
+const stepOf = (money: Money, roundings: readonly ShareRounding[]): number | undefined => {
+  const units = money.marks.split("|");
+  return roundings.find((rounding) => units.includes(plain(rounding.unit)))?.step;
+};
+
+/**
+ * Whether the written amount is the rate of the base: rounded down, to nearest or up, to the cent or the unit (the
+ * arithmetic of tax-mismatch), or to the rounding step of its unit.
+ */
+export const shareMatches = (written: number, base: number, rate: number, step: number | undefined): boolean => {
+  const writtenCents = Math.round(written * CENTS);
+  if (taxMatches(writtenCents, base, rate)) return true;
+  if (step === undefined) return false;
+  const stepCents = step * CENTS;
+  return [Math.floor, Math.round, Math.ceil].some((round) => Math.abs(round((base * rate) / stepCents) * stepCents - writtenCents) < 1);
+};
+
+/** The expected amount written the way the amount is: its unit, its grouping, its decimals, rounded to its step. */
+export const shownLike = (money: Money, exact: number, step: number | undefined): string => {
+  const rounded = step === undefined ? exact : Math.round(exact / step) * step;
+  const number = rounded.toLocaleString("en-US", {
+    minimumFractionDigits: money.decimals,
+    maximumFractionDigits: money.decimals,
+    useGrouping: money.text.includes(","),
+  });
+  return money.text.replace(NUMBER, number);
+};
+
+const issueOf = (base: Money, amount: Money, rate: ShareRate, roundings: readonly ShareRounding[]): StructureIssue[] => {
+  const step = stepOf(amount, roundings);
+  if (base.marks !== amount.marks || shareMatches(amount.value, base.value, rate.value, step)) return [];
+  const expected = shownLike(amount, (base.value * rate.value) / MAX_RATE, step);
+  return [{ offset: amount.offset, values: { written: amount.text, expected, rate: rate.written, base: base.text } }];
+};
+
+const onlyOne = <T>(items: readonly T[]): T | undefined => (items.length === 1 ? items[0] : undefined);
+
+type Labelled = { readonly label: string; readonly value: string; readonly offset: number };
+
+const labelledLine = (line: Line): Labelled | undefined => {
+  const at = line.text.search(SEPARATOR);
+  const label = line.text.slice(0, Math.max(at, 0)).replace(LIST_MARKER, "").trim();
+  const after = line.text.slice(at + 1);
+  const value = after.trim();
+  if (at < 0 || label === "" || value === "") return undefined;
+  return { label, value, offset: line.start + at + 1 + after.length - after.trimStart().length };
+};
+
+/** The share rate the document states on lines of their own (「負担割合：3割」, "Patient share: 30%"); undefined when none or two different ones. */
+export const statedRate = (labelled: readonly Labelled[], words: readonly ShareWord[]): ShareRate | undefined => {
+  const rates = labelled.flatMap((line) => {
+    const rate = roleOf(line.label, words) === "share" ? shareRateIn(line.value) : undefined;
+    return rate === undefined ? [] : [rate];
+  });
+  return new Set(rates.map((rate) => rate.value)).size === 1 ? rates[0] : undefined;
+};
+
+type Context = { readonly words: ShareWords; readonly stated: ShareRate | undefined };
+
+/** One row of a table: the total, the one amount, and the rate in the row, else in the amount's heading, else the stated one. */
+const rowIssues = (
+  row: readonly TableCell[],
+  headings: readonly TableCell[],
+  roles: readonly (ShareRole | undefined)[],
+  baseColumn: number,
+  context: Context,
+): StructureIssue[] => {
+  const baseCell = row[baseColumn];
+  const base = baseCell === undefined ? undefined : moneyIn(baseCell.text, offsetOf(baseCell));
+  const at = (role: ShareRole): number[] => roles.flatMap((found, index) => (found === role ? [index] : []));
+  const rowRates = at("share").flatMap((index) => {
+    const rate = shareRateIn(row[index]?.text ?? "");
+    return rate === undefined ? [] : [rate];
+  });
+  const amounts = [...at("share"), ...at("paid")].flatMap((index) => {
+    const cell = row[index];
+    const money = cell === undefined ? undefined : moneyIn(cell.text, offsetOf(cell));
+    return money === undefined ? [] : [{ money, index }];
+  });
+  const amount = onlyOne(amounts);
+  if (base === undefined || amount === undefined || rowRates.length > 1) return [];
+  const rowRate = onlyOne(rowRates);
+  // An amount column named only as a payment (Amount paid) is the share only beside a rate column in the same row.
+  const rate = rowRate ?? (roles[amount.index] === "share" ? (bracketedRate(headings[amount.index]?.text ?? "") ?? context.stated) : undefined);
+  return rate === undefined ? [] : issueOf(base, amount.money, rate, context.words.roundings);
+};
+
+const tableIssues = (table: ChangeTable, context: Context): StructureIssue[] => {
+  const roles = table.header.map((cell) => roleOf(cell.text, context.words.labels));
+  const baseColumn = onlyOne(roles.flatMap((role, index) => (role === "base" ? [index] : [])));
+  if (baseColumn === undefined) return [];
+  return bodyRows(table).flatMap((row) => rowIssues(row, table.header, roles, baseColumn, context));
+};
+
+/** The two-cell rows of a table that names no total column: | 合計 | 10,000円 |. */
+const keyValueRows = (table: ChangeTable, words: readonly ShareWord[]): Labelled[] =>
+  table.header.some((cell) => roleOf(cell.text, words) === "base")
+    ? []
+    : bodyRows(table).flatMap((row) => {
+        const [label, value] = row;
+        return row.length === KEY_VALUE_CELLS && label !== undefined && value !== undefined
+          ? [{ label: label.text, value: value.text, offset: offsetOf(value) }]
+          : [];
+      });
+
+const sectionOf = (offset: number, headings: readonly number[]): number => headings.filter((start) => start <= offset).length;
+
+/** Labelled lines of one section: the one total, and below it the one amount named as a share. */
+const sectionIssues = (section: readonly Labelled[], context: Context): StructureIssue[] => {
+  const moneyOf = (line: Labelled): Money | undefined => moneyIn(line.value, line.offset);
+  const bases = section.filter((line) => roleOf(line.label, context.words.labels) === "base" && moneyOf(line) !== undefined);
+  const amounts = section.filter((line) => roleOf(line.label, context.words.labels) === "share" && moneyOf(line) !== undefined);
+  const [baseLine, amountLine] = [onlyOne(bases), onlyOne(amounts)];
+  if (baseLine === undefined || amountLine === undefined || baseLine.offset > amountLine.offset) return [];
+  const [base, amount] = [moneyOf(baseLine), moneyOf(amountLine)];
+  const rate = bracketedRate(amountLine.label) ?? context.stated;
+  return base === undefined || amount === undefined || rate === undefined ? [] : issueOf(base, amount, rate, context.words.roundings);
+};
+
+const labelledIssues = (labelled: readonly Labelled[], headings: readonly number[], context: Context): StructureIssue[] => {
+  const sections = [...new Set(labelled.map((line) => sectionOf(line.offset, headings)))];
+  return sections.flatMap((section) =>
+    sectionIssues(
+      labelled.filter((line) => sectionOf(line.offset, headings) === section),
+      context,
+    ),
+  );
+};
+
+/** Each amount charged as a share that is not that share of the total beside it. */
+export const shareAmountMismatches = (text: ShareText, words: ShareWords): StructureIssue[] => {
+  if (words.labels.length === 0) return [];
+  const lines = text.lines.flatMap((line) => labelledLine(line) ?? []);
+  const rows = text.tables.flatMap((table) => keyValueRows(table, words.labels));
+  const labelled = [...lines, ...rows].toSorted((left, right) => left.offset - right.offset);
+  const context = { words, stated: statedRate(labelled, words.labels) };
+  return [...text.tables.flatMap((table) => tableIssues(table, context)), ...labelledIssues(labelled, text.headings, context)].toSorted(
+    (left, right) => left.offset - right.offset,
+  );
+};

package/src/structure/shift-times.ts

@@ -0,0 +1,136 @@
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import { linesOf } from "./lines.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { isReversed, rangeReading } from "./time-range.ts";
+import { dayShiftOf, wordOffsets, type Mark, type TimeSpan, type TimeWords } from "./time-marks.ts";
+
+/**
+ * 勤務表のように、始まりと終わりの時刻を別の列に書いた表（始業 | 終業、Start | End）。列は見出しの名前で読む（語彙表 shift-column の
+ * 組 start、end、hours、break）。行の終わりが始まりより前なら、どちらかの書き間違いか夜をまたぐ勤務。
+ * 文書に夜をまたぐ勤務の印（夜勤、night shift、翌 6:00、24 時を超える時刻）があれば言わない。両方に同じ午前・午後を書いた行は書き間違い。
+ * 実働の列があれば、夜をまたいで読んだ長さ（と、十二時間制で読んだ長さ）が実働と合わず、戻りが半日未満の行だけを言う。
+ * 実働が読めなければ、文の中の範囲と同じく打ち間違いの幅の戻りだけを言う。
+ */
+
+const MINUTES_PER_HOUR = 60;
+const SECONDS_PER_MINUTE = 60;
+const MINUTES_PER_DAY = 24 * MINUTES_PER_HOUR;
+const MINUTES_PER_HALF_DAY = 12 * MINUTES_PER_HOUR;
+const SECONDS_PER_HALF_DAY = MINUTES_PER_HALF_DAY * SECONDS_PER_MINUTE;
+/** 実働を小数の時間で書いたときの丸め（8.33 は 499.8 分）。 */
+const ROUNDING_MINUTES = 3;
+/** 翌日の印（「翌日 」）を探す、時刻の前の字数。 */
+const DAY_SHIFT_LOOK_BACK = 4;
+
+export type ShiftSide = "start" | "end" | "hours" | "break";
+
+export type ShiftInputs = {
+  readonly source: string;
+  readonly times: readonly TimeSpan[];
+  /** 列の見出しの名前。group が start、end、hours、break のどれか。 */
+  readonly columns: readonly Mark[];
+  /** 文書に夜をまたぐ勤務の印があるか。 */
+  readonly overnight: boolean;
+  /** 升に書いた長さ（8.0時間、1:00、8.00）を分で。読めなければ undefined。cellMinutes で読む。 */
+  readonly lengthOf: (text: string) => number | undefined;
+};
+
+/** 見出しの升の後ろの括弧書き（「始業（時刻）」「Start (local)」）。列の名前はその前まで。 */
+const NOTE_OPENER = /[(（[［]/u;
+
+const columnName = (heading: string): string => {
+  const note = heading.search(NOTE_OPENER);
+  return (note === -1 ? heading : heading.slice(0, note)).trim().toLowerCase();
+};
+
+/** 見出しに括弧書きがあるか（「休憩（分）」「Hours (decimal)」）。単位を書き添えた列の、単位の無い数は時間と読まない。 */
+export const hasHeadingNote = (heading: string): boolean => NOTE_OPENER.test(heading);
+
+const CLOCK_LENGTH = /^(\d{1,2}):([0-5]\d)$/u;
+const BARE_HOURS = /^\d{1,2}(?:\.\d{1,2})?$/u;
+
+/**
+ * 升に書いた長さを分で。単位付き（8.0時間、9時間30分、8 hours）、時と分（1:00）、bareHours なら単位の無い時間（8.00）も。
+ * lengths はその升の文字列から読んだ時間の長さ。
+ */
+export const cellMinutes = (text: string, lengths: readonly (Span & { readonly minutes: number })[], bareHours: boolean): number | undefined => {
+  const only = lengths.length === 1 ? lengths[0] : undefined;
+  if (only !== undefined) return only.start === 0 && only.end === text.length ? only.minutes : undefined;
+  const clock = CLOCK_LENGTH.exec(text);
+  if (clock !== null) return Number(clock[1]) * MINUTES_PER_HOUR + Number(clock[2]);
+  return bareHours && BARE_HOURS.test(text) ? Number(text) * MINUTES_PER_HOUR : undefined;
+};
+
+export const columnOf = (header: readonly Cell[], columns: readonly Mark[], side: ShiftSide): number =>
+  header.findIndex((cell) => columns.some((mark) => mark.group === side && mark.pattern.toLowerCase() === columnName(cell.text)));
+
+/** 升に時刻だけを書いたときの、その時刻。 */
+export const onlyTime = (cell: Cell | undefined, times: readonly TimeSpan[], source: string): TimeSpan | undefined => {
+  if (cell === undefined) return undefined;
+  const within = times.filter((time) => time.start >= cell.start && time.end <= cell.end);
+  const only = within.length === 1 ? within[0] : undefined;
+  return only !== undefined && source.slice(only.start, only.end) === cell.text.trim() ? only : undefined;
+};
+
+type Row = { readonly start: TimeSpan; readonly end: TimeSpan; readonly hours: number | undefined; readonly break: number | undefined };
+
+/** 実働と休憩から見て、夜をまたぐ勤務でも十二時間制の書き方でもない行か。 */
+const hoursContradictOvernight = (row: Row, hours: number, rest: number): boolean => {
+  const span = (row.end.seconds - row.start.seconds) / SECONDS_PER_MINUTE;
+  const overnight = span + MINUTES_PER_DAY - rest;
+  const twelveHour = span + MINUTES_PER_HALF_DAY - rest;
+  return [overnight, twelveHour].every((reading) => Math.abs(hours - reading) > ROUNDING_MINUTES);
+};
+
+/** 実働か休憩が読めない行は、文の中の範囲と同じく打ち間違いの幅の戻りだけを言う。 */
+const isReversedRow = (row: Row, inputs: ShiftInputs): boolean => {
+  const reading = rangeReading(inputs.source, row.start, row.end);
+  const back = reading.from - reading.to;
+  if (back <= 0) return false;
+  if (reading.sameHalf === true) return true;
+  if (inputs.overnight) return false;
+  if (row.hours === undefined || row.break === undefined) return isReversed(reading);
+  return back < SECONDS_PER_HALF_DAY && hoursContradictOvernight(row, row.hours, row.break);
+};
+
+/** 列の升の長さ。列が無ければ休憩は 0、実働は読まない。 */
+const lengthIn = (cells: readonly Cell[], column: number, inputs: ShiftInputs, absent: number | undefined): number | undefined => {
+  if (column === -1) return absent;
+  const cell = cells[column];
+  return cell === undefined ? undefined : inputs.lengthOf(cell.text.trim());
+};
+
+type Labels = { readonly start: string; readonly end: string };
+
+const issueOf = (row: Row, labels: Labels, source: string): StructureIssue => {
+  const [start, end] = [source.slice(row.start.start, row.start.end), source.slice(row.end.start, row.end.end)];
+  return { offset: row.end.start, values: { range: `${start} | ${end}`, start, end, start_label: labels.start, end_label: labels.end } };
+};
+
+/** 始まりの列と終わりの列を見出しから読む表の、終わりが始まりより前の行。終わりの時刻を指す。 */
+export const reversedShiftRows = (inputs: ShiftInputs): StructureIssue[] =>
+  tablesOf(linesOf(inputs.source)).flatMap((table) => {
+    const header = cellsOf(table.header);
+    const [starts, ends, hours, breaks] = (["start", "end", "hours", "break"] as const).map((side) => columnOf(header, inputs.columns, side));
+    if (starts === undefined || ends === undefined || starts === -1 || ends === -1) return [];
+    const labels = { start: header[starts]?.text.trim() ?? "", end: header[ends]?.text.trim() ?? "" };
+    return table.rows.flatMap((line) => {
+      const cells = cellsOf(line);
+      const [start, end] = [onlyTime(cells[starts], inputs.times, inputs.source), onlyTime(cells[ends], inputs.times, inputs.source)];
+      if (start === undefined || end === undefined) return [];
+      const row = { start, end, hours: lengthIn(cells, hours ?? -1, inputs, undefined), break: lengthIn(cells, breaks ?? -1, inputs, 0) };
+      return isReversedRow(row, inputs) ? [issueOf(row, labels, inputs.source)] : [];
+    });
+  });
+
+/** 24 時を超える時刻（25:30）。夜をまたぐ勤務を当日の続きで書く書き方。 */
+const PAST_MIDNIGHT = /(?<![\d:])(?:2[4-9]|3\d|4[0-7]):[0-5]\d(?!\d)/u;
+
+/** 文書に夜をまたぐ勤務の印があるか。語（夜勤、night shift。語彙表 overnight-work-mark）、翌日の印を付けた時刻、24 時を超える時刻。 */
+export const showsOvernightWork = (source: string, times: readonly TimeSpan[], marks: readonly Mark[], words: TimeWords): boolean => {
+  const lower = source.toLowerCase();
+  if (marks.some((mark) => wordOffsets(lower, mark.pattern.toLowerCase()).length > 0)) return true;
+  if (PAST_MIDNIGHT.test(source)) return true;
+  return times.some((time) => dayShiftOf(source.slice(Math.max(0, time.start - DAY_SHIFT_LOOK_BACK), time.start), source, time.end, words) > 0);
+};

package/src/structure/span-label.ts

@@ -0,0 +1,26 @@
+import { leadOf } from "./stated-period.ts";
+
+const LABEL_COLON = /[:：]/u;
+const LABEL_CLOSE = /(?:\*\*|__|】|\])$/u;
+/** 見出しの語は数語（Sales period）。コロンの前がそれより長ければ文で、見出しではない。 */
+const MAX_LABEL_WORDS = 4;
+
+/** 期間を名指す語（period、dates）で終わる短い見出しとコロン（Sales period:）の後ろの、行の中の位置。そうした見出しの無い行は undefined。 */
+export const afterSpanLabel = (line: string, heads: readonly string[]): number | undefined => {
+  const lead = leadOf(line);
+  const colon = line.slice(lead).search(LABEL_COLON);
+  if (colon === -1) return undefined;
+  const label = line
+    .slice(lead, lead + colon)
+    .replace(LABEL_CLOSE, "")
+    .trim()
+    .toLowerCase()
+    .split(/\s+/u);
+  if (label.length > MAX_LABEL_WORDS) return undefined;
+  const text = label.join(" ");
+  const named = heads.some((head) => {
+    const word = head.toLowerCase();
+    return text === word || text.endsWith(` ${word}`);
+  });
+  return named ? lead + colon + 1 : undefined;
+};