chaffjs 0.30.0 → 0.32.0

package/src/derived/durations.ts

@@ -1,52 +1,123 @@
 import type { Span } from "../plugin.ts";
 import { bySentence } from "./sentence-buckets.ts";
 import { calendarDateOf, dateOf, shifted, valueOf, type DurationUnit } from "./date-arithmetic.ts";
+import { markedPair, type MarkText } from "./marked-dates.ts";
 
 /**
  * 始まりと期間と終わりを一つの文に書いたもの（「4月1日から3か月間（6月30日まで）」"for 3 months from April 1, 2026 (until
  * June 30, 2026)"）。始まりに期間を足した日が終わりと合わなければ言う。期間の数え方は三通りある。終わりの日を含めて数える
  * （4月1日から3か月間は6月30日まで）か、含めずに数える（7月1日まで）か、初日を数えずに期間が過ぎた日（「到達日から2週間が経過した日
  * （4月16日）」）。どれとも合わないときだけ言う。
- * 文に日付がちょうど二つ、期間がちょうど一つのときだけ読む。それより多い文は、どの日付とどの期間が組なのか決まらない。
+ * 文に期間がちょうど一つのときだけ読む。日付が三つ以上なら、始まりと終わりを語で印した組（「7月1日から」「（7月31日まで）」）だけを
+ * 読む。印が無ければ、どの日付とどの期間が組なのか決まらない。
+ * 範囲のすぐ後ろの括弧に書いた期間（「9月1日〜9月30日（30日間）」）は範囲そのものの長さで、期間が過ぎた日を終わりに書くことはない。
  */
 export type DatedValue = Span & { readonly value: string };
 
-export type Duration = Span & { readonly amount: number; readonly unit: DurationUnit };
+export type Duration = Span & {
+  readonly amount: number;
+  readonly unit: DurationUnit;
+  /** 名詞の前に書いた期間（a 7-day returns window）。決まりの長さのことが多く、二つの日付の間の長さとは限らない。 */
+  readonly attributive?: boolean;
+};
 
 export type DurationMismatch = { readonly start: DatedValue; readonly duration: Duration; readonly end: DatedValue; readonly expected: string };
 
