chaffjs 0.31.0 → 0.33.0

package/src/structure/date-range.ts

@@ -1,12 +1,13 @@
 import { escapeRegExp } from "../orthography.ts";
 import type { StructureIssue } from "./issues.ts";
+import { reversedReading } from "./range-years.ts";
 
 /**
  * 期間の終わりが始まりより前。二つの日付の間が範囲の記号（〜、–、through）だけか、開きの語（から）で終わりの日付に閉じの語（まで）が続くときを期間と読む。
- * 比べるのは、両方が年月日か、両方が年月のときだけ。年の無い期間（12月28日〜1月4日）は年をまたぐかもしれない。
+ * 比べるのは、両方が年月日か、両方が年月か、年を片方にだけ書いた年月日（range-years.ts）。年の無い期間（12月28日〜1月4日）は年をまたぐかもしれない。
  * 言語の知識（範囲の記号と語）は語彙表から受け取る。
  */
-export type DatedSpan = { readonly offset: number; readonly end: number; readonly value: string };
+export type DatedSpan = { readonly offset: number; readonly end: number; readonly value: string; readonly weekday?: number | undefined };
 
 export type RangeWords = {
   /** それだけで期間を作る記号と語。 */
@@ -51,14 +52,10 @@ export const rangeFrameOf = (pattern: string): RangeFrame | undefined => {
   return lead === undefined || joint === undefined || lead === "" || joint === "" || rest.length > 0 ? undefined : { lead, joint };
 };
 
-const COMPARABLE = [/^\d{4}-\d{2}-\d{2}$/u, /^\d{4}-\d{2}$/u];
-
-const comparable = (start: string, end: string): boolean => COMPARABLE.some((pattern) => pattern.test(start) && pattern.test(end));
-
 /** 日付に添えた曜日（（水））と時刻（10:00）は、期間のつなぎ目ではないので読み飛ばす。 */
 const ASIDES = /[（(][^（()）\n]{1,6}[）)]|\d{1,2}[:：]\d{2}/gu;
 
-const bare = (text: string): string => text.replace(ASIDES, "").trim().toLowerCase();
+export const bare = (text: string): string => text.replace(ASIDES, "").trim().toLowerCase();
 
 const isOneOf = (text: string, words: readonly string[]): boolean => words.some((word) => word.toLowerCase() === text);
 
@@ -162,17 +159,18 @@ const writtenPeriod = (source: string, start: DatedSpan, end: DatedSpan): string
 
 /**
  * 隣り合う二つの日付のうち、期間をなし、終わりが始まりより前のもの。期間の書き出しを指し、書いたままの期間を見せる。
- * isLabelled は、その位置の日付が期間の語で始まる行（Dates: …）の、語より後ろにあるか。
+ * isLabelled は、その位置の日付が期間の語で始まる行（Dates: …）の、語より後ろにあるか。alsoRange は、ほかの書き方で期間と読める組か。
  */
 export const reversedRanges = (
   source: string,
   dates: readonly DatedSpan[],
   words: RangeWords,
   isLabelled: (offset: number) => boolean = () => false,
+  alsoRange: (start: DatedSpan, end: DatedSpan) => boolean = () => false,
 ): StructureIssue[] =>
   dates.slice(1).flatMap((end, index) => {
     const start = dates[index];
-    if (start === undefined || !comparable(start.value, end.value) || end.value >= start.value) return [];
-    if (!isRange(source, start, end, words, isLabelled)) return [];
-    return [{ offset: start.offset, values: { start: start.value, end: end.value, period: writtenPeriod(source, start, end) } }];
+    const reading = start === undefined ? undefined : reversedReading(start, end);
+    if (start === undefined || reading === undefined || !(isRange(source, start, end, words, isLabelled) || alsoRange(start, end))) return [];
+    return [{ offset: start.offset, values: { start: reading.start, end: reading.end, period: writtenPeriod(source, start, end) } }];
   });

package/src/structure/deadline-after-event.ts

@@ -3,18 +3,29 @@ import type { DatedPoint } from "./due-date.ts";
 import type { StructureIssue } from "./issues.ts";
 import { lineNumberAt, linesOf, type Line } from "./lines.ts";
 import { isTotalLabel } from "./total.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
 
 /**
  * 催しの後の申込締切。催しの日の語で始まり時刻のある一行（日時：2026年11月20日（金）14:00〜）が催しの日を書き、
  * 申込の語（申込、RSVP）と締め切りの語（までに、by）のある文か行の、年のある日付がどの催しの日よりも後なら指す。
  * 時刻を求めるのは、手紙の頭の「Date: …」を催しの日と読まないため。催しの後に来てよいもの（アンケート、支払）の語が同じ文にあれば比べない。
- * 文か行に日付が二つ以上あれば、どれが締め切りか分からないので比べない。Pure.
+ * 文か行に日付が二つ以上あれば、どれが締め切りか分からないので比べない。
+ * チケットの注文（題名にチケットの語があり、請求書の語が無い文書）では、支払の期限も締め切りと読む。請求書なら支払は催しの後でよい。
+ * 旅行の知らせ（題名に旅行の語があり、請求書の語が無い文書）では、出発の語で始まる行（出発日：、期間：）の最初の日付を時刻が無くても催しの日と読み、
+ * 納入期限の語のある文か、その語を列の見出しにした表の升の日付を支払の期限と読む。請求書の「期間」は請求の期間で、旅行ではない。Pure.
  */
 export type EventDeadlineWords = {
   readonly events: readonly string[];
   readonly registrations: readonly string[];
   readonly deadlines: readonly string[];
   readonly asides: readonly string[];
+  readonly tickets: readonly string[];
+  readonly payments: readonly string[];
+  readonly bills: readonly string[];
+  readonly trips: readonly string[];
+  readonly starts: readonly string[];
+  readonly paymentDeadlines: readonly string[];
+  readonly dues: readonly string[];
 };
 
 type Span = { readonly start: number; readonly end: number };
@@ -37,6 +48,27 @@ const eventDayOf = (line: Line, dates: readonly DatedPoint[], words: EventDeadli
   return latestOf(values.filter((value) => FULL_DATE.test(value)));
 };
 
+const MONTH_DAY = /^\d{2}-\d{2}$/u;
+const YEAR_LENGTH = 4;
+
+/**
+ * 期間の始まりの日。年を書かない始まり（October 14 – Friday, October 16, 2026）は終わりの年を借り、始まりの月が終わりの月より後なら
+ * （December 30 – January 2, 2027）その前の年。同じ月で日が逆さまの期間は、逆さまのまま同じ年に置く。
+ */
+export const rangeStartOf = (values: readonly string[]): string | undefined => {
+  const [first, ...rest] = values;
+  if (first === undefined || FULL_DATE.test(first)) return first;
+  const end = rest.find((value) => FULL_DATE.test(value));
+  if (!MONTH_DAY.test(first) || end === undefined) return undefined;
+  const year = Number(end.slice(0, YEAR_LENGTH));
+  const crossesYear = first.slice(0, 2) > end.slice(YEAR_LENGTH + 1, YEAR_LENGTH + 3);
+  return `${String(crossesYear ? year - 1 : year)}-${first}`;
+};
+
+/** 旅行の始まりの日: 出発の語で始まる行の、最初の日付。期間（10月14日〜16日）なら始まりの日。 */
+const tripStartOf = (line: Line, dates: readonly DatedPoint[], words: EventDeadlineWords): string | undefined =>
+  isTotalLabel(line.text, words.starts) ? rangeStartOf(datesIn(dates, { start: line.start, end: endOf(line) }).map((date) => date.value)) : undefined;
+
 /** 日付を囲む文を、その行の中に切ったもの。文が見つからなければ行。 */
 const unitOf = (offset: number, line: Line, sentences: readonly Span[]): Span => {
   const sentence = sentences.find((span) => span.start <= offset && offset < span.end);
@@ -47,21 +79,106 @@ const unitOf = (offset: number, line: Line, sentences: readonly Span[]): Span =>
 export const isRegistrationDeadline = (text: string, words: EventDeadlineWords): boolean =>
   mentions(text, words.registrations) && mentions(text, words.deadlines) && !mentions(text, words.asides);
 
-type Reading = { readonly source: string; readonly lines: readonly Line[]; readonly dates: readonly DatedPoint[]; readonly sentences: readonly Span[] };
+/** 催しの後に来てよいものの語のうち、支払の語でないもの（アンケート、返金）。 */
+const asidesBesidesPayment = (words: EventDeadlineWords): readonly string[] =>
+  words.asides.filter((aside) => !words.payments.some((payment) => payment.toLowerCase() === aside.toLowerCase()));
+
+/** チケットの注文の支払期限を書いた文か: 支払の語と締め切りの語があり、支払の語のほかに催しの後に来てよいものの語が無い。 */
+export const isTicketPaymentDeadline = (text: string, words: EventDeadlineWords): boolean =>
+  mentions(text, words.payments) && mentions(text, words.deadlines) && !mentions(text, asidesBesidesPayment(words));
+
+/** チケットの注文か: 題名（最初の見出し）にチケットの語があり、文書のどこにも請求書の語が無い。 */
+export const isTicketOrder = (title: string | undefined, source: string, words: EventDeadlineWords): boolean =>
+  title !== undefined && mentions(title, words.tickets) && !mentions(title, words.bills) && !mentions(source, words.bills);
+
+/** 旅行の知らせか: 題名（最初の見出し）に旅行の語があり、文書のどこにも請求書の語が無い。 */
+export const isTripNotice = (title: string | undefined, source: string, words: EventDeadlineWords): boolean =>
+  title !== undefined && mentions(title, words.trips) && !mentions(title, words.bills) && !mentions(source, words.bills);
+
+/**
+ * 旅行の代金の期限を書いた文か: 納入期限の語があるか、支払の語と締め切りか期日の語がある（Second payment: $60, due …）。
+ * heading は日付のある表の升の列の見出しで、文と合わせて読む（見出しが Due by、行が 2nd payment）。
+ * 支払の語のほかに催しの後に来てよいものの語（返金、精算）があれば読まない。期日の語（due）は旅行の知らせでだけ読む。
+ */
+export const isTripPaymentDeadline = (text: string, heading: string | undefined, words: EventDeadlineWords): boolean => {
+  const read = heading === undefined ? text : `${heading} ${text}`;
+  if (mentions(read, asidesBesidesPayment(words))) return false;
+  return mentions(read, words.paymentDeadlines) || (mentions(read, words.payments) && mentions(read, [...words.deadlines, ...words.dues]));
+};
 
-const lateDeadlines = (reading: Reading, words: EventDeadlineWords, event: string): StructureIssue[] =>
+type Reading = {
+  readonly title: string | undefined;
+  readonly source: string;
+  readonly lines: readonly Line[];
+  readonly dates: readonly DatedPoint[];
+  readonly sentences: readonly Span[];
+  /** 表の本体の行の番号から、その表の見出しの行。 */
+  readonly tableHeaders: ReadonlyMap<number, Line>;
+};
+
+/** 締め切りとして読んだ道。payment はチケットの注文か旅行の知らせの支払期限で、知らせの言い方を変える。 */
+export type DeadlineKind = "registration" | "payment";
+
+export type DeadlineIssue = StructureIssue & { readonly kind: DeadlineKind };
+
+/** heading は日付が表の升にあるときの、その列の見出し。 */
+type ReadDeadline = (text: string, heading: string | undefined) => DeadlineKind | undefined;
+
+const deadlineReaderOf = (reading: Reading, words: EventDeadlineWords): ReadDeadline => {
+  const ticketOrder = isTicketOrder(reading.title, reading.source, words);
+  const tripNotice = isTripNotice(reading.title, reading.source, words);
+  return (text, heading) => {
+    if (ticketOrder && isTicketPaymentDeadline(text, words)) return "payment";
+    if (tripNotice && isTripPaymentDeadline(text, heading, words)) return "payment";
+    return isRegistrationDeadline(text, words) ? "registration" : undefined;
+  };
+};
+
+const tableHeadersOf = (lines: readonly Line[]): Map<number, Line> =>
+  new Map(tablesOf(lines).flatMap(({ header, rows }) => rows.map((row): [number, Line] => [row.number, header])));
+
+/** offset が表の本体の升にあれば、その列の見出しの字。 */
+const columnHeadingAt = (reading: Reading, line: Line, offset: number): string | undefined => {
+  const header = reading.tableHeaders.get(line.number);
+  if (header === undefined) return undefined;
+  const column = cellsOf(line).findIndex((cell) => cell.start <= offset && offset < cell.end);
+  return column === -1 ? undefined : cellsOf(header)[column]?.text;
+};
+
+const lateDeadlines = (reading: Reading, readDeadline: ReadDeadline, event: string): DeadlineIssue[] =>
   reading.dates.flatMap((date) => {
     if (!FULL_DATE.test(date.value) || date.value <= event) return [];
     const line = reading.lines[(lineNumberAt(reading.lines, date.offset) ?? 0) - 1];
     if (line === undefined) return [];
     const unit = unitOf(date.offset, line, reading.sentences);
-    if (datesIn(reading.dates, unit).length > 1 || !isRegistrationDeadline(reading.source.slice(unit.start, unit.end), words)) return [];
-    return [{ offset: date.offset, values: { deadline: date.value, event } }];
+    if (datesIn(reading.dates, unit).length > 1) return [];
+    const kind = readDeadline(reading.source.slice(unit.start, unit.end), columnHeadingAt(reading, line, date.offset));
+    if (kind === undefined) return [];
+    return [{ offset: date.offset, kind, values: { deadline: date.value, event } }];
   });
 
-export const deadlinesAfterEvent = (source: string, dates: readonly DatedPoint[], sentences: readonly Span[], words: EventDeadlineWords): StructureIssue[] => {
+/** 催しの日: 催しの日の行の日付と、旅行の知らせなら出発の行の日付の、いちばん後のもの。 */
+const eventOf = (reading: Reading, words: EventDeadlineWords): string | undefined => {
+  const trip = isTripNotice(reading.title, reading.source, words);
+  return latestOf(
+    reading.lines.flatMap((line) =>
+      [eventDayOf(line, reading.dates, words), trip ? tripStartOf(line, reading.dates, words) : undefined].flatMap((day) => day ?? []),
+    ),
+  );
+};
+
+/** title は文書の最初の見出しの言葉（無ければ undefined）。 */
+export const deadlinesAfterEvent = (
+  source: string,
+  dates: readonly DatedPoint[],
+  sentences: readonly Span[],
+  words: EventDeadlineWords,
+  title?: string,
+): DeadlineIssue[] => {
   if (words.events.length === 0 || words.registrations.length === 0 || words.deadlines.length === 0) return [];
   const lines = linesOf(source);
-  const event = latestOf(lines.flatMap((line) => eventDayOf(line, dates, words) ?? []));
-  return event === undefined ? [] : lateDeadlines({ source, lines, dates, sentences }, words, event);
+  const reading = { title, source, lines, dates, sentences, tableHeaders: tableHeadersOf(lines) };
+  const event = eventOf(reading, words);
+  if (event === undefined) return [];
+  return lateDeadlines(reading, deadlineReaderOf(reading, words), event);
 };

package/src/structure/deductible-limit.ts

@@ -0,0 +1,255 @@
+import { escapeRegExp } from "../orthography.ts";
+import { keyOf, proseValues, type AmountWords, type ProseFigure, type ProseQuantity } from "./ratio.ts";
+
+/**
+ * deductible-exceeds-limit: the deciding half. In one sentence naming one deductible (免責金額, excess) and one limit
+ * (支払限度額, the most we pay), each with one amount of money right after it, a deductible larger than the limit for a
+ * comparable basis (1回, a claim, 1品, a single item) means the benefit pays nothing. The words are lexicons; nothing here
+ * knows a word of insurance. Pure.
+ */
+
+/** A basis an amount is stated for (1回, a visit, 1品). rank orders the bases that nest: a claim holds one item or more. */
+export type BasisWord = { readonly pattern: string; readonly basis: string; readonly rank?: number | undefined };
+
+export type DeductibleWords = {
+  readonly deductibles: readonly string[];
+  readonly limits: readonly string[];
+  /** Phrases holding a deductible word without naming a deductible ("in excess of", 自己負担限度額). */
+  readonly notDeductibles: readonly string[];
+  /** Phrases holding a limit word without naming the most paid ("maximum excess"). */
+  readonly notLimits: readonly string[];
+  readonly bases: readonly BasisWord[];
+  readonly approximate: { readonly before: readonly string[]; readonly after: readonly string[] };
+  readonly rangeMarks: readonly string[];
+  /** Words of magnitude and what they multiply by (万 is 10000, million). */
+  readonly multipliers: readonly { readonly word: string; readonly value: number }[];
+  readonly amounts: AmountWords;
+  /** Which currency each mark names ($ and US$ are both USD; 円 and ¥ are both JPY). */
+  readonly currencies: readonly { readonly pattern: string; readonly currency: string }[];
+};
+
+export type Basis = { readonly basis: string; readonly rank?: number | undefined };
+
+/** An amount as stated: its value in the currency's own unit, the currency (with the magnitude word taken out), the basis. */
+export type StatedAmount = { readonly value: number; readonly currency: string; readonly basis?: Basis | undefined };
+
+export type DeductibleIssue = { readonly offset: number; readonly values: Readonly<Record<string, string>> };
+
+/**
+ * Whether a deductible on one basis can be held against a limit on another. A limit with no basis is the most ever paid, so
+ * every deductible is held against it. The same basis is. A deductible on a basis that holds the limit's (an excess per
+ * claim, a limit per item) is: a claim for one item meets the whole excess and at most one item's limit. A deductible with no
+ * basis is charged on one claim, so it is held against a limit on any basis that nests. Bases that do not nest (a day, a
+ * year) are compared only with themselves.
+ */
+export const basesComparable = (deductible: Basis | undefined, limit: Basis | undefined): boolean => {
+  if (limit === undefined) return true;
+  if (deductible === undefined) return limit.rank !== undefined;
+  if (deductible.basis === limit.basis) return true;
+  return deductible.rank !== undefined && limit.rank !== undefined && deductible.rank > limit.rank;
+};
+
+/** A deductible larger than the limit, in the same currency, on comparable bases. An equal one is not reported. */
+export const deductibleExceeds = (deductible: StatedAmount, limit: StatedAmount): boolean =>
+  deductible.currency === limit.currency && basesComparable(deductible.basis, limit.basis) && deductible.value > limit.value;
+
+/** How far after its word an amount may start (「免責金額は1回」, "the most we pay for a single item is"). */
+const MAX_GAP = 24;
+/** How far around a word and its amount the basis is looked for, in characters. */
+const BASIS_REACH = 16;
+/** Marks that end a clause: a basis is not read across them. */
+const CLAUSE_BREAK = /[、,;；，。.]/u;
+const LATIN = /^[A-Za-z]/u;
+const DIGIT_START = /^\d/u;
+const DIGIT_BEFORE = /[\d.,]$/u;
+const CJK_LETTER = /[\p{sc=Han}\p{sc=Katakana}ー]/u;
+const LETTER = /\p{L}/u;
+
+type Hit = { readonly start: number; readonly end: number; readonly kind: "deductible" | "limit"; readonly word: string };
+type Spot = { readonly start: number; readonly end: number };
+
+/** Where a word stands: a Latin word as a whole word in any case, any other word not inside a longer kanji or katakana word. */
+const spansOf = (text: string, word: string, cjkBounded: boolean): Spot[] => {
+  if (word === "") return [];
+  const latin = LATIN.test(word);
+  const pattern = new RegExp(latin ? `(?<![\\p{L}\\p{N}])${escapeRegExp(word)}(?![\\p{L}\\p{N}])` : escapeRegExp(word), latin ? "giu" : "gu");
+  return [...text.matchAll(pattern)]
+    .filter((match) => {
+      const [before, after] = [text.charAt(match.index - 1), text.charAt(match.index + match[0].length)];
+      if (DIGIT_START.test(word) && DIGIT_BEFORE.test(text.slice(0, match.index))) return false;
+      return latin || !cjkBounded || !(CJK_LETTER.test(before) || CJK_LETTER.test(after));
+    })
+    .map((match) => ({ start: match.index, end: match.index + match[0].length }));
+};
+
+const within = (outer: Spot) => (inner: Spot) => outer.start <= inner.start && inner.end <= outer.end;
+
+/** The deductible and limit words of a sentence, without those inside a not-phrase or inside a longer word found. */
+const hitsIn = (text: string, words: DeductibleWords): Hit[] => {
+  const nots = {
+    deductible: words.notDeductibles.flatMap((word) => spansOf(text, word, false)),
+    limit: words.notLimits.flatMap((word) => spansOf(text, word, false)),
+  };
+  const all = [
+    ...words.deductibles.flatMap((word) => spansOf(text, word, true).map((at): Hit => ({ ...at, kind: "deductible", word: text.slice(at.start, at.end) }))),
+    ...words.limits.flatMap((word) => spansOf(text, word, true).map((at): Hit => ({ ...at, kind: "limit", word: text.slice(at.start, at.end) }))),
+  ];
+  return all.filter(
+    (hit) =>
+      !nots[hit.kind].some((not) => within(not)(hit)) &&
+      !all.some((other) => other !== hit && within(other)(hit) && other.end - other.start > hit.end - hit.start),
+  );
+};
+
+/** The written text of an amount: its currency mark before, its number, its unit after (as long as the unit read). */
+type Written = Spot & { readonly figure: ProseFigure };
+
+const writtenOf = (figure: ProseFigure): Written => ({ start: figure.writtenStart, end: figure.writtenEnd, figure });
+
+const lower = (text: string): string => text.toLowerCase();
+
+/** A mark at the end of before (or the start of after) standing as a word of its own when it is Latin. */
+const endsWithMark = (before: string, mark: string): boolean => {
+  const at = lower(before).lastIndexOf(lower(mark));
+  return at >= 0 && at + mark.length === before.length && !(LATIN.test(mark) && LETTER.test(before.charAt(at - 1)));
+};
+const startsWithMark = (after: string, mark: string): boolean =>
+  lower(after).startsWith(lower(mark)) && !(LATIN.test(mark) && LETTER.test(after.charAt(mark.length)));
+
+/** A rough amount (約5,000円, about $80, 5,000円程度) or one end of a range (1,000〜5,000円, $50 - $80). A limit word is not rough. */
+const isRoughOrRange = (text: string, written: Written, words: DeductibleWords): boolean => {
+  const before = text.slice(0, written.start).trimEnd();
+  const after = text.slice(written.end).trimStart();
+  const limitWords = new Set(words.limits.map(lower));
+  const rough = [
+    ...words.approximate.before.filter((mark) => !limitWords.has(lower(mark)) && endsWithMark(before, mark)),
+    ...words.approximate.after.filter((mark) => startsWithMark(after, mark)),
+  ];
+  return rough.length > 0 || words.rangeMarks.some((mark) => before.endsWith(mark) || after.startsWith(mark));
+};
+
+/** The currency a mark names, or the mark itself when no lexicon entry names one. */
+const currencyOf = (mark: string, words: DeductibleWords): string => words.currencies.find((entry) => keyOf(entry.pattern) === mark)?.currency ?? mark;
+
+/** The value with its word of magnitude multiplied in, and the currency its marks name ("|万円" 30 is 300000 JPY, "us$|" is USD). */
+const scaled = (figure: ProseFigure, words: DeductibleWords): { value: number; currency: string } => {
+  const multiplier = words.multipliers.find((entry) => figure.suffix.startsWith(keyOf(entry.word)));
+  const bare = multiplier === undefined ? figure.suffix : figure.suffix.slice(keyOf(multiplier.word).length).trimStart();
+  const marks = [figure.mark, bare].filter((mark) => mark !== "").map((mark) => currencyOf(mark, words));
+  return { value: figure.value * (multiplier?.value ?? 1), currency: [...new Set(marks)].join("|") };
+};
+
+/** The only amount of money between a word and the next word (or the end), close to it. */
+const amountAfter = (hit: Hit, hits: readonly Hit[], figures: readonly ProseFigure[], text: string): Written | undefined => {
+  const until = Math.min(text.length, ...hits.filter((other) => other.start >= hit.end).map((other) => other.start));
+  const between = figures.filter((figure) => figure.start >= hit.end && figure.start < until);
+  const only = between.length === 1 ? between[0] : undefined;
+  if (only === undefined || only.start - hit.end > MAX_GAP) return undefined;
+  return writtenOf(only);
+};
+
+const lastBreakBefore = (text: string, at: number): number => {
+  const before = text.slice(0, at);
+  const breaks = [...before.matchAll(new RegExp(CLAUSE_BREAK.source, "gu"))].map((match) => match.index + 1);
+  return Math.max(0, ...breaks);
+};
+
+const firstBreakAfter = (text: string, at: number): number => {
+  const found = CLAUSE_BREAK.exec(text.slice(at));
+  return found === null ? text.length : at + found.index;
+};
+
+/** The bases written in the clause around a word and its amount, outside the amount itself. */
+const basesIn = (text: string, region: Spot, words: DeductibleWords, taken: Spot): BasisWord[] => {
+  const slice = text.slice(region.start, region.end);
+  return words.bases.flatMap((entry) =>
+    spansOf(slice, entry.pattern, false)
+      .map((at) => ({ start: region.start + at.start, end: region.start + at.end }))
+      .filter((at) => !(at.start < taken.end && taken.start < at.end))
+      .map(() => entry),
+  );
+};
+
+type Read = { readonly hit: Hit; readonly written: Written; readonly stated: StatedAmount };
+
+const SPACES = /^\s*/u;
+
+/** Where the bases written right after an amount end ("$80 a visit", "$80 a visit a day"), or the amount's end when none is. */
+const adjacentEnd = (text: string, end: number, words: DeductibleWords): number => {
+  const from = end + (SPACES.exec(text.slice(end))?.[0].length ?? 0);
+  const rest = text.slice(from);
+  const lengths = words.bases.flatMap((entry) =>
+    spansOf(rest, entry.pattern, false)
+      .filter((at) => at.start === 0)
+      .map((at) => at.end),
+  );
+  return lengths.length === 0 ? end : adjacentEnd(text, from + Math.max(...lengths), words);
+};
+
+/**
+ * The clause around a word and its amount where its basis is read. Between the first amount and the second word, only a basis
+ * right after the amount is the first's ("$80 a visit and the most we pay"); any other belongs to the second word
+ * (「300,000円で1品あたりの支払限度額」).
+ */
+const regionsOf = (text: string, first: Written, second: { hit: Hit; written: Written }, firstHit: Hit, words: DeductibleWords): [Spot, Spot] => {
+  const split = adjacentEnd(text, first.end, words);
+  const opening = { start: Math.max(firstHit.start - BASIS_REACH, lastBreakBefore(text, firstHit.start)), end: split };
+  const closing = {
+    start: Math.max(split, second.hit.start - BASIS_REACH, lastBreakBefore(text, second.hit.start)),
+    end: Math.min(second.written.end + BASIS_REACH, firstBreakAfter(text, second.written.end)),
+  };
+  return [opening, closing];
+};
+
+/** The amount as stated, with the one basis written around it; two different bases leave it unread. */
+const statedOf = (text: string, written: Written, region: Spot, words: DeductibleWords): StatedAmount | undefined => {
+  const found = basesIn(text, region, words, written);
+  if (new Set(found.map((entry) => entry.basis)).size > 1) return undefined;
+  const first = found[0];
+  return { ...scaled(written.figure, words), basis: first === undefined ? undefined : { basis: first.basis, rank: first.rank } };
+};
+
+/** Both words with their amounts and bases, in the order written; undefined when either amount is not read. */
+const readPair = (text: string, hits: readonly [Hit, Hit], figures: readonly ProseFigure[], words: DeductibleWords): Read[] | undefined => {
+  const [first, second] = hits.toSorted((left, right) => left.start - right.start);
+  if (first === undefined || second === undefined) return undefined;
+  const [firstWritten, secondWritten] = [amountAfter(first, hits, figures, text), amountAfter(second, hits, figures, text)];
+  if (firstWritten === undefined || secondWritten === undefined) return undefined;
+  if ([firstWritten, secondWritten].some((written) => isRoughOrRange(text, written, words))) return undefined;
+  const [opening, closing] = regionsOf(text, firstWritten, { hit: second, written: secondWritten }, first, words);
+  const [firstStated, secondStated] = [statedOf(text, firstWritten, opening, words), statedOf(text, secondWritten, closing, words)];
+  if (firstStated === undefined || secondStated === undefined) return undefined;
+  return [
+    { hit: first, written: firstWritten, stated: firstStated },
+    { hit: second, written: secondWritten, stated: secondStated },
+  ];
+};
+
+/**
+ * One sentence (text, starting at offset in the document; quantities are the tree's, in document offsets) with exactly one
+ * deductible word and one limit word, each with one amount of money right after it, read as stated and compared. Any other
+ * shape is not read.
+ */
+export const sentenceDeductibleOverLimit = (
+  text: string,
+  offset: number,
+  quantities: readonly ProseQuantity[],
+  words: DeductibleWords,
+): DeductibleIssue | undefined => {
+  const hits = hitsIn(text, words);
+  const deductibleHits = hits.filter((hit) => hit.kind === "deductible");
+  const limitHits = hits.filter((hit) => hit.kind === "limit");
+  const [deductibleHit, limitHit] = [deductibleHits[0], limitHits[0]];
+  if (deductibleHits.length !== 1 || limitHits.length !== 1 || deductibleHit === undefined || limitHit === undefined) return undefined;
+  const local = quantities.map((quantity) => ({ ...quantity, start: quantity.start - offset, end: quantity.end - offset }));
+  const { figures } = proseValues(text, 0, local, words.amounts);
+  const pair = readPair(text, [deductibleHit, limitHit], figures, words);
+  const deductible = pair?.find((read) => read.hit === deductibleHit);
+  const limit = pair?.find((read) => read.hit === limitHit);
+  if (deductible === undefined || limit === undefined || !deductibleExceeds(deductible.stated, limit.stated)) return undefined;
+  const shown = (read: Read): string => text.slice(read.written.start, read.written.end);
+  return {
+    offset: offset + deductible.written.start,
+    values: { deductibleWord: deductible.hit.word, deductible: shown(deductible), limitWord: limit.hit.word, limit: shown(limit) },
+  };
+};