chaffjs 0.29.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/session-hours.ts

@@ -0,0 +1,62 @@
+import type { Span } from "../plugin.ts";
+import type { Mark } from "../structure/time-marks.ts";
+import { labelOf, readScopes, within, type TimeLength } from "./time-lengths.ts";
+
+/**
+ * A number of sessions times the length of one against the stated total (90分×15回（計24時間）, 15 sessions of 90
+ * minutes, 24 hours in total). Read in one line, or in a list whose items say it together, holding exactly one count of
+ * two or more sessions, one length of a session and one total. A total written as approximate (約24時間, about 24 hours)
+ * may differ by less than the smallest unit it is written in. Pure.
+ */
+export type Count = Span & { readonly amount: number };
+
+export type SessionHoursWords = { readonly totals: readonly Mark[]; readonly approximate: readonly Mark[] };
+
+export type SessionHoursMismatch = {
+  readonly count: Count;
+  readonly length: TimeLength;
+  readonly total: TimeLength;
+  /** The count times the length, in minutes. */
+  readonly expected: number;
+};
+
+const overlaps = (left: Span, right: Span): boolean => left.start < right.end && right.start < left.end;
+
+type Statement = { readonly count: Count; readonly length: TimeLength; readonly total: TimeLength };
+
+/** The length with a rough mark written before it taken in (計約24時間 reads its label past 約). */
+const withRoughMark = (text: string, length: TimeLength, words: SessionHoursWords): Span => {
+  const mark = labelOf(text, length, words.approximate);
+  return mark !== undefined && mark.end <= length.start ? { start: mark.start, end: length.end } : length;
+};
+
+const statementIn = (text: string, scope: Span, counts: readonly Count[], lengths: readonly TimeLength[], words: SessionHoursWords) => {
+  const inCounts = counts.filter((count) => count.amount > 1 && within(count, scope));
+  const inLengths = lengths.filter((length) => within(length, scope));
+  const totals = inLengths.filter((length) => labelOf(text, withRoughMark(text, length, words), words.totals) !== undefined);
+  const sessions = inLengths.filter((length) => !totals.includes(length));
+  const [count, length, total] = [inCounts[0], sessions[0], totals[0]];
+  if (inCounts.length !== 1 || sessions.length !== 1 || totals.length !== 1 || count === undefined || length === undefined || total === undefined)
+    return undefined;
+  if (overlaps(count, length) || labelOf(text, length, words.approximate) !== undefined) return undefined;
+  return { count, length, total } satisfies Statement;
+};
+
+const allowanceOf = (text: string, total: TimeLength, words: SessionHoursWords): number =>
+  labelOf(text, total, words.approximate) === undefined ? 0 : total.unit;
+
+/** Sessions whose count times length is not the stated total. counts are the written counts of sessions (15回, 15 sessions). */
+export const sessionHoursMismatches = (
+  text: string,
+  source: string,
+  sentences: readonly Span[],
+  counts: readonly Count[],
+  lengths: readonly TimeLength[],
+  words: SessionHoursWords,
+): SessionHoursMismatch[] =>
+  readScopes(text, source, { sentences, times: [] }, (scope) => statementIn(text, scope, counts, lengths, words)).flatMap(({ count, length, total }) => {
+    const expected = count.amount * length.minutes;
+    const allowance = allowanceOf(text, total, words);
+    if (allowance === 0 ? expected === total.minutes : Math.abs(expected - total.minutes) < allowance) return [];
+    return [{ count, length, total, expected }];
+  });

package/src/derived/time-lengths.ts

