chaffjs 0.31.0 → 0.32.0

package/src/derived/timesheet-hours.ts

@@ -0,0 +1,112 @@
+import type { Span } from "../plugin.ts";
+import { linesOf } from "../structure/lines.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { columnOf, hasHeadingNote, onlyTime } from "../structure/shift-times.ts";
+import { rangeReading } from "../structure/time-range.ts";
+import type { Mark, TimeSpan } from "../structure/time-marks.ts";
+import type { ClockRange } from "./working-hours.ts";
+
+/**
+ * 勤務表の行の実働（始業 | 終業 | 休憩 | 実働、Start | End | Break | Hours）を、終わりから始まりと休憩を引いた長さと比べる。
+ * 列は見出しの名前で読む（語彙表 shift-column）。始まりと終わりの列が無ければ、一つの升に書いた範囲（9:30〜18:30）を読む。
+ * 休憩の列と実働の列が両方ある表だけを読み、どれかの升が読めない行は言わない（休憩が勤務より長い行は実働を読まずに言う）。休憩の升の単位の無い数（30）は分か時間か
+ * 分からないので読まない。片方にだけ午前・午後を書いた行も読まない。終わりが始まりより前の行は、文書に夜をまたぐ勤務の印が
+ * あるときだけ日をまたいで読み、無ければ言わない（time-range-reversed が見る）。Pure.
+ */
+
+const SECONDS_PER_MINUTE = 60;
+const MINUTES_PER_DAY = 24 * 60;
+/** 実働を小数の時間で書いたときの丸め（8.33 は 499.8 分）。 */
+const ROUNDING_MINUTES = 3;
+
+export type TimesheetInputs = {
+  readonly text: string;
+  readonly times: readonly TimeSpan[];
+  /** 一つの升に書いた時刻の範囲（9:30〜18:30）。 */
+  readonly ranges: readonly ClockRange[];
+  readonly columns: readonly Mark[];
+  readonly overnight: boolean;
+  /** 升に書いた長さを分で。bareHours なら単位の無い数（8.00）も時間と読む。 */
+  readonly lengthOf: (text: string, bareHours: boolean) => number | undefined;
+};
+
+export type TimesheetMismatch = {
+  readonly start: Span;
+  readonly end: Span;
+  readonly break: Span;
+  /** 休憩が勤務より長い行では読まない。 */
+  readonly total?: Span & { readonly minutes: number };
+  /** 終わりから始まりと休憩を引いた分。負なら休憩が勤務より長い。 */
+  readonly expected: number;
+};
+
+type Columns = { readonly start: number; readonly end: number; readonly hours: number; readonly break: number; readonly bareHours: boolean };
+
+const trimmed = (cell: Cell): Span & { readonly text: string } => {
+  const text = cell.text.trim();
+  const start = cell.start + cell.text.indexOf(text);
+  return { start, end: start + text.length, text };
+};
+
+/** 始まりと終わりの列の時刻。十二時間制の片方にだけ午前・午後を書いた組は読まない。 */
+const columnTimes = (cells: readonly Cell[], columns: Columns, inputs: TimesheetInputs) => {
+  const [from, to] = [onlyTime(cells[columns.start], inputs.times, inputs.text), onlyTime(cells[columns.end], inputs.times, inputs.text)];
+  if (from === undefined || to === undefined) return undefined;
+  const reading = rangeReading(inputs.text, from, to);
+  return reading.borrowed ? undefined : { from, to, minutes: (reading.to - reading.from) / SECONDS_PER_MINUTE };
+};
+
+/** 一つの升に範囲だけを書いた行の、その範囲。実働と休憩の列のほかに、そういう升が一つだけのときに読む。 */
+const rangeTimes = (cells: readonly Cell[], columns: Columns, inputs: TimesheetInputs) => {
+  const others = cells.filter((_cell, index) => index !== columns.hours && index !== columns.break);
+  const found = others.flatMap((cell) => {
+    const within = trimmed(cell);
+    return inputs.ranges.filter((range) => range.start === within.start && range.end === within.end);
+  });
+  const range = found.length === 1 ? found[0] : undefined;
+  if (range === undefined || rangeReading(inputs.text, range.from, range.to).borrowed) return undefined;
+  return { from: range.from, to: range.to, minutes: range.minutes ?? (range.to.seconds - range.from.seconds) / SECONDS_PER_MINUTE };
+};
+
+/** 勤務の長さ。日をまたぐ行は、夜をまたぐ勤務の印のある文書でだけ読む。 */
+const shiftMinutes = (minutes: number, overnight: boolean): number | undefined => {
+  if (minutes > 0) return minutes;
+  return overnight && minutes < 0 ? minutes + MINUTES_PER_DAY : undefined;
+};
+
+const lengthCell = (cell: Cell | undefined, inputs: TimesheetInputs, bareHours: boolean) => {
+  if (cell === undefined) return undefined;
+  const span = trimmed(cell);
+  const minutes = inputs.lengthOf(span.text, bareHours);
+  return minutes === undefined ? undefined : { ...span, minutes };
+};
+
+const rowMismatch = (cells: readonly Cell[], columns: Columns, inputs: TimesheetInputs): TimesheetMismatch | undefined => {
+  const times = columns.start === -1 ? rangeTimes(cells, columns, inputs) : columnTimes(cells, columns, inputs);
+  const shift = times === undefined ? undefined : shiftMinutes(times.minutes, inputs.overnight);
+  const breakLength = lengthCell(cells[columns.break], inputs, false);
+  const total = lengthCell(cells[columns.hours], inputs, columns.bareHours);
+  if (times === undefined || shift === undefined || breakLength === undefined) return undefined;
+  const expected = shift - breakLength.minutes;
+  if (expected < 0) return { start: times.from, end: times.to, break: breakLength, expected };
+  if (total === undefined || Math.abs(expected - total.minutes) <= ROUNDING_MINUTES) return undefined;
+  return { start: times.from, end: times.to, break: breakLength, total, expected };
+};
+
+const columnsOf = (header: readonly Cell[], marks: readonly Mark[]): Columns | undefined => {
+  const [start, end, hours, rest] = (["start", "end", "hours", "break"] as const).map((side) => columnOf(header, marks, side));
+  if (start === undefined || end === undefined || hours === undefined || rest === undefined || hours === -1 || rest === -1) return undefined;
+  if ((start === -1) !== (end === -1)) return undefined;
+  return { start, end, hours, break: rest, bareHours: !hasHeadingNote(header[hours]?.text ?? "") };
+};
+
+/** 勤務表の行で、実働が終わり − 始まり − 休憩と合わないもの、休憩が勤務より長いもの。 */
+export const timesheetHoursMismatches = (inputs: TimesheetInputs): TimesheetMismatch[] =>
+  tablesOf(linesOf(inputs.text)).flatMap((table) => {
+    const columns = columnsOf(cellsOf(table.header), inputs.columns);
+    if (columns === undefined) return [];
+    return table.rows.flatMap((line) => {
+      const mismatch = rowMismatch(cellsOf(line), columns, inputs);
+      return mismatch === undefined ? [] : [mismatch];
+    });
+  });