-/** 期間を足した日と、その前の日（終わりを含めて数える）と、次の日（初日を数えずに期間が過ぎた日）。 */
-const expectedEnds = (start: Date, duration: Duration): Date[] => {
+/** 期間を足した日と、その前の日（終わりを含めて数える）と、次の日（初日を数えずに期間が過ぎた日。範囲の長さには無い）。 */
+const expectedEnds = (start: Date, duration: Duration, rangeLength: boolean): Date[] => {
   const exclusive = shifted(start, duration.amount, duration.unit);
-  return [shifted(exclusive, -1, "day"), exclusive, shifted(exclusive, 1, "day")];
+  const ends = [shifted(exclusive, -1, "day"), exclusive];
+  return rangeLength ? ends : [...ends, shifted(exclusive, 1, "day")];
+};
+
+/** 文書と、範囲の間の語（〜、–、to）と、日付の後ろの括弧に添える曜日（（火）、(Wed)）。 */
+export type RangeText = { readonly source: string; readonly joiners: readonly string[]; readonly weekdays: readonly string[] };
+
+const LEADING_BRACKET = /^\s*[(（]([^()（）\n]+)[)）]/u;
+const OPEN_BRACKET = /^\s*[(（]\s*$/u;
+const CLOSE_BRACKET = /^\s*[)）]/u;
+
+/** 先頭の曜日の括弧（（火）、(Wednesday)）を除いた残り。曜日の名の頭だけを書いたものも曜日。 */
+const withoutWeekday = (text: string, weekdays: readonly string[]): string => {
+  const inside = LEADING_BRACKET.exec(text);
+  if (inside === null) return text;
+  const word = (inside[1] ?? "").trim().toLowerCase();
+  return word !== "" && weekdays.some((weekday) => weekday.toLowerCase().startsWith(word)) ? text.slice(inside[0].length) : text;
+};
+
+/** 範囲（9月1日〜9月30日、July 1 – August 31）の終わりのすぐ後ろの括弧に、期間だけを書いた（（30日間）、(30 days)）。 */
+export const isRangeLength = (text: RangeText, range: readonly [Span, Span], duration: Span): boolean => {
+  const { source, ...words } = text;
+  const [first, end] = range;
+  if (first.end > end.start || end.end > duration.start) return false;
+  const joint = withoutWeekday(source.slice(first.end, end.start), words.weekdays).trim().toLowerCase();
+  return (
+    words.joiners.some((joiner) => joiner.toLowerCase() === joint) &&
+    OPEN_BRACKET.test(withoutWeekday(source.slice(end.end, duration.start), words.weekdays)) &&
+    CLOSE_BRACKET.test(source.slice(duration.end))
+  );
 };
 
 /** 年まで書いた二つの日付は、早いほうを始まりにする（「7月1日まで、4月1日から3か月」）。月日だけなら書いた順（年をまたぐことがある）。 */
 const ordered = (first: DatedValue, second: DatedValue, withYear: boolean): [DatedValue, DatedValue] =>
   withYear && second.value < first.value ? [second, first] : [first, second];
 
-const mismatchOf = (written: readonly [DatedValue, DatedValue], duration: Duration): DurationMismatch | undefined => {
+/** 名詞の前の期間は、日付の間がその二倍までのときだけ組にする。75日の間に書いた 7-day の窓は別の長さ。 */
+export const ATTRIBUTIVE_REACH = 2;
+
+/** 書いた終わりの日。年の無い月日で始まりより前なら、翌年。 */
+const endDateOf = (start: Date, end: DatedValue, withYear: boolean): Date | undefined => {
+  const written = calendarDateOf(end.value);
+  if (written === undefined) return undefined;
+  const date = dateOf(written);
+  return withYear || date >= start ? date : shifted(date, 1, "year");
+};
+
+const beyondReach = (start: Date, end: DatedValue, duration: Duration, withYear: boolean): boolean => {
+  if (duration.attributive !== true) return false;
+  const endDate = endDateOf(start, end, withYear);
+  return endDate === undefined || endDate > shifted(start, duration.amount * ATTRIBUTIVE_REACH, duration.unit);
+};
+
+const mismatchOf = (written: readonly [DatedValue, DatedValue], duration: Duration, rangeLength: boolean): DurationMismatch | undefined => {
   const [firstDate, secondDate] = [calendarDateOf(written[0].value), calendarDateOf(written[1].value)];
   if (firstDate === undefined || secondDate === undefined || (firstDate.year === undefined) !== (secondDate.year === undefined)) return undefined;
   const withYear = firstDate.year !== undefined;
   const [start, end] = ordered(written[0], written[1], withYear);
   const startDate = calendarDateOf(start.value);
   if (startDate === undefined) return undefined;
-  const ends = expectedEnds(dateOf(startDate), duration);
+  const ends = expectedEnds(dateOf(startDate), duration, rangeLength);
   const [inclusive] = ends;
   if (inclusive === undefined || ends.some((candidate) => valueOf(candidate, withYear) === end.value)) return undefined;
+  if (beyondReach(dateOf(startDate), end, duration, withYear)) return undefined;
   return { start, duration, end, expected: valueOf(inclusive, withYear) };
 };
 
+/** 年まで書いた組で、印した終わりが始まりより前なら、期間の向きが逆（date-range-reversed が言う）。 */
+const reversed = ([start, end]: readonly [DatedValue, DatedValue]): boolean =>
+  calendarDateOf(start.value)?.year !== undefined && calendarDateOf(end.value)?.year !== undefined && end.value < start.value;
+
+const pairOf = (sentence: Span, inDates: readonly DatedValue[], duration: Duration, text: MarkText): readonly [DatedValue, DatedValue] | undefined => {
+  const [first, second] = inDates;
+  if (inDates.length === 2 && first !== undefined && second !== undefined) return [first, second];
+  const marked = inDates.length > 2 ? markedPair(text, sentence, inDates, duration) : undefined;
+  return marked === undefined || reversed(marked) ? undefined : marked;
+};
+
 /** 一つの文の中の、始まり・期間・終わり。 */
-export const durationMismatches = (sentences: readonly Span[], dates: readonly DatedValue[], durations: readonly Duration[]): DurationMismatch[] => {
+export const durationMismatches = (
+  sentences: readonly Span[],
+  dates: readonly DatedValue[],
+  durations: readonly Duration[],
+  text: RangeText & MarkText,
+): DurationMismatch[] => {
   const datesIn = bySentence(sentences, dates);
   return [...bySentence(sentences, durations).entries()].flatMap(([index, inDurations]) => {
-    const inDates = datesIn.get(index) ?? [];
-    const [first, second] = inDates;
     const [duration] = inDurations;
-    if (inDates.length !== 2 || inDurations.length !== 1 || first === undefined || second === undefined || duration === undefined) return [];
-    const mismatch = mismatchOf([first, second], duration);
+    const sentence = sentences[index];
+    if (inDurations.length !== 1 || duration === undefined || sentence === undefined) return [];
+    const pair = pairOf(sentence, datesIn.get(index) ?? [], duration, text);
+    const mismatch = pair === undefined ? undefined : mismatchOf(pair, duration, isRangeLength(text, pair, duration));
     return mismatch === undefined ? [] : [mismatch];
   });
 };

package/src/derived/hours-and-minutes.ts

@@ -0,0 +1,41 @@
+/**
+ * A computed length of time as whole hours and minutes, and which of the two a message writes: 4時間15分 / 4 hours 15
+ * minutes, 7時間 / 7 hours, 45分 / 45 minutes. A part of a minute is rounded to the nearest minute (half up).
+ */
+export type HoursAndMinutes = {
+  readonly hours: number;
+  readonly minutes: number;
+  /** "hours" when the minutes are 0, "minutes" under an hour (0 too), else "hours-minutes". */
+  readonly shape: "hours" | "minutes" | "hours-minutes";
+};
+
+const MINUTES_PER_HOUR = 60;
+
+/** undefined for a length that cannot be written: negative, NaN or infinite. */
+export const hoursAndMinutes = (totalMinutes: number): HoursAndMinutes | undefined => {
+  if (!Number.isFinite(totalMinutes) || totalMinutes < 0) return undefined;
+  const whole = Math.round(totalMinutes);
+  const hours = Math.floor(whole / MINUTES_PER_HOUR);
+  const minutes = whole % MINUTES_PER_HOUR;
+  if (hours === 0) return { hours, minutes, shape: "minutes" };
+  return { hours, minutes, shape: minutes === 0 ? "hours" : "hours-minutes" };
+};
+
+/** Whether a computed length would be written as the stated one: a message saying "8 hours, but 8 hours is written" says nothing. */
+export const readsTheSame = (computedMinutes: number, statedMinutes: number): boolean => Math.round(computedMinutes) === Math.round(statedMinutes);
+
+const HOUR_DECIMALS = 100;
+
+/** The computed length for a message: decimal hours as `expected` (kept for JSON readers), hours and minutes to write. */
+export type ComputedLength = {
+  readonly shape: HoursAndMinutes["shape"];
+  readonly values: { readonly expected: number; readonly hours: number; readonly minutes: number };
+};
+
+/** undefined when the computed length cannot be written, or would be written as the stated one. */
+export const computedLength = (computedMinutes: number, statedMinutes: number): ComputedLength | undefined => {
+  const length = hoursAndMinutes(computedMinutes);
+  if (length === undefined || readsTheSame(computedMinutes, statedMinutes)) return undefined;
+  const expected = Math.round((computedMinutes / MINUTES_PER_HOUR) * HOUR_DECIMALS) / HOUR_DECIMALS;
+  return { shape: length.shape, values: { expected, hours: length.hours, minutes: length.minutes } };
+};

package/src/derived/hyphenated-counts.ts

@@ -0,0 +1,38 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+/** A figure joined to its unit by a hyphen ("a 3-month trial", "a 2-night, 3-day tour"), with the unit as written in the list. */
+export type HyphenatedCount = Span & { readonly amount: number; readonly unit: string; readonly attributive: true };
+
+const HYPHENS = "[-‐‑]";
+
+const alternation = (units: readonly string[]): string =>
+  units
+    .filter((unit) => unit !== "")
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+/**
+ * Figures in digits joined by a hyphen to one of the units. The unit ends the word: "3-month-old" is an age and "3-monthly"
+ * another word, and a figure inside a longer number or word ("2026-04-3-day", "v2-day") is not a count. Pure.
+ */
+export const hyphenatedCounts = (text: string, units: readonly string[]): HyphenatedCount[] => {
+  const words = alternation(units);
+  if (words === "") return [];
+  const pattern = new RegExp(`(?<![\\p{L}\\p{N}\\p{Pd}.,])(\\p{Nd}+)${HYPHENS}(${words})(?![\\p{L}\\p{N}\\p{Pd}])`, "giu");
+  return [...text.matchAll(pattern)].flatMap((match): HyphenatedCount[] => {
+    const unit = units.find((candidate) => candidate.toLowerCase() === (match[2] ?? "").toLowerCase());
+    return unit === undefined
+      ? []
+      : [{ start: match.index, end: match.index + match[0].length, amount: Number((match[1] ?? "").normalize("NFKC")), unit, attributive: true }];
+  });
+};
+
+/** The text before an attributive count without the article its noun takes ("up to a" → "up to"): a rough mark stands before it. Pure. */
+export const withoutArticle = (before: string, articles: readonly string[]): string => {
+  const trimmed = before.trimEnd();
+  const lower = trimmed.toLowerCase();
+  const article = articles.find((word) => word !== "" && (lower === word.toLowerCase() || lower.endsWith(` ${word.toLowerCase()}`)));
+  return article === undefined ? trimmed : trimmed.slice(0, trimmed.length - article.length).trimEnd();
+};

package/src/derived/marked-dates.ts

@@ -0,0 +1,61 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { withoutTrailingWeekday, type RangeWords } from "../structure/date-range.ts";
+
+/**
+ * 日付が三つ以上ある文で、始まりと終わりを語で印した二つ（「お買い上げ日が7月1日の場合、7月1日から12か月（7月31日まで）」）。
+ * 始まりの印は、日付の後ろの開きの語（から）か、前の枠の前の語（from）。終わりの印は、後ろの閉じの語（まで）か、前のつなぎの語
+ * （〜、until）や枠の間の語（to）、または期間のすぐ後ろで開いた括弧。語は語彙表（range-opener、range-closer、range-connector、
+ * range-frame）から受け取る。
+ */
+export type MarkText = { readonly source: string; readonly range: RangeWords };
+
+/** 印の語を探す、日付の前後の字数。印の語はこれより短い。 */
+const MARK_REACH = 40;
+const OPEN_BRACKETS: readonly string[] = ["（", "("];
+const CLOSE_BRACKETS: readonly string[] = ["）", ")"];
+const LATIN = /\p{Script=Latin}/u;
+
+/** 語が書いてあるか。ラテン文字の端は、隣がラテン文字でないときだけ（"from" は "therefrom" の終わりではない）。 */
+const hasWord = (text: string, word: string, where: "start" | "end" | "anywhere"): boolean => {
+  if (word === "") return false;
+  const head = LATIN.test(word.charAt(0)) ? "(?<!\\p{Script=Latin})" : "";
+  const tail = LATIN.test(word.at(-1) ?? "") ? "(?!\\p{Script=Latin})" : "";
+  const body = `${head}${escapeRegExp(word)}${tail}`;
+  const anchored = { start: `^${body}`, end: `${body}$`, anywhere: body }[where];
+  return new RegExp(anchored, "iu").test(text);
+};
+
+const before = (text: MarkText, date: Span): string =>
+  withoutTrailingWeekday(text.source.slice(Math.max(0, date.start - MARK_REACH), date.start).trimEnd(), text.range.weekdays ?? []);
+
+const after = (text: MarkText, date: Span): string => text.source.slice(date.end, date.end + MARK_REACH).trimStart();
+
+const isStart = (text: MarkText, date: Span): boolean =>
+  text.range.openers.some((word) => hasWord(after(text, date), word, "start")) ||
+  text.range.frames.some((frame) => hasWord(before(text, date), frame.lead, "end"));
+
+/** 期間のすぐ後ろの括弧が、日付だけを囲む（12か月（2027年6月30日））。日付で始まる注（(May 15, 2026 billing notice)）は終わりではない。 */
+const bracketAfterLength = (text: MarkText, date: Span, length: Span): boolean =>
+  length.end <= date.start &&
+  OPEN_BRACKETS.includes(text.source.slice(length.end, date.start).trim()) &&
+  CLOSE_BRACKETS.some((bracket) => after(text, date).startsWith(bracket));
+
+/** 文に変更の語（moved、postponed）があれば、日付を動かした文で、期間ではない。 */
+const isChange = (text: MarkText, sentence: Span): boolean =>
+  text.range.changes.some((word) => hasWord(text.source.slice(sentence.start, sentence.end), word, "anywhere"));
+
+const isEnd = (text: MarkText, date: Span, length: Span): boolean =>
+  text.range.closers.some((word) => hasWord(after(text, date), word, "start")) ||
+  [...text.range.connectors, ...text.range.frames.map((frame) => frame.joint)].some((word) => hasWord(before(text, date), word, "end")) ||
+  bracketAfterLength(text, date, length);
+
+/** 始まりの印の日付と終わりの印の日付が一つずつで、別の日付のときだけ、その組。 */
+export const markedPair = <T extends Span>(text: MarkText, sentence: Span, dates: readonly T[], length: Span): readonly [T, T] | undefined => {
+  if (isChange(text, sentence)) return undefined;
+  const starts = dates.filter((date) => isStart(text, date));
+  const ends = dates.filter((date) => isEnd(text, date, length));
+  const [start] = starts;
+  const [end] = ends;
+  return starts.length === 1 && ends.length === 1 && start !== undefined && end !== undefined && start !== end ? [start, end] : undefined;
+};

package/src/derived/money-span.ts

@@ -0,0 +1,10 @@
+import type { Span } from "../plugin.ts";
+
+/** A currency mark from the currency-notation lexicon and the side of the number it is written on. */
+export type CurrencyMark = { readonly pattern: string; readonly before: boolean };
+
+/** Whether the amount at span is money: a currency mark right before its number (¥1,000, $5) or as its unit (3,000円, 10 USD). */
+export const isMoneySpan = (text: string, span: Span, unit: string, marks: readonly CurrencyMark[]): boolean => {
+  const before = text.slice(0, span.start).trimEnd();
+  return marks.some((mark) => (mark.before ? before.endsWith(mark.pattern) : unit === mark.pattern));
+};

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