@@ -0,0 +1,229 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { isWordAt, wordOffsets, type Mark } from "../structure/time-marks.ts";
+import { linesOf } from "../structure/lines.ts";
+
+/**
+ * Lengths of time in hours and minutes (8時間, 7時間30分, 90分, 1-hour, one-hour, 7.5 hours), the words written beside
+ * them (実働8時間, 8 hours a day), and the stretches of text a statement of hours is read in. The words come from the
+ * language packages; nothing here knows a language. Pure.
+ */
+export type TimeLength = Span & {
+  readonly minutes: number;
+  /** The smallest unit the length is written in, in minutes: 60 for 24時間, 1 for 90分 or 7時間30分, 30 for 7時間半. */
+  readonly unit: number;
+};
+
+export type LengthWords = {
+  readonly hourUnits: readonly string[];
+  readonly minuteUnits: readonly string[];
+  /** What written right after the hour unit adds half an hour (7時間半). */
+  readonly halves: readonly string[];
+  /** Numbers written as words, in order from one. */
+  readonly numberWords: readonly string[];
+};
+
+const MINUTES_PER_HOUR = 60;
+const HALF_HOUR = 30;
+
+const alternation = (words: readonly string[]): string =>
+  words
+    .filter((word) => word !== "")
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+const LATIN_END = /[a-z]$/iu;
+const LATIN_START = /^[a-z]/iu;
+
+const numberOf = (written: string, numberWords: readonly string[]): number => {
+  const position = numberWords.findIndex((word) => word.toLowerCase() === written.toLowerCase());
+  return position >= 0 ? position + 1 : Number(written.normalize("NFKC"));
+};
+
+/** 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}.,．/⁄])(?<digits>\\p{Nd}+(?:[.．]\\p{Nd}+)?)";
+  return words === "" ? digits : `(?:${digits}|(?<![\\p{L}\\p{N}\\p{Pd}])(?<word>${words}))`;
+};
+
+const SEPARATOR = "[\\s\\-‐]?";
+
+type Read = { readonly span: Span; readonly minutes: number; readonly unit: number };
+
+/** A Latin unit runs on into a longer word ("8 hoursx") or a letter-led tail: not a length. */
+const runsOn = (text: string, end: number): boolean => LATIN_END.test(text.slice(end - 1, end)) && LATIN_START.test(text.charAt(end));
+
+const DECIMAL_BASE = 10;
+
+/** 7.5 hours is written to a tenth of an hour, 6 minutes. */
+const hourStep = (number: string | undefined): number => {
+  const decimals = (number ?? "").normalize("NFKC").split(".")[1]?.length ?? 0;
+  return MINUTES_PER_HOUR / DECIMAL_BASE ** decimals;
+};
+
+const smallestUnit = (number: string | undefined, minutes: string | undefined, half: string | undefined): number => {
+  if (minutes !== undefined) return 1;
+  return half === undefined ? hourStep(number) : Math.min(HALF_HOUR, hourStep(number));
+};
+
+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?(?<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 { 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) }];
+  });
+};
+
+const minuteLengths = (text: string, words: LengthWords): Read[] => {
+  const minutes = alternation(words.minuteUnits);
+  if (minutes === "") return [];
+  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.groups?.["digits"] ?? match.groups?.["word"] ?? "", words.numberWords), unit: 1 }];
+  });
+};
+
+const overlaps = (left: Span, right: Span): boolean => left.start < right.end && right.start < left.end;
+
+/** Lengths of time in hours and minutes, in the order written. A minutes-only reading inside an hours one is dropped. */
+export const timeLengths = (text: string, words: LengthWords): TimeLength[] => {
+  const hours = hourLengths(text, words);
+  const minutes = minuteLengths(text, words).filter((read) => !hours.some((hour) => overlaps(hour.span, read.span)));
+  return [...hours, ...minutes]
+    .filter((read) => Number.isFinite(read.minutes) && read.minutes > 0)
+    .map((read) => ({ ...read.span, minutes: read.minutes, unit: read.unit }))
+    .toSorted((left, right) => left.start - right.start);
+};
+
+const longestFirst = (marks: readonly Mark[]): Mark[] => marks.toSorted((left, right) => right.pattern.length - left.pattern.length);
+
+const LABEL_GAP_BEFORE = new Set([" ", "\t", "\u3000", ":", "："]);
+const LABEL_GAP_AFTER = /^\s*/u;
+const LOOK_AROUND = 40;
+
+const lower = (text: string): string => text.toLowerCase();
+
+/** Where the separators that may stand between a label and its length (休憩：1時間、Break: 1 hour) begin, reading back from at. */
+const gapStart = (text: string, at: number): number => {
+  let start = at;
+  while (start > 0 && LABEL_GAP_BEFORE.has(text.charAt(start - 1))) start -= 1;
+  return start;
+};
+
+/** Whether pattern is written as a word at offset at, case aside. Reads a window around it, not the whole text. */
+const isLabelAt = (text: string, at: number, pattern: string): boolean => {
+  if (at < 0) return false;
+  const from = Math.max(0, at - 1);
+  return isWordAt(lower(text.slice(from, at + pattern.length + 1)), at - from, lower(pattern));
+};
+
+/** The label written right before span (after separators only), or undefined. */
+const labelBefore = (text: string, span: Span, marks: readonly Mark[]): Span | undefined => {
+  const end = gapStart(text, span.start);
+  if (span.start - end > LOOK_AROUND) return undefined;
+  const found = longestFirst(marks.filter((mark) => (mark.position ?? "before") === "before")).find((mark) =>
+    isLabelAt(text, end - mark.pattern.length, mark.pattern),
+  );
+  return found === undefined ? undefined : { start: end - found.pattern.length, end };
+};
+
+/** The label written right after span (after white space only), or undefined. */
+const labelAfter = (text: string, span: Span, marks: readonly Mark[]): Span | undefined => {
+  const start = span.end + (LABEL_GAP_AFTER.exec(text.slice(span.end, span.end + LOOK_AROUND))?.[0].length ?? 0);
+  const found = longestFirst(marks.filter((mark) => mark.position === "after")).find((mark) => isLabelAt(text, start, mark.pattern));
+  return found === undefined ? undefined : { start, end: start + found.pattern.length };
+};
+
+/** The label beside span, before or after it. */
+export const labelOf = (text: string, span: Span, marks: readonly Mark[]): Span | undefined => labelBefore(text, span, marks) ?? labelAfter(text, span, marks);
+
+/** Where the words of marks are written inside scope. */
+export const mentionsIn = (text: string, scope: Span, marks: readonly Mark[]): Span[] => {
+  const inside = lower(text.slice(scope.start, scope.end));
+  return [...new Set(marks.map((mark) => lower(mark.pattern)))].flatMap((pattern) =>
+    wordOffsets(inside, pattern).map((at) => ({ start: scope.start + at, end: scope.start + at + pattern.length })),
+  );
+};
+
+export const within = (inner: Span, outer: Span): boolean => inner.start >= outer.start && inner.end <= outer.end;
+
+const LIST_ITEM = /^\s*(?:[-*+・•]|\d{1,3}[.)])\s/u;
+
+type Paragraph = { readonly span: Span; readonly lines: readonly Span[]; readonly listed: boolean };
+
+type Run = { readonly lines: Span[]; listed: boolean };
+
+/** Runs of non-blank lines. listed: every line of the run is a list item in the source. */
+const paragraphsOf = (text: string, source: string): Paragraph[] => {
+  const listedLines = linesOf(source).map((line) => LIST_ITEM.test(line.text));
+  const runs: Run[] = [{ lines: [], listed: true }];
+  linesOf(text).forEach((line, index) => {
+    const run = runs[runs.length - 1];
+    if (line.text.trim() === "") runs.push({ lines: [], listed: true });
+    else if (run !== undefined) {
+      run.lines.push({ start: line.start, end: line.start + line.text.length });
+      run.listed = run.listed && listedLines[index] === true;
+    }
+  });
+  return runs.flatMap(({ lines, listed }) => {
+    const [first, last] = [lines[0], lines[lines.length - 1]];
+    return first === undefined || last === undefined ? [] : [{ span: { start: first.start, end: last.end }, lines, listed }];
+  });
+};
+
+const clipped = (inner: Span, outer: Span): Span => ({ start: Math.max(inner.start, outer.start), end: Math.min(inner.end, outer.end) });
+
+/** A sentence that ends on a clock time ("5:30 p.m. (a one-hour break") runs on into the next. */
+const joinedAtTimes = (sentences: readonly Span[], times: readonly Span[]): Span[] =>
+  sentences.reduce<Span[]>((joined, sentence) => {
+    const last = joined[joined.length - 1];
+    if (last !== undefined && times.some((time) => time.start < last.end && last.end <= time.end)) {
+      joined[joined.length - 1] = { start: last.start, end: sentence.end };
+    } else joined.push(sentence);
+    return joined;
+  }, []);
+
+/** The sentences of a line, clipped to it; the line itself when no sentence lies on it. */
+const sentencesOn = (line: Span, sentences: readonly Span[]): Span[] => {
+  const on = sentences.filter((sentence) => overlaps(sentence, line)).map((sentence) => clipped(sentence, line));
+  return on.length === 0 ? [line] : on;
+};
+
+/**
+ * The stretches a statement is read in: each sentence of a line, and a list whose items say it together (勤務時間 /
+ * 休憩 / 実働 on three items). read returns undefined when a stretch does not hold exactly one statement; a list that
+ * reads as one is not read again line by line.
+ */
+export const readScopes = <T>(
+  text: string,
+  source: string,
+  split: { readonly sentences: readonly Span[]; readonly times: readonly Span[] },
+  read: (scope: Span) => T | undefined,
+): T[] => {
+  const sentences = joinedAtTimes(split.sentences, split.times);
+  return paragraphsOf(text, source).flatMap((paragraph) => {
+    const whole = paragraph.listed && paragraph.lines.length > 1 ? read(paragraph.span) : undefined;
+    if (whole !== undefined) return [whole];
+    return paragraph.lines.flatMap((line) =>
+      sentencesOn(line, sentences).flatMap((scope) => {
+        const result = read(scope);
+        return result === undefined ? [] : [result];
+      }),
+    );
+  });
+};

package/src/derived/unit-counts.ts

@@ -0,0 +1,18 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+export type UnitCount = Span & { readonly amount: number };
+
+const LATIN_UNIT = /^[a-z]+$/iu;
+
+/** 数字と単位（3泊、3 nights、15回）。英字の単位は語の切れ目まで。Pure. */
+export const numeralCounts = (text: string, units: readonly string[]): UnitCount[] =>
+  units.flatMap((unit) => {
+    const tail = LATIN_UNIT.test(unit) ? "(?![\\p{L}\\p{N}])" : "";
+    const pattern = new RegExp(`(?<![\\p{N}.,])(\\p{Nd}+)\\s?${escapeRegExp(unit)}${tail}`, "giu");
+    return [...text.matchAll(pattern)].map((match) => ({
+      start: match.index,
+      end: match.index + match[0].length,
+      amount: Number((match[1] ?? "").normalize("NFKC")),
+    }));
+  });

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