package/src/derived/use-maximum.ts

@@ -0,0 +1,158 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import type { Mark } from "../structure/time-marks.ts";
+import {
+  asciiDigits,
+  isLimited,
+  lastIndexAtOrBefore,
+  periodCounts,
+  periodsIn,
+  windowStart,
+  type LimitWords,
+  type PeriodCount,
+  type PeriodCountWords,
+} from "./period-counts.ts";
+
+/**
+ * The amount of one use times the uses in a period, against the maximum stated for that period (1回2錠を1日3回、1日の最大量は
+ * 4錠; 2 tablets at a time, 3 times a day, no more than 4 tablets in 24 hours). Read in one paragraph holding exactly one
+ * labelled amount of one use, one count of uses in a period and one maximum in the same unit for the same period. Pure.
+ */
+type UseAmount = Span & { readonly amount: number; readonly unit: string };
+
+export type UseMaximumWords = PeriodCountWords &
+  LimitWords & {
+    /** What makes an amount the amount of one use: before it (1回2錠) or right after it (2 tablets at a time). */
+    readonly perUse: readonly Mark[];
+  };
+
+export type ExceededMaximum = {
+  readonly perUse: UseAmount;
+  readonly count: PeriodCount;
+  readonly maximum: UseAmount;
+  /** The amount of one use times the count. */
+  readonly expected: number;
+};
+
+type Maximum = UseAmount & { readonly hours: number };
+
+/** A number and the unit written right after it (2錠, 3,000円, 4 tablets). A number in a range (1〜2錠) is not read. */
+const AMOUNT = /(?<![\p{N}.,．〜~\-–])(\p{Nd}+(?:[,，]\p{Nd}{3})*(?:[.．]\p{Nd}+)?)\s?([\p{Script=Han}\p{Script=Katakana}ー]{1,6}|[A-Za-zµμ]+)/gu;
+
+const LATIN_PLURAL = /^([a-z]{2,})s$/u;
+
+/** 錠 and 錠, tablet and tablets: the unit with its case and an English plural s taken off. */
+const unitKey = (unit: string): string => {
+  const lower = unit.normalize("NFKC").toLowerCase();
+  return LATIN_PLURAL.exec(lower)?.[1] ?? lower;
+};
+
+/** The characters of text that taken covers. */
+const coverOf = (length: number, taken: readonly Span[]): Uint8Array => {
+  const cover = new Uint8Array(length);
+  taken.forEach((span) => cover.fill(1, span.start, span.end));
+  return cover;
+};
+
+const amountsIn = (text: string, taken: readonly Span[]): UseAmount[] => {
+  const cover = coverOf(text.length, taken);
+  return [...text.matchAll(AMOUNT)].flatMap((match): UseAmount[] => {
+    const span = { start: match.index, end: match.index + match[0].length };
+    const amount = Number((match[1] ?? "").normalize("NFKC").replace(/,/gu, ""));
+    if (cover.subarray(span.start, span.end).includes(1) || !Number.isFinite(amount)) return [];
+    return [{ ...span, amount, unit: unitKey(match[2] ?? "") }];
+  });
+};
+
+const lower = (text: string): string => text.toLowerCase();
+
+const LABEL_GAP = /^[\s,、]*/u;
+const LABEL_SEPARATORS = new Set([" ", "\t", "\u3000", ":", "："]);
+
+/** 1回量：2錠 reads its label past the colon. */
+const withoutSeparatorsAtEnd = (text: string): string => {
+  let end = text.length;
+  while (end > 0 && LABEL_SEPARATORS.has(text.charAt(end - 1))) end -= 1;
+  return text.slice(0, end);
+};
+/** How far around an amount its label is looked for, in characters. */
+const LABEL_REACH = 32;
+
+/** 1回2錠: the label right before the number. 2 tablets at a time: right after the unit. */
+const isLabelled = (text: string, amount: UseAmount, labels: readonly Mark[]): boolean => {
+  const before = withoutSeparatorsAtEnd(lower(text.slice(Math.max(0, amount.start - LABEL_REACH), amount.start)));
+  const after = lower(text.slice(amount.end, amount.end + LABEL_REACH));
+  const gap = LABEL_GAP.exec(after)?.[0].length ?? 0;
+  return labels.some((label) =>
+    (label.position ?? "before") === "before"
+      ? before.endsWith(lower(label.pattern))
+      : new RegExp(`^${escapeRegExp(lower(label.pattern))}(?![a-z])`, "u").test(after.slice(gap)),
+  );
+};
+
+const COUNT_GAP = /^[\s,、を]*/u;
+const SPACES = /^\s*/u;
+
+/** Where the count would start after amount: past commas, を, and a limit word ("2 tablets, up to 3 times a day"). */
+const countStartAfter = (text: string, amount: UseAmount, words: LimitWords): number => {
+  const from = amount.end + (COUNT_GAP.exec(text.slice(amount.end, amount.end + LABEL_REACH))?.[0].length ?? 0);
+  const rest = lower(text.slice(from, from + LABEL_REACH));
+  const limit = words.limits.find((mark) => (mark.position ?? "before") === "before" && new RegExp(`^${escapeRegExp(lower(mark.pattern))}\\s`, "u").test(rest));
+  if (limit === undefined) return from;
+  const after = from + limit.pattern.length;
+  return after + (SPACES.exec(text.slice(after, after + LABEL_REACH))?.[0].length ?? 0);
+};
+
+type Period = Span & { readonly hours: number };
+
+type Periods = { readonly all: readonly Period[]; readonly ends: readonly number[]; readonly byStart: ReadonlyMap<number, number> };
+
+const periodsOf = (all: readonly Period[]): Periods => ({
+  all,
+  ends: all.map((period) => period.end),
+  byStart: new Map(all.map((period) => [period.start, period.hours])),
+});
+
+/** The period of a maximum: right after it (4 tablets in 24 hours), or the last in its window (1日の最大量は). */
+const periodOf = (text: string, amount: UseAmount, from: number, periods: Periods): number | undefined => {
+  const at = amount.end + (SPACES.exec(text.slice(amount.end, amount.end + LABEL_REACH))?.[0].length ?? 0);
+  const before = periods.all[lastIndexAtOrBefore(periods.ends, amount.start)];
+  return periods.byStart.get(at) ?? (before !== undefined && before.start >= from ? before.hours : undefined);
+};
+
+type Reading = { readonly perUse: UseAmount[]; readonly maxima: Maximum[]; readonly counts: PeriodCount[] };
+
+const readingOf = (text: string, words: UseMaximumWords): Reading => {
+  const counts = periodCounts(text, words);
+  const periods = periodsOf(periodsIn(text, words));
+  const amounts = amountsIn(text, [...counts, ...periods.all]);
+  const countStarts = new Set(counts.map((count) => count.start));
+  const perUse = new Set(amounts.filter((amount) => isLabelled(text, amount, words.perUse) || countStarts.has(countStartAfter(text, amount, words))));
+  const takenEnds = [...counts, ...amounts].map((span) => span.end).toSorted((left, right) => left - right);
+  const maxima = amounts.flatMap((amount): Maximum[] => {
+    const from = windowStart(text, amount.start, takenEnds);
+    const hours = perUse.has(amount) || !isLimited(text, amount, from, words) ? undefined : periodOf(text, amount, from, periods);
+    return hours === undefined ? [] : [{ ...amount, hours }];
+  });
+  return { perUse: [...perUse], maxima, counts };
+};
+
+const inside = (scope: Span) => (span: Span) => span.start >= scope.start && span.end <= scope.end;
+
+const exceededIn = (scope: Span, reading: Reading): ExceededMaximum | undefined => {
+  const [perUse, counts, maxima] = [reading.perUse.filter(inside(scope)), reading.counts.filter(inside(scope)), reading.maxima.filter(inside(scope))];
+  const [one, count, maximum] = [perUse[0], counts[0], maxima[0]];
+  if (perUse.length !== 1 || counts.length !== 1 || maxima.length !== 1 || one === undefined || count === undefined || maximum === undefined) return undefined;
+  if (one.unit !== maximum.unit || count.hours !== maximum.hours) return undefined;
+  const expected = one.amount * count.amount;
+  return expected > maximum.amount ? { perUse: one, count, maximum, expected } : undefined;
+};
+
+/** Maxima below the amount of one use times the uses in the same period. scopes are the paragraphs to read in. */
+export const exceededMaxima = (written: string, scopes: readonly Span[], words: UseMaximumWords): ExceededMaximum[] => {
+  const reading = readingOf(asciiDigits(written), words);
+  return scopes.flatMap((scope) => {
+    const found = exceededIn(scope, reading);
+    return found === undefined ? [] : [found];
+  });
+};

