chaffjs 0.30.0 → 0.31.0

package/src/derived/period-counts.ts

@@ -0,0 +1,178 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import type { Mark } from "../structure/time-marks.ts";
+import { linesOf } from "../structure/lines.ts";
+
+/**
+ * Counts of uses in a period (1日3回, 3 times a day, twice in 24 hours) and the words that make a number a limit (まで,
+ * no more than, 最大量). The words come from the language packages; nothing here knows a language. Pure.
+ */
+export type PeriodWord = Mark & { readonly hours: number };
+
+/** A number written as a word, with its value (three, twice). alone: it counts uses without a counter (twice a day). */
+export type CountWord = { readonly pattern: string; readonly value: number; readonly alone: boolean };
+
+export type PeriodCountWords = {
+  /** Periods: before the number (1日3回) or after the counter (3 times a day). */
+  readonly periods: readonly PeriodWord[];
+  /** What a count of uses is written in (回, times, doses). */
+  readonly counters: readonly string[];
+  readonly numberWords: readonly CountWord[];
+};
+
+export type PeriodCount = Span & { readonly amount: number; readonly hours: number };
+
+const alternation = (words: readonly string[]): string =>
+  [...new Set(words.filter((word) => word !== ""))]
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+/** A word that does not run on from a Latin letter or a digit before it, or into a Latin letter after it. */
+const bounded = (pattern: string): string => `(?<![A-Za-z0-9])(?:${pattern})(?![A-Za-z])`;
+
+const DIGITS = "(?<![\\p{N}.,．])\\p{Nd}+(?:[.．]\\p{Nd}+)?";
+
+const numberAt = (written: string, words: readonly CountWord[]): number =>
+  words.find((word) => word.pattern.toLowerCase() === written.toLowerCase())?.value ?? Number(written.normalize("NFKC"));
+
+const periodsOn = (words: PeriodCountWords, side: "before" | "after"): PeriodWord[] => words.periods.filter((period) => (period.position ?? "before") === side);
+
+const hoursOf = (words: PeriodCountWords, written: string): number =>
+  words.periods.find((period) => period.pattern.toLowerCase() === written.toLowerCase())?.hours ?? 0;
+
+/** The hours of the longest period word the match starts with. */
+const periodHoursIn = (written: string, words: PeriodCountWords): number => {
+  const found = periodsOn(words, "before")
+    .toSorted((left, right) => right.pattern.length - left.pattern.length)
+    .find((period) => written.toLowerCase().startsWith(period.pattern.toLowerCase()));
+  return found?.hours ?? 0;
+};
+
+/** At most this many letters (の, に, あたり) between a period written first and its count: 1日に3回. */
+const JOINER = "[^\\p{N}\\s。、，,.．！？!?]{0,4}";
+
+/** 1日3回: the period first, then the number and the counter. */
+const periodFirst = (text: string, words: PeriodCountWords): PeriodCount[] => {
+  const [periods, counters] = [alternation(periodsOn(words, "before").map((word) => word.pattern)), alternation(words.counters)];
+  if (periods === "" || counters === "") return [];
+  const pattern = new RegExp(`${bounded(periods)}${JOINER}\\s?(?<digits>${DIGITS})\\s?(?:${counters})`, "giu");
+  return [...text.matchAll(pattern)].map((match) => ({
+    start: match.index,
+    end: match.index + match[0].length,
+    amount: Number((match.groups?.["digits"] ?? "").normalize("NFKC")),
+    hours: periodHoursIn(match[0], words),
+  }));
+};
+
+const namesOf = (words: readonly CountWord[], alone: boolean): string => alternation(words.filter((word) => word.alone === alone).map((word) => word.pattern));
+
+/** 3 times a day, twice in 24 hours: the number and the counter first, then the period. */
+const periodLast = (text: string, words: PeriodCountWords): PeriodCount[] => {
+  const [periods, counters] = [alternation(periodsOn(words, "after").map((word) => word.pattern)), alternation(words.counters)];
+  if (periods === "" || counters === "") return [];
+  const [counted, alone] = [namesOf(words.numberWords, false), namesOf(words.numberWords, true)];
+  const number = counted === "" ? `(?<digits>${DIGITS})` : `(?:(?<digits>${DIGITS})|(?<word>${bounded(counted)}))`;
+  const once = alone === "" ? "" : `|(?<alone>${bounded(alone)})`;
+  const pattern = new RegExp(`(?:${number}\\s?${bounded(counters)}${once})\\s+(?<period>${bounded(periods)})`, "giu");
+  return [...text.matchAll(pattern)].map((match) => {
+    const groups = match.groups ?? {};
+    const written = groups["digits"] ?? groups["word"] ?? groups["alone"] ?? "";
+    return {
+      start: match.index,
+      end: match.index + match[0].length,
+      amount: numberAt(written, words.numberWords),
+      hours: hoursOf(words, groups["period"] ?? ""),
+    };
+  });
+};
+
+const FULL_WIDTH_ZERO = 0xff10;
+const ASCII_ZERO = 0x30;
+
+/** Full-width digits as ASCII ones, one for one, so offsets stay (１日 reads as 1日). */
+export const asciiDigits = (text: string): string =>
+  text.replace(/[０-９]/gu, (digit) => String.fromCharCode(digit.charCodeAt(0) - FULL_WIDTH_ZERO + ASCII_ZERO));
+
+/** Counts of uses in a period, in the order written. */
+export const periodCounts = (written: string, words: PeriodCountWords): PeriodCount[] => {
+  const text = asciiDigits(written);
+  return [...periodFirst(text, words), ...periodLast(text, words)]
+    .filter((count) => Number.isFinite(count.amount) && count.amount > 0 && count.hours > 0)
+    .toSorted((left, right) => left.start - right.start);
+};
+
+/** The periods written in text, wherever they stand (the maximum daily dose, 1日の最大量). */
+export const periodsIn = (written: string, words: PeriodCountWords): (Span & { readonly hours: number })[] => {
+  const text = asciiDigits(written);
+  const all = alternation(words.periods.map((word) => word.pattern));
+  if (all === "") return [];
+  return [...text.matchAll(new RegExp(bounded(all), "giu"))].map((match) => ({
+    start: match.index,
+    end: match.index + match[0].length,
+    hours: hoursOf(words, match[0]),
+  }));
+};
+
+const SENTENCE_END = /[。．！？!?\n]|\.(?=\s|$)/gu;
+
+/** How far back the window of a number reaches at most, in characters. */
+const WINDOW_REACH = 120;
+
+/** The index of the last of values (ascending) at or before at, or -1. */
+export const lastIndexAtOrBefore = (values: readonly number[], at: number): number => {
+  let [low, high, found] = [0, values.length - 1, -1];
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    if ((values[middle] ?? Infinity) <= at) [found, low] = [middle, middle + 1];
+    else high = middle - 1;
+  }
+  return found;
+};
+
+/** Where the stretch a number is read in begins: after the sentence end, or the last of takenEnds (ascending), before at. */
+export const windowStart = (text: string, at: number, takenEnds: readonly number[]): number => {
+  const reach = Math.max(0, at - WINDOW_REACH);
+  const ends = [...text.slice(reach, at).matchAll(SENTENCE_END)].map((match) => reach + match.index + match[0].length);
+  return Math.max(reach, takenEnds[lastIndexAtOrBefore(takenEnds, at)] ?? 0, ...ends);
+};
+
+export type LimitWords = {
+  /** Limit words; a word in group limit-negated ("more than") is one only with a negation before it ("do not take more than"). */
+  readonly limits: readonly Mark[];
+  readonly negations: readonly string[];
+};
+
+const NEGATED = "limit-negated";
+const LIMIT_GAP_AFTER = /^[\s、,]*/u;
+const LIMIT_REACH_AFTER = 24;
+
+const containsWord = (text: string, word: string): boolean => new RegExp(bounded(escapeRegExp(word.toLowerCase())), "u").test(text);
+
+/** A limit word in the window before span (no more than, 最大量は), or right after it (まで, を超えて). */
+export const isLimited = (text: string, span: Span, from: number, words: LimitWords): boolean => {
+  const before = text.slice(from, span.start).toLowerCase();
+  const after = text.slice(span.end, span.end + LIMIT_REACH_AFTER).toLowerCase();
+  const gap = LIMIT_GAP_AFTER.exec(after)?.[0].length ?? 0;
+  const negated = words.negations.some((word) => containsWord(before, word));
+  return words.limits.some((limit) =>
+    (limit.position ?? "before") === "before"
+      ? containsWord(before, limit.pattern) && (limit.group !== NEGATED || negated)
+      : after.startsWith(limit.pattern.toLowerCase(), gap),
+  );
+};
+
+const TABLE_ROW = /^\s*\|/u;
+
+const isProse = (line: { readonly text: string } | undefined): boolean => line !== undefined && line.text.trim() !== "" && !TABLE_ROW.test(line.text);
+
+/** Runs of non-blank lines that are not table rows: the paragraphs a statement of use is read in. */
+export const paragraphsOf = (text: string): Span[] =>
+  linesOf(text).reduce<Span[]>((runs, line, index, lines) => {
+    if (!isProse(line)) return runs;
+    const end = line.start + line.text.length;
+    const last = runs.at(-1);
+    if (isProse(lines[index - 1]) && last !== undefined) runs[runs.length - 1] = { start: last.start, end };
+    else runs.push({ start: line.start, end });
+    return runs;
+  }, []);

