chaffjs 0.31.0 → 0.33.0

package/src/structure/share-amount.ts

@@ -0,0 +1,206 @@
+// share-amount-mismatch: the amount a patient pays that is not the stated share (3割, 30%) of the total beside it. Two
+// shapes: a table whose headings name the total, the share and the amount, read row by row; and labelled lines
+// (「合計：10,000円」 then 「自己負担額（3割）：3,500円」) in one section, the total above the amount. Pure.
+import type { Line } from "./lines.ts";
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { bodyRows, offsetOf } from "./order-quantity.ts";
+import { taxMatches } from "./tax.ts";
+
+/** base: the total the share is of. share: a share, written as a rate (負担割合 3割) or as the amount (負担額 3,000円). paid: only the amount. */
+export type ShareRole = "base" | "share" | "paid";
+export type ShareWord = { readonly pattern: string; readonly role: ShareRole };
+/** An amount written in this unit may be rounded to this step (円: 10, the 10-yen rounding of a patient's share). */
+export type ShareRounding = { readonly unit: string; readonly step: number };
+export type ShareWords = { readonly labels: readonly ShareWord[]; readonly roundings: readonly ShareRounding[] };
+/** The document's tables, its lines outside tables, and where each heading starts (a section ends there). */
+export type ShareText = { readonly tables: readonly ChangeTable[]; readonly lines: readonly Line[]; readonly headings: readonly number[] };
+
+export type ShareRate = { readonly value: number; readonly written: string };
+export type Money = { readonly value: number; readonly decimals: number; readonly marks: string; readonly offset: number; readonly text: string };
+
+const ROLE_ORDER: readonly ShareRole[] = ["paid", "share", "base"];
+const PERCENT_RATE = /^(\d{1,2}(?:\.\d{1,2})?)\s*%$/u;
+/** 3割 is 30%: the Japanese share written in tenths. */
+const TENTHS_RATE = /^([1-9])\s*割$/u;
+const TENTH = 10;
+const MAX_RATE = 100;
+const CENTS = 100;
+const BRACKETED = /\(([^()]*)\)/gu;
+const NUMBER = /\d[\d,]*(?:\.(\d+))?/u;
+/** A line that is one label and one value: 「合計：10,000円」, "- Your share (30%): $350.00". */
+const SEPARATOR = /[:：]/u;
+const LIST_MARKER = /^\s*(?:[-*+]|\d{1,3}[.)])\s+/u;
+const KEY_VALUE_CELLS = 2;
+
+/** A share written as a rate: 30%, 30 %, 3割. Undefined for anything else, 0 and 100% and more. */
+export const shareRateIn = (text: string): ShareRate | undefined => {
+  const written = plain(text);
+  const percent = PERCENT_RATE.exec(written)?.[1];
+  const tenths = TENTHS_RATE.exec(written)?.[1];
+  const value = percent === undefined ? Number(tenths) * TENTH : Number(percent);
+  return Number.isFinite(value) && value > 0 && value < MAX_RATE ? { value, written } : undefined;
+};
+
+/** A rate written in brackets in a label: 「自己負担額（3割）」, "Your share (30%)". */
+const bracketedRate = (label: string): ShareRate | undefined => {
+  const rates = [...plain(label).matchAll(BRACKETED)].flatMap((match) => {
+    const rate = shareRateIn(match[1] ?? "");
+    return rate === undefined ? [] : [rate];
+  });
+  return rates.length === 1 ? rates[0] : undefined;
+};
+
+const roleOf = (label: string, words: readonly ShareWord[]): ShareRole | undefined => {
+  const key = plain(label).toLowerCase();
+  return ROLE_ORDER.find((role) => words.some((word) => word.role === role && holds(key, word.pattern)));
+};
+
+/** An amount: a number with what is written around it (10,000円, $600.00), not a rate. */
+const moneyIn = (text: string, offset: number): Money | undefined => {
+  const value = valueIn(text);
+  if (value === undefined || shareRateIn(text) !== undefined) return undefined;
+  const decimals = NUMBER.exec(plain(text))?.[1]?.length ?? 0;
+  return { value: value.value, decimals, marks: value.marks, offset, text: plain(text) };
+};
+
+const stepOf = (money: Money, roundings: readonly ShareRounding[]): number | undefined => {
+  const units = money.marks.split("|");
+  return roundings.find((rounding) => units.includes(plain(rounding.unit)))?.step;
+};
+
+/**
+ * Whether the written amount is the rate of the base: rounded down, to nearest or up, to the cent or the unit (the
+ * arithmetic of tax-mismatch), or to the rounding step of its unit.
+ */
+export const shareMatches = (written: number, base: number, rate: number, step: number | undefined): boolean => {
+  const writtenCents = Math.round(written * CENTS);
+  if (taxMatches(writtenCents, base, rate)) return true;
+  if (step === undefined) return false;
+  const stepCents = step * CENTS;
+  return [Math.floor, Math.round, Math.ceil].some((round) => Math.abs(round((base * rate) / stepCents) * stepCents - writtenCents) < 1);
+};
+
+/** The expected amount written the way the amount is: its unit, its grouping, its decimals, rounded to its step. */
+export const shownLike = (money: Money, exact: number, step: number | undefined): string => {
+  const rounded = step === undefined ? exact : Math.round(exact / step) * step;
+  const number = rounded.toLocaleString("en-US", {
+    minimumFractionDigits: money.decimals,
+    maximumFractionDigits: money.decimals,
+    useGrouping: money.text.includes(","),
+  });
+  return money.text.replace(NUMBER, number);
+};
+
+const issueOf = (base: Money, amount: Money, rate: ShareRate, roundings: readonly ShareRounding[]): StructureIssue[] => {
+  const step = stepOf(amount, roundings);
+  if (base.marks !== amount.marks || shareMatches(amount.value, base.value, rate.value, step)) return [];
+  const expected = shownLike(amount, (base.value * rate.value) / MAX_RATE, step);
+  return [{ offset: amount.offset, values: { written: amount.text, expected, rate: rate.written, base: base.text } }];
+};
+
+const onlyOne = <T>(items: readonly T[]): T | undefined => (items.length === 1 ? items[0] : undefined);
+
+type Labelled = { readonly label: string; readonly value: string; readonly offset: number };
+
+const labelledLine = (line: Line): Labelled | undefined => {
+  const at = line.text.search(SEPARATOR);
+  const label = line.text.slice(0, Math.max(at, 0)).replace(LIST_MARKER, "").trim();
+  const after = line.text.slice(at + 1);
+  const value = after.trim();
+  if (at < 0 || label === "" || value === "") return undefined;
+  return { label, value, offset: line.start + at + 1 + after.length - after.trimStart().length };
+};
+
+/** The share rate the document states on lines of their own (「負担割合：3割」, "Patient share: 30%"); undefined when none or two different ones. */
+export const statedRate = (labelled: readonly Labelled[], words: readonly ShareWord[]): ShareRate | undefined => {
+  const rates = labelled.flatMap((line) => {
+    const rate = roleOf(line.label, words) === "share" ? shareRateIn(line.value) : undefined;
+    return rate === undefined ? [] : [rate];
+  });
+  return new Set(rates.map((rate) => rate.value)).size === 1 ? rates[0] : undefined;
+};
+
+type Context = { readonly words: ShareWords; readonly stated: ShareRate | undefined };
+
+/** One row of a table: the total, the one amount, and the rate in the row, else in the amount's heading, else the stated one. */
+const rowIssues = (
+  row: readonly TableCell[],
+  headings: readonly TableCell[],
+  roles: readonly (ShareRole | undefined)[],
+  baseColumn: number,
+  context: Context,
+): StructureIssue[] => {
+  const baseCell = row[baseColumn];
+  const base = baseCell === undefined ? undefined : moneyIn(baseCell.text, offsetOf(baseCell));
+  const at = (role: ShareRole): number[] => roles.flatMap((found, index) => (found === role ? [index] : []));
+  const rowRates = at("share").flatMap((index) => {
+    const rate = shareRateIn(row[index]?.text ?? "");
+    return rate === undefined ? [] : [rate];
+  });
+  const amounts = [...at("share"), ...at("paid")].flatMap((index) => {
+    const cell = row[index];
+    const money = cell === undefined ? undefined : moneyIn(cell.text, offsetOf(cell));
+    return money === undefined ? [] : [{ money, index }];
+  });
+  const amount = onlyOne(amounts);
+  if (base === undefined || amount === undefined || rowRates.length > 1) return [];
+  const rowRate = onlyOne(rowRates);
+  // An amount column named only as a payment (Amount paid) is the share only beside a rate column in the same row.
+  const rate = rowRate ?? (roles[amount.index] === "share" ? (bracketedRate(headings[amount.index]?.text ?? "") ?? context.stated) : undefined);
+  return rate === undefined ? [] : issueOf(base, amount.money, rate, context.words.roundings);
+};
+
+const tableIssues = (table: ChangeTable, context: Context): StructureIssue[] => {
+  const roles = table.header.map((cell) => roleOf(cell.text, context.words.labels));
+  const baseColumn = onlyOne(roles.flatMap((role, index) => (role === "base" ? [index] : [])));
+  if (baseColumn === undefined) return [];
+  return bodyRows(table).flatMap((row) => rowIssues(row, table.header, roles, baseColumn, context));
+};
+
+/** The two-cell rows of a table that names no total column: | 合計 | 10,000円 |. */
+const keyValueRows = (table: ChangeTable, words: readonly ShareWord[]): Labelled[] =>
+  table.header.some((cell) => roleOf(cell.text, words) === "base")
+    ? []
+    : bodyRows(table).flatMap((row) => {
+        const [label, value] = row;
+        return row.length === KEY_VALUE_CELLS && label !== undefined && value !== undefined
+          ? [{ label: label.text, value: value.text, offset: offsetOf(value) }]
+          : [];
+      });
+
+const sectionOf = (offset: number, headings: readonly number[]): number => headings.filter((start) => start <= offset).length;
+
+/** Labelled lines of one section: the one total, and below it the one amount named as a share. */
+const sectionIssues = (section: readonly Labelled[], context: Context): StructureIssue[] => {
+  const moneyOf = (line: Labelled): Money | undefined => moneyIn(line.value, line.offset);
+  const bases = section.filter((line) => roleOf(line.label, context.words.labels) === "base" && moneyOf(line) !== undefined);
+  const amounts = section.filter((line) => roleOf(line.label, context.words.labels) === "share" && moneyOf(line) !== undefined);
+  const [baseLine, amountLine] = [onlyOne(bases), onlyOne(amounts)];
+  if (baseLine === undefined || amountLine === undefined || baseLine.offset > amountLine.offset) return [];
+  const [base, amount] = [moneyOf(baseLine), moneyOf(amountLine)];
+  const rate = bracketedRate(amountLine.label) ?? context.stated;
+  return base === undefined || amount === undefined || rate === undefined ? [] : issueOf(base, amount, rate, context.words.roundings);
+};
+
+const labelledIssues = (labelled: readonly Labelled[], headings: readonly number[], context: Context): StructureIssue[] => {
+  const sections = [...new Set(labelled.map((line) => sectionOf(line.offset, headings)))];
+  return sections.flatMap((section) =>
+    sectionIssues(
+      labelled.filter((line) => sectionOf(line.offset, headings) === section),
+      context,
+    ),
+  );
+};
+
+/** Each amount charged as a share that is not that share of the total beside it. */
+export const shareAmountMismatches = (text: ShareText, words: ShareWords): StructureIssue[] => {
+  if (words.labels.length === 0) return [];
+  const lines = text.lines.flatMap((line) => labelledLine(line) ?? []);
+  const rows = text.tables.flatMap((table) => keyValueRows(table, words.labels));
+  const labelled = [...lines, ...rows].toSorted((left, right) => left.offset - right.offset);
+  const context = { words, stated: statedRate(labelled, words.labels) };
+  return [...text.tables.flatMap((table) => tableIssues(table, context)), ...labelledIssues(labelled, text.headings, context)].toSorted(
+    (left, right) => left.offset - right.offset,
+  );
+};