package/src/derived/working-hours.ts

@@ -21,12 +21,12 @@ export type WorkingHoursMismatch = {
   readonly start: Span;
   readonly end: Span;
   readonly break: Span;
-  readonly total: Span;
+  readonly total: TimeLength;
   /** The total the times and the break give, in minutes. */
   readonly expected: number;
 };
 
-type ClockRange = Span & { readonly from: Span; readonly to: Span; readonly minutes: number | undefined };
+export type ClockRange = Span & { readonly from: TimeSpan; readonly to: TimeSpan; readonly minutes: number | undefined };
 
 const SECONDS_PER_MINUTE = 60;
 

package/src/detectors/annual-holidays-mismatch.ts

@@ -0,0 +1,41 @@
+// annual-holidays-mismatch: annual days off fewer than the weekly days off give over a year (structure/annual-holidays.ts).
+// The labels are annual-holidays-label, the weekly phrases weekly-days-off, the other words annual-holidays-word,
+// approximate-marker, range-connector and amount-range-word.
+import type { Detector, Finding, Lexicon, ProseDocument } from "../plugin.ts";
+import { annualHolidaysMismatches, type AnnualHolidaysWords, type PositionedWord } from "../structure/annual-holidays.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const entriesOf = (doc: ProseDocument, lexicon: string, group?: string): Lexicon =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group);
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] => entriesOf(doc, lexicon, group).map((entry) => entry.pattern);
+
+const positionedOf = (doc: ProseDocument, lexicon: string, group?: string): PositionedWord[] =>
+  entriesOf(doc, lexicon, group).map((entry) => ({ word: entry.pattern, position: entry.position === "after" ? "after" : "before" }));
+
+const weeklyOf = (doc: ProseDocument): AnnualHolidaysWords["weekly"] =>
+  entriesOf(doc, "weekly-days-off").map((entry) => ({ word: entry.pattern, minimum: entry.group === "every-week" ? entry.weight : undefined }));
+
+const wordsOf = (doc: ProseDocument): AnnualHolidaysWords => ({
+  labels: positionedOf(doc, "annual-holidays-label"),
+  days: patternsOf(doc, "annual-holidays-word", "day"),
+  links: patternsOf(doc, "annual-holidays-word", "link"),
+  weekly: weeklyOf(doc),
+  negations: positionedOf(doc, "annual-holidays-word", "negation"),
+  exceptions: patternsOf(doc, "annual-holidays-word", "exception"),
+  markers: [...positionedOf(doc, "approximate-marker"), ...positionedOf(doc, "annual-holidays-word", "open")],
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "amount-range-word")],
+});
+
+export const annualHolidaysMismatch: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return annualHolidaysMismatches(text, wordsOf(doc)).map((issue) => ({
+    rule: "annual-holidays-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/annual-pay-mismatch.ts

@@ -0,0 +1,71 @@
+// annual-pay-mismatch: an example annual pay that is not the monthly pay times twelve plus the bonus months
+// (structure/annual-pay.ts). The amounts are currency-notation's, read with amount-multiplier's words of scale; the labels
+// are annual-pay-label, the other words annual-pay-word, approximate-marker, duration-month, number-word (digit),
+// range-connector and amount-range-word.
+import type { Detector, Finding, Lexicon, ProseDocument } from "../plugin.ts";
+import { annualPayMismatches, type AnnualPayWords, type PayAmount, type PositionedWord } from "../structure/annual-pay.ts";
+import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
+import { amountsIn, formsOf } from "./currency-notation.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const entriesOf = (doc: ProseDocument, lexicon: string, group?: string): Lexicon =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => group === undefined || entry.group === group);
+
+const patternsOf = (doc: ProseDocument, lexicon: string, group?: string): string[] => entriesOf(doc, lexicon, group).map((entry) => entry.pattern);
+
+const positionedOf = (doc: ProseDocument, lexicon: string, group?: string): PositionedWord[] =>
+  entriesOf(doc, lexicon, group).map((entry) => ({ word: entry.pattern, position: entry.position === "after" ? "after" : "before" }));
+
+const numberWordsOf = (doc: ProseDocument): AnnualPayWords["numberWords"] =>
+  entriesOf(doc, "number-word", "digit").flatMap((entry) => (entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }]));
+
+const labelsOf = (doc: ProseDocument): AnnualPayWords["labels"] => ({
+  example: patternsOf(doc, "annual-pay-label", "example"),
+  salary: patternsOf(doc, "annual-pay-label", "salary"),
+  monthly: patternsOf(doc, "annual-pay-label", "monthly"),
+  pay: patternsOf(doc, "annual-pay-label", "pay"),
+  bonus: patternsOf(doc, "annual-pay-label", "bonus"),
+});
+
+const wordsOf = (doc: ProseDocument): AnnualPayWords => ({
+  labels: labelsOf(doc),
+  links: patternsOf(doc, "annual-pay-word", "link"),
+  perMonth: patternsOf(doc, "annual-pay-word", "per-month"),
+  none: positionedOf(doc, "annual-pay-word", "none"),
+  each: patternsOf(doc, "annual-pay-word", "each"),
+  extra: patternsOf(doc, "annual-pay-word", "extra"),
+  times: patternsOf(doc, "annual-pay-word", "times"),
+  totals: patternsOf(doc, "annual-pay-word", "total"),
+  includes: patternsOf(doc, "annual-pay-word", "include"),
+  markers: [...positionedOf(doc, "approximate-marker"), ...positionedOf(doc, "annual-pay-word", "open")],
+  months: patternsOf(doc, "duration-month"),
+  connectors: [...patternsOf(doc, "range-connector"), ...patternsOf(doc, "amount-range-word")],
+  numberWords: numberWordsOf(doc),
+});
+
+const amountsOf = (text: string, doc: ProseDocument): PayAmount[] => {
+  const scales = scaleWordsOf(doc);
+  return amountsIn(
+    text,
+    formsOf(doc),
+    scales.map((scale) => scale.word),
+  ).flatMap((amount) => {
+    const read = scaledAmountOf(text, amount, scales);
+    return read === undefined
+      ? []
+      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
+  });
+};
+
+export const annualPayMismatch: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return annualPayMismatches(text, amountsOf(text, doc), wordsOf(doc)).map((issue) => ({
+    rule: "annual-pay-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/blank-structure.ts

@@ -5,6 +5,9 @@ import { readMarkdown } from "../markdown-read.ts";
 import { spanOf, type MarkdownNode } from "../markdown-node.ts";
 import { eachPreOrder, foldPostOrder } from "../tree-walk.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { amountColumnOf, isTotalRowGap, type BodyRow } from "../structure/total-row-blank.ts";
+import { isAmountNameLine, isTotalLine } from "../structure/total-line.ts";
+import { isTotalLabel } from "../structure/total.ts";
 
 /** Fewer body rows than this, and one blank is as likely a choice as a gap. */
 const MIN_BODY_ROWS = 3;
@@ -61,25 +64,45 @@ const cellOffset = (cell: MarkdownNode | undefined, row: MarkdownNode | undefine
   return row === undefined ? undefined : spanOf(row)?.end;
 };
 
-/** The one blank body cell of a column whose other body rows are all filled. */
-const columnBlank = (source: string, header: MarkdownNode, body: readonly MarkdownNode[], column: number): Blank[] => {
-  const cells = body.map((row) => row.children?.[column]);
-  const blanks = cells.flatMap((cell, index) => (cell === undefined || !shows(cell) ? [index] : []));
+/** Whether a row is a total, subtotal or tax row, judged from the row's source text. */
+export type IsTotalRow = (rowText: string) => boolean;
+
+const NO_TOTAL_ROWS: IsTotalRow = () => false;
+
+const rowSource = (source: string, row: MarkdownNode): string => {
+  const span = spanOf(row);
+  return span === undefined ? "" : source.slice(span.start, span.end);
+};
+
+const bodyRowOf = (source: string, row: MarkdownNode, isTotalRow: IsTotalRow): BodyRow => ({
+  total: isTotalRow(rowSource(source, row)),
+  cells: (row.children ?? []).map((cell) => (shows(cell) ? sourceOf(source, cell) : undefined)),
+});
+
+/**
+ * The one blank body cell of a column whose other body rows are all filled, unless it is a total row's blank beside its
+ * amount. Such a blank still counts as a second blank, so the rows it shares a column with stay as unreported as before.
+ */
+const columnBlank = (source: string, header: MarkdownNode, body: readonly MarkdownNode[], rows: readonly BodyRow[], column: number): Blank[] => {
+  const blanks = rows.flatMap((row, index) => (row.cells[column] === undefined ? [index] : []));
   const at = blanks[0];
-  if (blanks.length !== 1 || at === undefined) return [];
-  const offset = cellOffset(cells[at], body[at]);
+  const row = at === undefined ? undefined : rows[at];
+  if (blanks.length !== 1 || at === undefined || row === undefined) return [];
+  if (isTotalRowGap(row, column, amountColumnOf(rows, header.children?.length ?? 0))) return [];
+  const offset = cellOffset(body[at]?.children?.[column], body[at]);
   const name = sourceOf(source, header.children?.[column]);
   return offset === undefined || name === "" ? [] : [{ offset, name }];
 };
 
 /** The first column is skipped: a blank there often means "same as above". */
-const tableBlanksOf = (source: string, table: MarkdownNode): Blank[] => {
+const tableBlanksOf = (source: string, table: MarkdownNode, isTotalRow: IsTotalRow): Blank[] => {
   const [header, ...body] = table.children ?? [];
   if (header === undefined || body.length < MIN_BODY_ROWS) return [];
+  const rows = body.map((row) => bodyRowOf(source, row, isTotalRow));
   const columns = header.children?.length ?? 0;
   return Array.from({ length: columns }, (_unused, column) => column)
     .slice(1)
-    .flatMap((column) => columnBlank(source, header, body, column));
+    .flatMap((column) => columnBlank(source, header, body, rows, column));
 };
 
 /** Quoted material is someone else's: email replies the document model found, and every Markdown blockquote. */
@@ -95,8 +118,8 @@ const blocksOutsideQuotes = (source: string, type: string, replies: readonly Spa
 };
 
 /** Blank cells in every table outside quotes. */
-export const tableBlanks = (source: string, replies: readonly Span[] = []): Blank[] =>
-  blocksOutsideQuotes(source, "table", replies).flatMap((table) => tableBlanksOf(source, table));
+export const tableBlanks = (source: string, replies: readonly Span[] = [], isTotalRow: IsTotalRow = NO_TOTAL_ROWS): Blank[] =>
+  blocksOutsideQuotes(source, "table", replies).flatMap((table) => tableBlanksOf(source, table, isTotalRow));
 
 type Item = { readonly node: MarkdownNode; readonly text: string | undefined; readonly empty: boolean };
 
@@ -139,9 +162,9 @@ export const listBlanks = (source: string, replies: readonly Span[] = []): Blank
   blocksOutsideQuotes(source, "list", replies).flatMap((list) => listBlanksOf(source, list));
 
 const findingsOf =
-  (rule: string, blanksOf: (source: string, replies: readonly Span[]) => Blank[]): Detector =>
+  (rule: string, blanksOf: (doc: ProseDocument) => Blank[]): Detector =>
   (doc: ProseDocument): Finding[] =>
-    blanksOf(doc.source, doc.replyQuotes ?? []).map((blank) => ({
+    blanksOf(doc).map((blank) => ({
       rule,
       severity: "warning",
       line: 0,
@@ -151,5 +174,22 @@ const findingsOf =
       values: { name: blank.name, offset: blank.offset },
     }));
 
-export const emptyTableCell: Detector = findingsOf("empty-table-cell", tableBlanks);
-export const emptyListItem: Detector = findingsOf("empty-list-item", listBlanks);
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/**
+ * A total row starts with a total word (total-label, with total-label-qualifier or total-period-qualifier: Week total),
+ * a tax word (tax-label), or is named by a computed amount (net-amount-label: Gross pay, Net pay).
+ */
+const totalRowOf = (doc: ProseDocument): IsTotalRow => {
+  const totals = {
+    labels: patternsOf(doc, "total-label"),
+    qualifiers: doc.lexicons["total-label-qualifier"] ?? [],
+    periodQualifiers: doc.lexicons["total-period-qualifier"] ?? [],
+    amountNames: patternsOf(doc, "net-amount-label"),
+  };
+  const taxes = patternsOf(doc, "tax-label");
+  return (rowText) => isTotalLine(rowText, totals) || isAmountNameLine(rowText, totals) || isTotalLabel(rowText, taxes);
+};
+
+export const emptyTableCell: Detector = findingsOf("empty-table-cell", (doc) => tableBlanks(doc.source, doc.replyQuotes ?? [], totalRowOf(doc)));
+export const emptyListItem: Detector = findingsOf("empty-list-item", (doc) => listBlanks(doc.source, doc.replyQuotes ?? []));

package/src/detectors/bmi-mismatch.ts

@@ -0,0 +1,82 @@
+// bmi-mismatch: the reading half. Reads, section by section, the tables (each row's label and cells) and the "label: value"
+// lines, and leaves the deciding to structure/bmi.ts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { tablesOf } from "../facts/table-facts.ts";
+import { EDGE_MARKS, trimEndOf, withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { tableRowOf } from "./ratio-mismatch.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { sectionBmiMismatches, type BodyKind, type BodyUnit, type BodyWords } from "../structure/bmi.ts";
+import type { TableRow } from "../structure/ratio.ts";
+
+const RULE = "bmi-mismatch";
+const KINDS: ReadonlySet<string> = new Set(["height", "weight", "bmi"]);
+
+const isKind = (group: string | undefined): group is BodyKind => group !== undefined && KINDS.has(group);
+
+const unitsOf = (doc: ProseDocument, id: string): BodyUnit[] =>
+  (doc.lexicons[id] ?? []).flatMap((entry) => (entry.weight === undefined ? [] : [{ pattern: entry.pattern, factor: entry.weight }]));
+
+const wordsOf = (doc: ProseDocument): BodyWords => ({
+  terms: (doc.lexicons["bmi-term"] ?? []).flatMap((entry) => (isKind(entry.group) ? [{ pattern: entry.pattern, kind: entry.group }] : [])),
+  lengthUnits: unitsOf(doc, "unit-length"),
+  massUnits: unitsOf(doc, "unit-mass"),
+  bmiUnits: (doc.lexicons["bmi-unit"] ?? []).map((entry) => entry.pattern),
+});
+
+/** A list mark or a blockquote mark at the head of a line ("- ", "1. ", "> "). */
+const LINE_MARK = /^\s*(?:>\s*)*(?:(?:[-*+]|\d+[.)])\s+)?/u;
+/** "Height: 178 cm", 「身長：160.0 cm」: the label ends at the first colon. */
+const COLON = /[:：]/u;
+/** What may end a value: a sentence end, edge marks and spaces. */
+const VALUE_END: ReadonlySet<string> = new Set([...EDGE_MARKS, "。", "."]);
+
+/** A "label: value" line read as a row of one cell: the label up to the first colon, the value after it to the line end. */
+const labelLineRow = (line: Line): TableRow[] => {
+  const mark = LINE_MARK.exec(line.text)?.[0] ?? "";
+  const colon = line.text.slice(mark.length).search(COLON);
+  if (colon <= 0) return [];
+  const valueFrom = mark.length + colon + 1;
+  const text = withoutEdgeMarks(trimEndOf(line.text.slice(valueFrom), VALUE_END));
+  if (text === "") return [];
+  const start = line.start + valueFrom + line.text.slice(valueFrom).indexOf(text);
+  return [{ label: withoutEdgeMarks(line.text.slice(mark.length, mark.length + colon)), cells: [{ start, text }] }];
+};
+
+type SectionGroups = { readonly tables: TableRow[][]; readonly lines: TableRow[] };
+
+const sectionAt = (doc: ProseDocument, offset: number): number => doc.sections.findLastIndex((section) => section.span.start <= offset);
+
+/** Each section's tables and its "label: value" lines, by the index of the section (-1 before the first). */
+const groupsBySection = (doc: ProseDocument): Map<number, SectionGroups> => {
+  const lines = linesOf(proseAndTablesOf(doc));
+  const tables = tablesOf(lines);
+  const tableLines = new Set(tables.flatMap((table) => [table.header.number, ...table.rows.map((row) => row.number)]));
+  const groups = new Map<number, SectionGroups>();
+  const groupAt = (offset: number): SectionGroups => {
+    const index = sectionAt(doc, offset);
+    const found = groups.get(index) ?? { tables: [], lines: [] };
+    groups.set(index, found);
+    return found;
+  };
+  tables.forEach((table) => groupAt(table.header.start).tables.push(table.rows.flatMap(tableRowOf)));
+  lines.filter((line) => !tableLines.has(line.number)).forEach((line) => groupAt(line.start).lines.push(...labelLineRow(line)));
+  return groups;
+};
+
+export const bmiMismatch: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  if (words.terms.length === 0) return [];
+  return [...groupsBySection(doc).values()]
+    .flatMap((section) => sectionBmiMismatches([...section.tables, section.lines], words))
+    .toSorted((left, right) => left.offset - right.offset)
+    .map((issue) => ({
+      rule: RULE,
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));
+};

package/src/detectors/change-rate.ts

@@ -2,11 +2,15 @@
 // tree's quantities, the numbers counted with a word ("1,200 companies"), the calendar years, and the lexicons change-direction,
 // change-base, change-target, change-break, percent-unit and amount-multiplier.
 import type { Detector, Finding, LexiconEntry, ProseDocument, Span, StructureNode, Token } from "../plugin.ts";
-import { inDocumentOrder } from "../structure/issues.ts";
+import { inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { startsOtherSubject } from "../structure/subject-change.ts";
 import { changeRateMismatches, type BaseMark, type Break, type Direction, type Figure, type Period, type Rate } from "../structure/change-rate.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { tableRateMismatches, type ChangeTable, type ColumnRole, type ColumnWord } from "../structure/change-rate-table.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { proseAndTablesOf } from "../table-text.ts";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
@@ -137,7 +141,23 @@ const marksOf = (doc: ProseDocument, lexicon: string): BaseMark[] =>
     entry.position === undefined ? [] : spansOf(doc.source, entry.pattern).map((span) => ({ ...span, position: entry.position ?? "before" })),
   );
 
-export const changeRate: Detector = (doc): Finding[] => {
+const ROLES: readonly string[] = ["base", "current", "rate", "change"] satisfies readonly ColumnRole[];
+const isRole = (group: string | undefined): group is ColumnRole => group !== undefined && ROLES.includes(group);
+
+/** Lexicon change-column: the heading words that say which column holds the earlier value, the later one and the rate. */
+const columnWordsOf = (doc: ProseDocument): ColumnWord[] =>
+  (doc.lexicons["change-column"] ?? []).flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : []));
+
+/** The document's Markdown tables (outside code and quotes): the heading cells and the body rows' cells. */
+const changeTablesOf = (doc: ProseDocument): ChangeTable[] =>
+  tablesOf(linesOf(proseAndTablesOf(doc))).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) }));
+
+const tableIssues = (doc: ProseDocument): StructureIssue[] => {
+  const words = columnWordsOf(doc);
+  return words.length === 0 ? [] : tableRateMismatches(changeTablesOf(doc), words);
+};
+
+const sentenceIssues = (doc: ProseDocument): StructureIssue[] => {
   if (doc.structure === undefined) return [];
   const nodes = quantityNodes(doc.structure);
   const units = patternsOf(doc, "percent-unit");
@@ -155,7 +175,11 @@ export const changeRate: Detector = (doc): Finding[] => {
     breaks: breaksOf(doc),
     source: doc.source,
   };
-  return changeRateMismatches(text).map((issue) => ({
+  return changeRateMismatches(text);
+};
+
+export const changeRate: Detector = (doc): Finding[] =>
+  [...sentenceIssues(doc), ...tableIssues(doc)].map((issue) => ({
     rule: "change-rate-mismatch",
     severity: "warning",
     line: 0,
@@ -163,4 +187,3 @@ export const changeRate: Detector = (doc): Finding[] => {
     quote: quoteAt(doc.source, issue.offset),
     values: { ...issue.values, offset: issue.offset },
   }));
-};