chaffjs 0.30.0 → 0.32.0

package/src/derived/use-interval.ts

@@ -0,0 +1,151 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import type { Mark } from "../structure/time-marks.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import type { TimeLength } from "./time-lengths.ts";
+import {
+  asciiDigits,
+  isLimited,
+  lastIndexAtOrBefore,
+  periodCounts,
+  windowStart,
+  type LimitWords,
+  type PeriodCount,
+  type PeriodCountWords,
+  type PeriodWord,
+} from "./period-counts.ts";
+
+/**
+ * A minimum interval between uses and a maximum count of uses in a period that cannot both hold, and a maximum count that
+ * differs from the times a day of the dosing table in the same section. Read in one paragraph holding exactly one
+ * minimum interval (4時間以上あけ, at least 4 hours between doses) and exactly one count with a limit (1日6回を超えて,
+ * no more than 6 doses a day). n uses at least h hours apart take (n - 1) × h hours from the first to the last; when
+ * that reaches the length of the period, the n-th use falls outside it. Pure.
+ */
+export type IntervalWords = PeriodCountWords &
+  LimitWords & {
+    /** What makes a length a minimum: before it (at least 4 hours) or right after it (4時間以上). */
+    readonly minimum: readonly Mark[];
+    /** What makes a minimum length an interval between uses, in the same sentence (間隔, between). */
+    readonly cues: readonly string[];
+    /** Table headings of a count of uses in a period (1日の服用回数, Times a day), with the period's hours. */
+    readonly columns: readonly PeriodWord[];
+  };
+
+export type IntervalMismatch =
+  | { readonly kind: "interval"; readonly count: PeriodCount; readonly interval: TimeLength; readonly neededHours: number }
+  | { readonly kind: "table"; readonly count: PeriodCount; readonly column: string; readonly tableCount: number };
+
+const MINUTES_PER_HOUR = 60;
+
+const lower = (text: string): string => text.toLowerCase();
+
+const SENTENCE_END = /[。．！？!?\n]|\.(?=\s|$)/u;
+
+/** How far after a length its sentence is read, in characters. */
+const SENTENCE_REACH = 120;
+
+const sentenceAround = (text: string, span: Span): Span => {
+  const end = SENTENCE_END.exec(text.slice(span.end, span.end + SENTENCE_REACH));
+  return { start: windowStart(text, span.start, []), end: end === null ? Math.min(text.length, span.end + SENTENCE_REACH) : span.end + end.index };
+};
+
+const hasWord = (text: string, word: string): boolean => new RegExp(`(?<![a-z])${escapeRegExp(lower(word))}(?![a-z])`, "u").test(lower(text));
+
+/** 4時間以上, at least 4 hours: a length with a minimum mark beside it and an interval word in its sentence. */
+const isMinimumInterval = (text: string, length: TimeLength, words: IntervalWords): boolean => {
+  const sentence = sentenceAround(text, length);
+  const before = lower(text.slice(sentence.start, length.start)).trimEnd();
+  const after = lower(text.slice(length.end, sentence.end)).trimStart();
+  const marked = words.minimum.some((mark) =>
+    (mark.position ?? "after") === "after" ? after.startsWith(lower(mark.pattern)) : before.endsWith(lower(mark.pattern)),
+  );
+  return marked && words.cues.some((cue) => hasWord(text.slice(sentence.start, sentence.end), cue));
+};
+
+const inside = (scope: Span) => (span: Span) => span.start >= scope.start && span.end <= scope.end;
+
+type Statement = { readonly count: PeriodCount; readonly interval: TimeLength };
+
+const statementIn = (scope: Span, counts: readonly PeriodCount[], intervals: readonly TimeLength[]): Statement | undefined => {
+  const [inCounts, inIntervals] = [counts.filter(inside(scope)), intervals.filter(inside(scope))];
+  const [count, interval] = [inCounts[0], inIntervals[0]];
+  return inCounts.length === 1 && inIntervals.length === 1 && count !== undefined && interval !== undefined ? { count, interval } : undefined;
+};
+
+const HEADING = /^ {0,3}#{1,6}\s/u;
+
+const plain = (cell: string): string => lower(asciiDigits(cell).normalize("NFKC").replace(/[*_`]/gu, "").trim());
+
+const COUNT_CELL = /^(\d+)(?:\s*[〜~\-–]\s*(\d+))?$/u;
+
+/** A cell that holds only a count: 3, 3回, 2〜3回, three, twice. The larger end of a range. */
+const cellCount = (cell: string, words: PeriodCountWords): number | undefined => {
+  const text = plain(cell);
+  const counter = words.counters.find((word) => text.endsWith(lower(word)));
+  const bare = counter === undefined ? text : text.slice(0, -counter.length).trim();
+  const digits = COUNT_CELL.exec(bare);
+  if (digits !== null) return Number(digits[2] ?? digits[1]);
+  return words.numberWords.find((word) => lower(word.pattern) === bare)?.value;
+};
+
+type TableCount = { readonly at: number; readonly column: string; readonly count: number; readonly hours: number };
+
+/** The largest count of each counted column, in every table. */
+const tableCountsOf = (lines: readonly Line[], words: IntervalWords): TableCount[] =>
+  tablesOf(lines).flatMap(({ header, rows }) =>
+    cellsOf(header).flatMap((cell, index): TableCount[] => {
+      const column = words.columns.find((word) => plain(word.pattern) === plain(cell.text));
+      const values = rows.flatMap((row) => {
+        const value = cellCount(cellsOf(row)[index]?.text ?? "", words);
+        return value === undefined ? [] : [value];
+      });
+      if (column === undefined || values.length === 0) return [];
+      return [{ at: header.start, column: cell.text.trim(), count: Math.max(...values), hours: column.hours }];
+    }),
+  );
+
+type Layout = { readonly headings: readonly number[]; readonly tables: readonly TableCount[]; readonly length: number };
+
+const layoutOf = (text: string, words: IntervalWords): Layout => {
+  const lines = linesOf(text);
+  return { headings: lines.filter((line) => HEADING.test(line.text)).map((line) => line.start), tables: tableCountsOf(lines, words), length: text.length };
+};
+
+/** The heading-delimited section that holds at. */
+const sectionOf = (layout: Layout, at: number): Span => {
+  const index = lastIndexAtOrBefore(layout.headings, at);
+  return { start: layout.headings[index] ?? 0, end: layout.headings[index + 1] ?? layout.length };
+};
+
+const tableMismatch = (layout: Layout, count: PeriodCount): IntervalMismatch | undefined => {
+  const section = sectionOf(layout, count.start);
+  const tables = layout.tables.filter((table) => table.at >= section.start && table.at < section.end && table.hours === count.hours);
+  const table = tables[0];
+  if (tables.length !== 1 || table === undefined || table.count === count.amount) return undefined;
+  return { kind: "table", count, column: table.column, tableCount: table.count };
+};
+
+const mismatchOf = (layout: Layout, statement: Statement): IntervalMismatch | undefined => {
+  const { count, interval } = statement;
+  const neededMinutes = (count.amount - 1) * interval.minutes;
+  if (neededMinutes >= count.hours * MINUTES_PER_HOUR) return { kind: "interval", count, interval, neededHours: neededMinutes / MINUTES_PER_HOUR };
+  return tableMismatch(layout, count);
+};
+
+/** Limited counts that a minimum interval in the same paragraph, or the table of the section, contradicts. */
+export const intervalCountMismatches = (written: string, scopes: readonly Span[], lengths: readonly TimeLength[], words: IntervalWords): IntervalMismatch[] => {
+  const text = asciiDigits(written);
+  const all = periodCounts(text, words);
+  const takenEnds = all.map((count) => count.end);
+  const counts = all.filter((count) => isLimited(text, count, windowStart(text, count.start, takenEnds), words));
+  const intervals = lengths.filter((length) => isMinimumInterval(text, length, words));
+  if (counts.length === 0 || intervals.length === 0) return [];
+  const layout = layoutOf(text, words);
+  return scopes.flatMap((scope) => {
+    const statement = statementIn(scope, counts, intervals);
+    const found = statement === undefined ? undefined : mismatchOf(layout, statement);
+    return found === undefined ? [] : [found];
+  });
+};

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/announced-count.ts

@@ -10,6 +10,7 @@ const countWordsOf = (doc: ProseDocument): CountWords => ({
   anchors: patternsOf(doc, "count-anchor"),
   numbers: patternsOf(doc, "count-number"),
   counters: patternsOf(doc, "count-counter"),
+  frames: patternsOf(doc, "count-frame"),
   hedgesBefore: patternsOf(doc, "count-hedge", "before"),
   hedgesAfter: patternsOf(doc, "count-hedge", "after"),
 });

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 },
+    }));
+};