package/src/derived/time-lengths.ts

@@ -44,8 +44,8 @@ const numberOf = (written: string, numberWords: readonly string[]): number => {
 /** A digit number not inside a longer one, or a number word standing as a word of its own. */
 const numberPattern = (numberWords: readonly string[]): string => {
   const words = alternation(numberWords);
-  const digits = "(?<![\\p{N}.,．/⁄])(\\p{Nd}+(?:[.．]\\p{Nd}+)?)";
-  return words === "" ? digits : `(?:${digits}|(?<![\\p{L}\\p{N}\\p{Pd}])(${words}))`;
+  const digits = "(?<![\\p{N}.,．/⁄])(?<digits>\\p{Nd}+(?:[.．]\\p{Nd}+)?)";
+  return words === "" ? digits : `(?:${digits}|(?<![\\p{L}\\p{N}\\p{Pd}])(?<word>${words}))`;
 };
 
 const SEPARATOR = "[\\s\\-‐]?";
@@ -71,17 +71,18 @@ const smallestUnit = (number: string | undefined, minutes: string | undefined, h
 const hourLengths = (text: string, words: LengthWords): Read[] => {
   const [hours, minutes, halves] = [alternation(words.hourUnits), alternation(words.minuteUnits), alternation(words.halves)];
   if (hours === "") return [];
-  const minutePart = minutes === "" ? "" : `|\\s?(\\p{Nd}{1,2})\\s?(?:${minutes})`;
-  const halfPart = halves === "" ? "" : `|\\s?(${halves})`;
+  const minutePart = minutes === "" ? "" : `|\\s?(?<extra>\\p{Nd}{1,2})\\s?(?:${minutes})`;
+  const halfPart = halves === "" ? "" : `|\\s?(?<half>${halves})`;
   const tail = minutePart === "" && halfPart === "" ? "" : `(?:${minutePart.slice(1)}${halfPart})?`;
   const pattern = new RegExp(`${numberPattern(words.numberWords)}${SEPARATOR}(?:${hours})${tail}`, "giu");
   return [...text.matchAll(pattern)].flatMap((match): Read[] => {
     const end = match.index + match[0].length;
     if (runsOn(text, end)) return [];
-    const amount = numberOf(match[1] ?? match[2] ?? "", words.numberWords);
-    const extra = match[3] === undefined ? 0 : Number(match[3].normalize("NFKC"));
-    const half = match[4] === undefined ? 0 : HALF_HOUR;
-    return [{ span: { start: match.index, end }, minutes: amount * MINUTES_PER_HOUR + extra + half, unit: smallestUnit(match[1], match[3], match[4]) }];
+    const { digits, word, extra, half } = match.groups ?? {};
+    const amount = numberOf(digits ?? word ?? "", words.numberWords);
+    const extraMinutes = extra === undefined ? 0 : Number(extra.normalize("NFKC"));
+    const halfMinutes = half === undefined ? 0 : HALF_HOUR;
+    return [{ span: { start: match.index, end }, minutes: amount * MINUTES_PER_HOUR + extraMinutes + halfMinutes, unit: smallestUnit(digits, extra, half) }];
   });
 };
 
@@ -91,7 +92,9 @@ const minuteLengths = (text: string, words: LengthWords): Read[] => {
   const pattern = new RegExp(`${numberPattern(words.numberWords)}${SEPARATOR}(?:${minutes})`, "giu");
   return [...text.matchAll(pattern)].flatMap((match): Read[] => {
     const end = match.index + match[0].length;
-    return runsOn(text, end) ? [] : [{ span: { start: match.index, end }, minutes: numberOf(match[1] ?? match[2] ?? "", words.numberWords), unit: 1 }];
+    return runsOn(text, end)
+      ? []
+      : [{ span: { start: match.index, end }, minutes: numberOf(match.groups?.["digits"] ?? match.groups?.["word"] ?? "", words.numberWords), unit: 1 }];
   });
 };
 

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/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/capacity-runtime.ts

@@ -0,0 +1,128 @@
+// capacity-runtime-mismatch: a stated runtime longer than the battery capacity divided by the consumption (derived/battery-runtime.ts).
+// Values are read from table rows (item name, value) and from "item name: value" lines. One key-value table and the labelled
+// lines of one section are one device; a wider table is one device per column.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import {
+  capacityRuntimeMismatches,
+  isPeakHeading,
+  labelOf,
+  splitCondition,
+  valueOf,
+  type BatteryWords,
+  type ElectricUnit,
+  type Entry,
+  type Family,
+  type Marker,
+} from "../derived/battery-runtime.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const FAMILIES: readonly Family[] = ["charge", "current", "energy", "power"];
+const isFamily = (group: string | undefined): group is Family => FAMILIES.some((family) => family === group);
+
+type Lexicons = ProseDocument["lexicons"];
+
+const markersOf = (lexicons: Lexicons, id: string, group?: string): Marker[] =>
+  (lexicons[id] ?? [])
+    .filter((entry) => group === undefined || entry.group === group)
+    .map((entry) => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+export const batteryWordsOf = (lexicons: Lexicons): BatteryWords => {
+  const labels = (lexicons["battery-label"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? "" }));
+  const bounds = markersOf(lexicons, "battery-label", "bound");
+  return {
+    electric: (lexicons["battery-unit"] ?? []).flatMap((entry): ElectricUnit[] =>
+      isFamily(entry.group) ? [{ pattern: entry.pattern, weight: entry.weight ?? 1, family: entry.group }] : [],
+    ),
+    time: (lexicons["unit-time"] ?? []).map((entry) => ({ pattern: entry.pattern, weight: entry.weight ?? 1 })),
+    approximate: markersOf(lexicons, "approximate-marker").filter((marker) => !bounds.some((bound) => bound.pattern === marker.pattern)),
+    bounds,
+    connectors: (lexicons["range-connector"] ?? []).map((entry) => entry.pattern),
+    labels,
+  };
+};
+
+const EMPHASIS = /[*`]/gu;
+const plain = (text: string): string => text.replace(EMPHASIS, "");
+
+type Slot = { readonly key: string; readonly entry: Entry };
+
+const entryOf = (label: string, value: Cell, words: BatteryWords, columnPeak: boolean): Entry | undefined => {
+  const named = labelOf(plain(label), words);
+  const text = plain(value.text).trim();
+  const read = named === undefined ? undefined : valueOf(text, named.role, words);
+  if (named === undefined || read === undefined) return undefined;
+  const lead = value.text.length - value.text.trimStart().length;
+  return {
+    ...named,
+    peak: named.peak || read.peak || columnPeak,
+    condition: named.condition === "" ? splitCondition(text).condition : named.condition,
+    reading: read.reading,
+    start: value.start + lead,
+    text,
+  };
+};
+
+const sectionAt = (doc: ProseDocument, offset: number): number => doc.sections.findLastIndex((section) => section.span.start <= offset);
+
+const TWO_COLUMNS = 2;
+
+const tableSlots = (doc: ProseDocument, words: BatteryWords): Slot[] =>
+  tablesOf(linesOf(doc.source)).flatMap((table) => {
+    const headings = cellsOf(table.header);
+    const wide = headings.length > TWO_COLUMNS;
+    return table.rows.flatMap((row) => {
+      const [label, ...values] = cellsOf(row);
+      if (label === undefined) return [];
+      return values.flatMap((value, index): Slot[] => {
+        const column = index + 1;
+        const peak = wide && isPeakHeading(plain(headings[column]?.text ?? ""), words);
+        const entry = entryOf(label.text, value, words, peak);
+        const key = wide ? `table ${table.header.start} ${column}` : `section ${sectionAt(doc, row.start)}`;
+        return entry === undefined || (!wide && column > 1) ? [] : [{ key, entry }];
+      });
+    });
+  });
+
+const LIST_MARKER = /^\s*(?:[-*+]|\d+[.)])\s+/u;
+const COLON = /[:：]/u;
+const MAX_LABEL = 80;
+
+/** "Battery life: up to 10 hours", "- 消費電流：500 mA". */
+const lineSlot = (doc: ProseDocument, line: Line, words: BatteryWords): Slot[] => {
+  const body = line.text.slice(LIST_MARKER.exec(line.text)?.[0].length ?? 0);
+  const colon = COLON.exec(body)?.index;
+  if (colon === undefined) return [];
+  const label = body.slice(0, colon).trim();
+  const value = body.slice(colon + 1).trim();
+  if (label === "" || label.length > MAX_LABEL || value === "") return [];
+  const start = line.start + line.text.lastIndexOf(value);
+  const entry = entryOf(label, { start, end: start + value.length, text: value }, words, false);
+  return entry === undefined ? [] : [{ key: `section ${sectionAt(doc, line.start)}`, entry }];
+};
+
+const HOUR_DECIMALS = 100;
+
+export const capacityRuntime: Detector = (doc): Finding[] => {
+  const words = batteryWordsOf(doc.lexicons);
+  const lines = linesOf(doc.prose ?? doc.source).filter((line) => !line.text.includes("|"));
+  const slots = [...tableSlots(doc, words), ...lines.flatMap((line) => lineSlot(doc, line, words))];
+  const keys = [...new Set(slots.map((slot) => slot.key))];
+  return keys
+    .flatMap((key) => capacityRuntimeMismatches(slots.filter((slot) => slot.key === key).map((slot) => slot.entry)))
+    .map((mismatch) => ({
+      rule: "capacity-runtime-mismatch",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, mismatch.runtime.start),
+      values: {
+        capacity: mismatch.capacity.text,
+        consumption: mismatch.consumption.text,
+        runtime: mismatch.runtime.text,
+        expected: Math.round(mismatch.idealHours * HOUR_DECIMALS) / HOUR_DECIMALS,
+        offset: mismatch.runtime.start,
+      },
+    }));
+};

package/src/detectors/contact-variant.ts

@@ -0,0 +1,24 @@
+// contact-variant: one email address or postal address written two ways in one document (contacts/emails.ts,
+// contacts/addresses.ts). The address labels come from the language's address-label lexicon.
+import { addressVariants } from "../contacts/addresses.ts";
+import { emailVariants } from "../contacts/emails.ts";
+import type { Variant, Writing } from "../contacts/variants.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding } from "../plugin.ts";
+
+const findingOf = (source: string, { writing, other }: Variant<Writing>, variant?: string): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: quoteAt(source, writing.offset),
+  values: { written: writing.written, other: other.written, offset: writing.offset },
+  ...(variant === undefined ? {} : { variant }),
+});
+
+export const contactVariant: Detector = (doc, options): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const emails = emailVariants(text).map((found) => findingOf(doc.source, found));
+  const addresses = addressVariants(text, options.lexicon ?? []).map(({ variant, found }) => findingOf(doc.source, found, variant));
+  return [...emails, ...addresses].toSorted((a, b) => Number(a.values?.["offset"]) - Number(b.values?.["offset"]));
+};

package/src/detectors/count-over-capacity.ts

@@ -0,0 +1,37 @@
+// A stated capacity smaller than a stated number registered, invited or attending (count-over-capacity). The words come
+// from the language package: capacity-label, headcount-label, headcount-unit and capacity-exception.
+import { countsOverCapacity, type CapacityWords, type CountMark } from "../structure/capacity-count.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const marksOf = (doc: ProseDocument, lexicon: string): CountMark[] =>
+  (doc.lexicons[lexicon] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position, group: entry.group }));
+
+const exceptionsOf = (doc: ProseDocument, group: string): string[] =>
+  (doc.lexicons["capacity-exception"] ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+const capacityWords = (doc: ProseDocument): CapacityWords => ({
+  capacities: marksOf(doc, "capacity-label"),
+  counts: marksOf(doc, "headcount-label"),
+  units: marksOf(doc, "headcount-unit"),
+  overflows: exceptionsOf(doc, "overflow"),
+  perSession: exceptionsOf(doc, "per-session"),
+  otherOccasions: exceptionsOf(doc, "other-occasion"),
+  negations: exceptionsOf(doc, "negation"),
+});
+
+/** The prose with its tables put back, so code is not read; offsets are the source's. */
+export const countOverCapacity: Detector = (doc): Finding[] =>
+  countsOverCapacity(
+    proseAndTablesOf(doc),
+    capacityWords(doc),
+    doc.sections.map((section) => section.span),
+  ).map((issue) => ({
+    rule: "count-over-capacity",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));

package/src/detectors/date-outside-period.ts

@@ -6,13 +6,14 @@ import { quoteAt } from "./structure-tree.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
-/** 期間の語、期間の外に置く語、文書の仕事の期間の語、締め切りの語、概要の節の見出しの語、範囲の記号（range-connector、range-opener、range-frame の間の語）、月と曜日の名は語彙表から取る。 */
+/** 期間の語、期間の外に置く語、文書の仕事の期間の語、締め切りの語、期間の後に来てよい仕事の語、概要の節の見出しの語、範囲の記号（range-connector、range-opener、range-frame の間の語）、月と曜日の名は語彙表から取る。 */
 const wordsOf = (doc: ProseDocument): OutsideWords => ({
   labels: patternsOf(doc, "period-label"),
   terms: patternsOf(doc, "period-term-label"),
   asides: patternsOf(doc, "period-aside"),
   deadlines: patternsOf(doc, "period-deadline"),
   overviews: patternsOf(doc, "period-overview-heading"),
+  afterTerm: patternsOf(doc, "period-after-term"),
   connectors: [
     ...patternsOf(doc, "range-connector"),
     ...patternsOf(doc, "range-opener"),

package/src/detectors/date-stamp-order.ts

@@ -0,0 +1,28 @@
+// date-stamp-order: an established date later than the last update, on the document's stamp lines (structure/stamp-order.ts).
+// The stamp words come from the language's stamp-order-label lexicon, grouped into established and updated.
+import type { Detector, Finding } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { stampOrderIssues } from "../structure/stamp-order.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+export const dateStampOrder: Detector = (doc, options): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const labels = options.lexicon ?? [];
+  const wordsOf = (group: string): string[] => labels.filter((entry) => entry.group === group).map((entry) => entry.pattern);
+  const dates = inDocumentOrder(doc.structure).flatMap((node) =>
+    node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : [],
+  );
+  return stampOrderIssues(proseAndTablesOf(doc), dates, { established: wordsOf("established"), updated: wordsOf("updated") }).map(({ offset, values }) => {
+    const { side, ...dated } = values;
+    return {
+      rule: "",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, offset),
+      values: { ...dated, offset },
+      ...(side === undefined ? {} : { variant: String(side) }),
+    };
+  });
+};