package/src/structure/shift-times.ts

@@ -0,0 +1,136 @@
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import { linesOf } from "./lines.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { isReversed, rangeReading } from "./time-range.ts";
+import { dayShiftOf, wordOffsets, type Mark, type TimeSpan, type TimeWords } from "./time-marks.ts";
+
+/**
+ * 勤務表のように、始まりと終わりの時刻を別の列に書いた表（始業 | 終業、Start | End）。列は見出しの名前で読む（語彙表 shift-column の
+ * 組 start、end、hours、break）。行の終わりが始まりより前なら、どちらかの書き間違いか夜をまたぐ勤務。
+ * 文書に夜をまたぐ勤務の印（夜勤、night shift、翌 6:00、24 時を超える時刻）があれば言わない。両方に同じ午前・午後を書いた行は書き間違い。
+ * 実働の列があれば、夜をまたいで読んだ長さ（と、十二時間制で読んだ長さ）が実働と合わず、戻りが半日未満の行だけを言う。
+ * 実働が読めなければ、文の中の範囲と同じく打ち間違いの幅の戻りだけを言う。
+ */
+
+const MINUTES_PER_HOUR = 60;
+const SECONDS_PER_MINUTE = 60;
+const MINUTES_PER_DAY = 24 * MINUTES_PER_HOUR;
+const MINUTES_PER_HALF_DAY = 12 * MINUTES_PER_HOUR;
+const SECONDS_PER_HALF_DAY = MINUTES_PER_HALF_DAY * SECONDS_PER_MINUTE;
+/** 実働を小数の時間で書いたときの丸め（8.33 は 499.8 分）。 */
+const ROUNDING_MINUTES = 3;
+/** 翌日の印（「翌日 」）を探す、時刻の前の字数。 */
+const DAY_SHIFT_LOOK_BACK = 4;
+
+export type ShiftSide = "start" | "end" | "hours" | "break";
+
+export type ShiftInputs = {
+  readonly source: string;
+  readonly times: readonly TimeSpan[];
+  /** 列の見出しの名前。group が start、end、hours、break のどれか。 */
+  readonly columns: readonly Mark[];
+  /** 文書に夜をまたぐ勤務の印があるか。 */
+  readonly overnight: boolean;
+  /** 升に書いた長さ（8.0時間、1:00、8.00）を分で。読めなければ undefined。cellMinutes で読む。 */
+  readonly lengthOf: (text: string) => number | undefined;
+};
+
+/** 見出しの升の後ろの括弧書き（「始業（時刻）」「Start (local)」）。列の名前はその前まで。 */
+const NOTE_OPENER = /[(（[［]/u;
+
+const columnName = (heading: string): string => {
+  const note = heading.search(NOTE_OPENER);
+  return (note === -1 ? heading : heading.slice(0, note)).trim().toLowerCase();
+};
+
+/** 見出しに括弧書きがあるか（「休憩（分）」「Hours (decimal)」）。単位を書き添えた列の、単位の無い数は時間と読まない。 */
+export const hasHeadingNote = (heading: string): boolean => NOTE_OPENER.test(heading);
+
+const CLOCK_LENGTH = /^(\d{1,2}):([0-5]\d)$/u;
+const BARE_HOURS = /^\d{1,2}(?:\.\d{1,2})?$/u;
+
+/**
+ * 升に書いた長さを分で。単位付き（8.0時間、9時間30分、8 hours）、時と分（1:00）、bareHours なら単位の無い時間（8.00）も。
+ * lengths はその升の文字列から読んだ時間の長さ。
+ */
+export const cellMinutes = (text: string, lengths: readonly (Span & { readonly minutes: number })[], bareHours: boolean): number | undefined => {
+  const only = lengths.length === 1 ? lengths[0] : undefined;
+  if (only !== undefined) return only.start === 0 && only.end === text.length ? only.minutes : undefined;
+  const clock = CLOCK_LENGTH.exec(text);
+  if (clock !== null) return Number(clock[1]) * MINUTES_PER_HOUR + Number(clock[2]);
+  return bareHours && BARE_HOURS.test(text) ? Number(text) * MINUTES_PER_HOUR : undefined;
+};
+
+export const columnOf = (header: readonly Cell[], columns: readonly Mark[], side: ShiftSide): number =>
+  header.findIndex((cell) => columns.some((mark) => mark.group === side && mark.pattern.toLowerCase() === columnName(cell.text)));
+
+/** 升に時刻だけを書いたときの、その時刻。 */
+export const onlyTime = (cell: Cell | undefined, times: readonly TimeSpan[], source: string): TimeSpan | undefined => {
+  if (cell === undefined) return undefined;
+  const within = times.filter((time) => time.start >= cell.start && time.end <= cell.end);
+  const only = within.length === 1 ? within[0] : undefined;
+  return only !== undefined && source.slice(only.start, only.end) === cell.text.trim() ? only : undefined;
+};
+
+type Row = { readonly start: TimeSpan; readonly end: TimeSpan; readonly hours: number | undefined; readonly break: number | undefined };
+
+/** 実働と休憩から見て、夜をまたぐ勤務でも十二時間制の書き方でもない行か。 */
+const hoursContradictOvernight = (row: Row, hours: number, rest: number): boolean => {
+  const span = (row.end.seconds - row.start.seconds) / SECONDS_PER_MINUTE;
+  const overnight = span + MINUTES_PER_DAY - rest;
+  const twelveHour = span + MINUTES_PER_HALF_DAY - rest;
+  return [overnight, twelveHour].every((reading) => Math.abs(hours - reading) > ROUNDING_MINUTES);
+};
+
+/** 実働か休憩が読めない行は、文の中の範囲と同じく打ち間違いの幅の戻りだけを言う。 */
+const isReversedRow = (row: Row, inputs: ShiftInputs): boolean => {
+  const reading = rangeReading(inputs.source, row.start, row.end);
+  const back = reading.from - reading.to;
+  if (back <= 0) return false;
+  if (reading.sameHalf === true) return true;
+  if (inputs.overnight) return false;
+  if (row.hours === undefined || row.break === undefined) return isReversed(reading);
+  return back < SECONDS_PER_HALF_DAY && hoursContradictOvernight(row, row.hours, row.break);
+};
+
+/** 列の升の長さ。列が無ければ休憩は 0、実働は読まない。 */
+const lengthIn = (cells: readonly Cell[], column: number, inputs: ShiftInputs, absent: number | undefined): number | undefined => {
+  if (column === -1) return absent;
+  const cell = cells[column];
+  return cell === undefined ? undefined : inputs.lengthOf(cell.text.trim());
+};
+
+type Labels = { readonly start: string; readonly end: string };
+
+const issueOf = (row: Row, labels: Labels, source: string): StructureIssue => {
+  const [start, end] = [source.slice(row.start.start, row.start.end), source.slice(row.end.start, row.end.end)];
+  return { offset: row.end.start, values: { range: `${start} | ${end}`, start, end, start_label: labels.start, end_label: labels.end } };
+};
+
+/** 始まりの列と終わりの列を見出しから読む表の、終わりが始まりより前の行。終わりの時刻を指す。 */
+export const reversedShiftRows = (inputs: ShiftInputs): StructureIssue[] =>
+  tablesOf(linesOf(inputs.source)).flatMap((table) => {
+    const header = cellsOf(table.header);
+    const [starts, ends, hours, breaks] = (["start", "end", "hours", "break"] as const).map((side) => columnOf(header, inputs.columns, side));
+    if (starts === undefined || ends === undefined || starts === -1 || ends === -1) return [];
+    const labels = { start: header[starts]?.text.trim() ?? "", end: header[ends]?.text.trim() ?? "" };
+    return table.rows.flatMap((line) => {
+      const cells = cellsOf(line);
+      const [start, end] = [onlyTime(cells[starts], inputs.times, inputs.source), onlyTime(cells[ends], inputs.times, inputs.source)];
+      if (start === undefined || end === undefined) return [];
+      const row = { start, end, hours: lengthIn(cells, hours ?? -1, inputs, undefined), break: lengthIn(cells, breaks ?? -1, inputs, 0) };
+      return isReversedRow(row, inputs) ? [issueOf(row, labels, inputs.source)] : [];
+    });
+  });
+
+/** 24 時を超える時刻（25:30）。夜をまたぐ勤務を当日の続きで書く書き方。 */
+const PAST_MIDNIGHT = /(?<![\d:])(?:2[4-9]|3\d|4[0-7]):[0-5]\d(?!\d)/u;
+
+/** 文書に夜をまたぐ勤務の印があるか。語（夜勤、night shift。語彙表 overnight-work-mark）、翌日の印を付けた時刻、24 時を超える時刻。 */
+export const showsOvernightWork = (source: string, times: readonly TimeSpan[], marks: readonly Mark[], words: TimeWords): boolean => {
+  const lower = source.toLowerCase();
+  if (marks.some((mark) => wordOffsets(lower, mark.pattern.toLowerCase()).length > 0)) return true;
+  if (PAST_MIDNIGHT.test(source)) return true;
+  return times.some((time) => dayShiftOf(source.slice(Math.max(0, time.start - DAY_SHIFT_LOOK_BACK), time.start), source, time.end, words) > 0);
+};

package/src/structure/span-label.ts

@@ -0,0 +1,26 @@
+import { leadOf } from "./stated-period.ts";
+
+const LABEL_COLON = /[:：]/u;
+const LABEL_CLOSE = /(?:\*\*|__|】|\])$/u;
+/** 見出しの語は数語（Sales period）。コロンの前がそれより長ければ文で、見出しではない。 */
+const MAX_LABEL_WORDS = 4;
+
+/** 期間を名指す語（period、dates）で終わる短い見出しとコロン（Sales period:）の後ろの、行の中の位置。そうした見出しの無い行は undefined。 */
+export const afterSpanLabel = (line: string, heads: readonly string[]): number | undefined => {
+  const lead = leadOf(line);
+  const colon = line.slice(lead).search(LABEL_COLON);
+  if (colon === -1) return undefined;
+  const label = line
+    .slice(lead, lead + colon)
+    .replace(LABEL_CLOSE, "")
+    .trim()
+    .toLowerCase()
+    .split(/\s+/u);
+  if (label.length > MAX_LABEL_WORDS) return undefined;
+  const text = label.join(" ");
+  const named = heads.some((head) => {
+    const word = head.toLowerCase();
+    return text === word || text.endsWith(` ${word}`);
+  });
+  return named ? lead + colon + 1 : undefined;
+};

package/src/structure/start-end-range.ts

@@ -0,0 +1,120 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { Lexicon } from "../plugin.ts";
+import { bare, withoutTrailingWeekday, type DatedSpan } from "./date-range.ts";
+
+/**
+ * 始まりの語と終わりの語で書いた期間（The term starts on 1 April 2026 and ends on 31 March 2027、2026年4月1日から開始し、2027年3月31日に終了する）。
+ * 一つ目の日付に始まりの語が、二つ目の日付に終わりの語が付き、二つの日付の間は付いた語とつなぎの語だけ。
+ * 文に始まりの語か終わりの語が二つあれば、どの日付がどの期間のものか決まらないので読まない。語は語彙表（range-start-end）から受け取る。
+ */
+export type StartEndWord = { readonly word: string; readonly position: "before" | "after" };
+
+export type StartEndWords = {
+  readonly starts: readonly StartEndWord[];
+  readonly ends: readonly StartEndWord[];
+  /** 始まりの語と終わりの語の間に立つ語（and、and shall、し、）。 */
+  readonly joints: readonly string[];
+  /**
+   * 終わりの日付の後ろに付く終わりの語（に終了）の、さらに後ろに来てよい語（する、し、）。「、」で終わる語は文が続くので頭だけを照らし、
+   * ほかは文の終わりまでがその語だけ。「に終了した旧契約」は名詞にかかる語で、期間の終わりではない。
+   */
+  readonly tails: readonly string[];
+  readonly weekdays: readonly string[];
+};
+
+/** 文の終わり。英語は後ろが大文字のときだけ（"in Jan. 2026" は切らない）。段落の切れ目も文の終わり。 */
+const SENTENCE_END = /[。！？]|[.!?]\s+(?=[A-Z])|\n\s*\n/gu;
+
+const flat = (text: string): string => text.replace(/\s+/gu, " ").toLowerCase();
+
+const LATIN = /[a-z]/u;
+
+/** 英字の語は語の切れ目で照らす（ends が depends に当たらない）。英字で始まらない・終わらない語は、その側を照らさない。 */
+const wordPattern = (word: string, flags: string): RegExp => {
+  const head = LATIN.test(word.charAt(0)) ? "(?<![a-z])" : "";
+  const tail = LATIN.test(word.at(-1) ?? "") ? "(?![a-z])" : "";
+  return new RegExp(`${head}${escapeRegExp(word)}${tail}`, flags);
+};
+
+const endsWithWord = (text: string, word: string): boolean => new RegExp(`${wordPattern(word, "u").source}$`, "u").test(text);
+
+const startsWithWord = (text: string, word: string): boolean => new RegExp(`^${wordPattern(word, "u").source}`, "u").test(text);
+
+/** 文の中で、語のどれかに当たる所の数。重なる当たり（starts と starts on）は一つ。 */
+export const occurrences = (text: string, words: readonly StartEndWord[]): number => {
+  const spans = words
+    .flatMap(({ word }) => [...text.matchAll(wordPattern(word, "gu"))].map((match) => ({ start: match.index, end: match.index + match[0].length })))
+    .toSorted((left, right) => left.start - right.start || right.end - left.end);
+  return spans.reduce(
+    (acc, span) => (span.start >= acc.end ? { count: acc.count + 1, end: span.end } : { count: acc.count, end: Math.max(acc.end, span.end) }),
+    {
+      count: 0,
+      end: -1,
+    },
+  ).count;
+};
+
+type Sentence = { readonly before: string; readonly between: string; readonly after: string; readonly whole: string };
+
+/** 二つの日付を含む文を、始まりの日付の前、二つの日付の間、終わりの日付の後ろに分ける。間に文の終わりがあれば undefined。 */
+const sentenceOf = (source: string, start: DatedSpan, end: DatedSpan): Sentence | undefined => {
+  const between = source.slice(start.end, end.offset);
+  if (new RegExp(SENTENCE_END.source, "u").test(between)) return undefined;
+  const from = [...source.slice(0, start.offset).matchAll(SENTENCE_END)].map((match) => match.index + match[0].length).at(-1) ?? 0;
+  const tail = source.slice(end.end);
+  const to = end.end + ([...tail.matchAll(SENTENCE_END)][0]?.index ?? tail.length);
+  const before = flat(source.slice(from, start.offset)).trimEnd();
+  const after = bare(source.slice(end.end, to));
+  return { before, between: bare(between), after, whole: flat(source.slice(from, to)) };
+};
+
+const beforeWord = (text: string, words: readonly StartEndWord[]): string | undefined =>
+  words.find((entry) => entry.position === "before" && endsWithWord(text, entry.word))?.word;
+
+const afterWord = (text: string, words: readonly StartEndWord[]): string | undefined =>
+  words.find((entry) => entry.position === "after" && startsWithWord(text, entry.word))?.word;
+
+const endsPredicate = (rest: string, tails: readonly string[]): boolean => tails.some((tail) => (tail.endsWith("、") ? rest.startsWith(tail) : rest === tail));
+
+/** 終わりの日付の後ろの終わりの語で、その後ろが述語の終わり（に終了する。に終了し、）。 */
+const endAfterWord = (after: string, words: StartEndWords): string | undefined => {
+  const word = afterWord(after, words.ends);
+  return word !== undefined && endsPredicate(after.slice(word.length).trim(), words.tails) ? word : undefined;
+};
+
+/** 間の語から、始まりの日付の後ろの語と終わりの日付の前の語を除いた残りが、つなぎの語か。 */
+const joinedBetween = (between: string, words: StartEndWords, startAfter: string | undefined, endBefore: string | undefined): boolean => {
+  const head = startAfter === undefined ? between : between.slice(startAfter.length).trimStart();
+  const rest = endBefore === undefined ? head : head.slice(0, head.length - endBefore.length).trimEnd();
+  return words.joints.some((joint) => joint.toLowerCase() === rest);
+};
+
+/** 二つの日付が、始まりの語と終わりの語で書いた一つの期間か。 */
+export const isStartEndRange = (source: string, start: DatedSpan, end: DatedSpan, words: StartEndWords): boolean => {
+  const sentence = sentenceOf(source, start, end);
+  if (sentence === undefined) return false;
+  if (occurrences(sentence.whole, words.starts) !== 1 || occurrences(sentence.whole, words.ends) !== 1) return false;
+  const between = withoutTrailingWeekday(sentence.between, words.weekdays);
+  const startBefore = beforeWord(withoutTrailingWeekday(sentence.before, words.weekdays), words.starts);
+  const startAfter = afterWord(between, words.starts);
+  const endBefore = beforeWord(between, words.ends);
+  const endAfter = endAfterWord(sentence.after, words);
+  if ((startBefore ?? startAfter) === undefined || (endBefore ?? endAfter) === undefined) return false;
+  return joinedBetween(between, words, startAfter, endBefore);
+};
+
+const wordsIn = (entries: Lexicon, group: "start" | "end"): StartEndWord[] =>
+  entries
+    .filter((entry) => entry.group === group)
+    .map((entry) => ({ word: entry.pattern.toLowerCase(), position: entry.position === "after" ? "after" : "before" }));
+
+const patternsIn = (entries: Lexicon, group: string): string[] => entries.filter((entry) => entry.group === group).map((entry) => entry.pattern.toLowerCase());
+
+/** 語彙表 range-start-end の行を、group（start、end、joint、tail）で分ける。 */
+export const startEndWordsOf = (entries: Lexicon, weekdays: readonly string[]): StartEndWords => ({
+  starts: wordsIn(entries, "start"),
+  ends: wordsIn(entries, "end"),
+  joints: patternsIn(entries, "joint"),
+  tails: patternsIn(entries, "tail"),
+  weekdays,
+});

package/src/structure/stated-multiple.ts

@@ -0,0 +1,82 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * The reading shared by the rules that compare an amount stated as a number of another stated amount: a deposit in months
+ * of rent (rent-multiple.ts), an annual premium in monthly payments (period-multiple.ts). Words are matched whole, amounts
+ * are read as the interval their written digits allow, and a multiple is taken of the nearest stated base. Pure.
+ */
+
+/** One amount of money as read: its currency, its value, and the value of the word of scale written in it (万), if any. */
+export type StatedAmount = {
+  readonly offset: number;
+  readonly end: number;
+  readonly currency: string;
+  readonly value: number;
+  readonly scale: number | undefined;
+};
+
+/** An amount read as the interval its written digits allow (9.8万円 is anything from 97,500 to 98,500). */
+export type Interval = { readonly low: number; readonly high: number };
+
+export type Span = { readonly start: number; readonly end: number };
+
+/** Rounding to the currency's unit (a yen, a dollar) is allowed on top of the written precision. */
+const UNIT_SLACK = 1;
+
+const LATIN = /[A-Za-z]/u;
+const SEPARATORS = /[\s|｜:：=＝、，,・/／'’()（）[\]［］-]/gu;
+const PARENTHETICAL_WITHOUT_DIGITS = /[（(][^()（）0-9０-９]*[)）]/gu;
+/** The possessive after a count (2 months' rent, 1 month's rent). */
+const POSSESSIVE = /['’]s?(?![A-Za-z])/gu;
+
+const wordPattern = (word: string): string => {
+  const edgeStart = LATIN.test(word.charAt(0)) ? "(?<![A-Za-z])" : "";
+  const edgeEnd = LATIN.test(word.charAt(word.length - 1)) ? "(?![A-Za-z])" : "";
+  return `${edgeStart}${escapeRegExp(word)}${edgeEnd}`;
+};
+
+/** One alternation of the words, longest first so 月額賃料 wins over 賃料. Undefined when there are none. */
+export const alternation = (words: readonly string[]): string | undefined =>
+  words.length === 0
+    ? undefined
+    : words
+        .toSorted((left, right) => right.length - left.length)
+        .map(wordPattern)
+        .join("|");
+
+export const occurrences = (text: string, words: readonly string[]): Span[] => {
+  const pattern = alternation(words);
+  if (pattern === undefined) return [];
+  return [...text.matchAll(new RegExp(pattern, "giu"))].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+};
+
+const withoutWords = (text: string, words: readonly string[]): string => {
+  const pattern = alternation(words);
+  return pattern === undefined ? text : text.replace(new RegExp(pattern, "giu"), "");
+};
+
+/** Whether only separators, bracketed words and link words stand in the gap (「 | 」, " (monthly): ", "の", "'s rent ("). */
+export const isPlainGap = (gap: string, words: readonly string[]): boolean =>
+  withoutWords(gap.replace(PARENTHETICAL_WITHOUT_DIGITS, "").replace(POSSESSIVE, ""), words).replace(SEPARATORS, "") === "";
+
+const decimalsOf = (written: string): number => /[.．]([0-9０-９]+)/u.exec(written)?.[1]?.length ?? 0;
+
+/** The interval an amount's digits allow: a word of scale (9.8万) leaves half its last digit either way; plain digits are exact. */
+export const intervalOf = (amount: StatedAmount, written: string): Interval => {
+  const half = amount.scale === undefined ? 0 : (amount.scale * 10 ** -decimalsOf(written)) / 2;
+  return { low: amount.value - half, high: amount.value + half };
+};
+
+/** Whether the amount is the count of one of the bases, within the written precision and a unit's rounding. */
+export const isMultiple = (count: number, amount: Interval, bases: readonly Interval[]): boolean =>
+  bases.some((base) => count * base.low - UNIT_SLACK <= amount.high && amount.low <= count * base.high + UNIT_SLACK);
+
+type Stated = { readonly offset: number; readonly range: Interval | undefined };
+
+/** The base a statement at this offset is of: the nearest before it, or, before any, the one base the document states. */
+export const nearestStated = <T extends Stated>(bases: readonly T[], offset: number): T | undefined => {
+  const before = bases.filter((base) => base.offset < offset).at(-1);
+  if (before !== undefined) return before;
+  const [first] = bases;
+  return bases.every((base) => base.range !== undefined && base.range.low === first?.range?.low && base.range.high === first.range.high) ? first : undefined;
+};

package/src/structure/stated-period.ts

@@ -1,5 +1,7 @@
 import { escapeRegExp } from "../orthography.ts";
 import { withoutTrailingWeekday } from "./date-range.ts";
+import { keyValueCell } from "./key-value-row.ts";
+import { TABLE_ROW } from "./runs.ts";
 
 /**
  * 文書が書いた期間（旅行期間：10月12日〜10月15日、Trip period: Oct 12–15）。期間の語（period-label）で始まる一行だけを読む。
@@ -19,15 +21,12 @@ export type PeriodWords = {
 
 export type Period = { readonly start: string; readonly end: string; readonly written: string };
 
-/**
- * 行の頭の印（見出し、箇条書き、引用）と、語を囲む太字や括弧の開き。表の行は読まない。
- * 「| Conference | May 3–5 |」は催しを並べた表の一行で、文書の期間ではない。
- */
+/** 行の頭の印（見出し、箇条書き、引用）と、語を囲む太字や括弧の開き。表の行は statedPeriod が別に読む。 */
 const LINE_MARKS = /^[ \t]*(?:(?:#{1,6}|[-*+>]|\d{1,3}[.)])[ \t]*)*/u;
 const LABEL_OPEN = /^(?:\*\*|__|【|\[)?/u;
 const LABEL_END = /^(?:\*\*|__|】|\])?(?:[ \t]*[:：][ \t]*|[ \t\u3000]+)/u;
 
-const leadOf = (line: string): number => {
+export const leadOf = (line: string): number => {
   const marks = LINE_MARKS.exec(line)?.[0].length ?? 0;
   return marks + (LABEL_OPEN.exec(line.slice(marks))?.[0].length ?? 0);
 };
@@ -149,13 +148,26 @@ const datesOf = (line: string, lineStart: number, from: number, dates: readonly
   return monthRange(line.slice(from), words);
 };
 
+/** 期間を書いた部分の、行の中の始まりと終わり。表の行は、その表（tableOf）を渡したときだけ、二列の表の内容の升を読む。 */
+const valueSpan = (line: string, labels: readonly string[], tableOf: (() => readonly string[]) | undefined): { from: number; to: number } | undefined => {
+  if (TABLE_ROW.test(line)) return tableOf === undefined ? undefined : keyValueCell(line, tableOf, labels);
+  const from = afterLabel(line, labels);
+  return from === undefined ? undefined : { from, to: line.length };
+};
+
 /**
  * 期間の語で始まる一行の期間。行の中の日付が二つで間が範囲の記号なら、その二つ。一つなら、その前か後ろに日だけを書いた片方を読む。
- * 日付の無い行は、月の名と日の範囲を読む。読めなければ undefined。
+ * 日付の無い行は、月の名と日の範囲を読む。読めなければ undefined。tableOf はその行を含む表の行を返し、渡すと二列の表の一行（| 対象期間 | … |）も読む。
  */
-export const statedPeriod = (line: string, lineStart: number, dates: readonly DateMention[], words: PeriodWords): Period | undefined => {
-  const from = afterLabel(line, words.labels);
-  if (from === undefined) return undefined;
-  const found = datesOf(line, lineStart, from, dates, words);
-  return found === undefined ? undefined : { ...found, written: line.slice(from).trim() };
+export const statedPeriod = (
+  line: string,
+  lineStart: number,
+  dates: readonly DateMention[],
+  words: PeriodWords,
+  tableOf?: () => readonly string[],
+): Period | undefined => {
+  const span = valueSpan(line, words.labels, tableOf);
+  if (span === undefined) return undefined;
+  const found = datesOf(line.slice(0, span.to), lineStart, span.from, dates, words);
+  return found === undefined ? undefined : { ...found, written: line.slice(span.from, span.to).trim() };
 };