chaffjs 0.31.0 → 0.32.0

package/src/structure/cumulative-below-current.ts

@@ -0,0 +1,66 @@
+// cumulative-below-current: a table with a this-period column and a cumulative one (当月 / 累計, "This period" / "Year to
+// date"), where a row's cumulative figure is lower than its figure for this period. A running total includes this period, so
+// it cannot be the smaller. The columns are named by their heading words only. Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, sameHeadingUnits, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+
+/**
+ * current and cumulative name the two columns; prior names a heading that is neither (「前月までの累計」 is not this period's
+ * running total); level names a figure that is a level, not a sum over periods (an average, a rate, a balance), in a row label or a heading.
+ */
+export type CumulativeRole = "current" | "cumulative" | "prior" | "level";
+export type CumulativeWord = { readonly pattern: string; readonly role: CumulativeRole };
+
+/**
+ * prior first (「前月累計」 is not the running total), then level ("Current balance" is not this period), then cumulative
+ * (「当月累計」 is the running total, not this month). A prior or level heading is neither column.
+ */
+const HEADING_ORDER: readonly CumulativeRole[] = ["prior", "level", "cumulative", "current"];
+
+const roleOf = (heading: string, words: readonly CumulativeWord[]): CumulativeRole | undefined => {
+  const key = plain(heading).toLowerCase();
+  return HEADING_ORDER.find((role) => words.some((word) => word.role === role && holds(key, word.pattern)));
+};
+
+type Columns = { readonly current: number; readonly cumulative: number };
+
+/** The one this-period column and the one cumulative column; undefined when either is missing or doubled, or their units differ. */
+export const cumulativeColumnsOf = (headings: readonly string[], words: readonly CumulativeWord[]): Columns | undefined => {
+  const roles = headings.map((heading) => roleOf(heading, words));
+  const all = (role: CumulativeRole): number[] => roles.flatMap((found, index) => (found === role ? [index] : []));
+  const [currents, cumulatives] = [all("current"), all("cumulative")];
+  const [current, cumulative] = [currents[0], cumulatives[0]];
+  if (currents.length !== 1 || cumulatives.length !== 1 || current === undefined || cumulative === undefined) return undefined;
+  return sameHeadingUnits(headings[current], headings[cumulative]) ? { current, cumulative } : undefined;
+};
+
+/** A row whose label says its figure is a level (平均単価, "Average rate"), which a running total does not add up. */
+const isLevelRow = (row: readonly TableCell[], columns: Columns, words: readonly CumulativeWord[]): boolean => {
+  const label = columns.current === 0 || columns.cumulative === 0 ? "" : plain(row[0]?.text ?? "").toLowerCase();
+  return words.some((word) => word.role === "level" && holds(label, word.pattern));
+};
+
+/** Room for the binary fractions of decimal amounts, as a share of the rounding allowed. */
+const EPSILON = 1e-6;
+
+const issueInRow = (row: readonly TableCell[], columns: Columns, words: readonly CumulativeWord[]): StructureIssue[] => {
+  const [currentCell, cumulativeCell] = [row[columns.current], row[columns.cumulative]];
+  if (currentCell === undefined || cumulativeCell === undefined || isLevelRow(row, columns, words)) return [];
+  const [current, cumulative] = [valueIn(currentCell.text), valueIn(cumulativeCell.text)];
+  if (current === undefined || cumulative === undefined || current.marks !== cumulative.marks) return [];
+  const rounding = ((current.step + cumulative.step) / 2) * (1 + EPSILON);
+  if (current.value - cumulative.value <= rounding) return [];
+  const offset = cumulativeCell.start + (cumulativeCell.text.length - cumulativeCell.text.trimStart().length);
+  return [{ offset, values: { cumulative: plain(cumulativeCell.text), current: plain(currentCell.text) } }];
+};
+
+/** Each row, in every table with one this-period and one cumulative column, whose cumulative figure is below this period's. */
+export const cumulativeBelowCurrent = (tables: readonly ChangeTable[], words: readonly CumulativeWord[]): StructureIssue[] =>
+  tables.flatMap((table) => {
+    const columns = cumulativeColumnsOf(
+      table.header.map((cell) => cell.text),
+      words,
+    );
+    if (columns === undefined) return [];
+    return table.rows.filter((row) => row.length === table.header.length).flatMap((row) => issueInRow(row, columns, words));
+  });

package/src/structure/currency-column.ts

@@ -0,0 +1,97 @@
+// currency-column-mix: one column of amounts with a single cell in another currency (USD 45 among 円 amounts). Which
+// currency an amount is in, and which heading words make a table one that converts or lists currencies, come from the
+// language packages. Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { bodyRows, offsetOf } from "./order-quantity.ts";
+
+/** A way of writing a currency (円, ¥, USD, ドル) and the currency it means (JPY, USD). */
+export type CurrencyWord = { readonly pattern: string; readonly currency: string };
+
+export type CurrencyColumnWords = {
+  /** The currency marks, to read which currencies a heading or a row label names. */
+  readonly currencies: readonly CurrencyWord[];
+  /** Heading words of a column that says the currency or the exchange rate (通貨, Currency, 為替, exchange rate). */
+  readonly columns: readonly string[];
+  /** The currencies of the amounts written in a cell's text (USD 45 → USD). */
+  readonly amountCurrencies: (text: string) => readonly string[];
+};
+
+/** The majority currency must stand in at least this many cells of the column. */
+const MIN_MAJORITY = 2;
+/** A column holds two currencies: the one most cells are in and the one odd cell's. */
+const CURRENCIES_IN_MIX = 2;
+
+const namedCurrencies = (text: string, words: readonly CurrencyWord[]): Set<string> => {
+  const key = plain(text).toLowerCase();
+  return new Set(words.filter((word) => holds(key, word.pattern)).map((word) => word.currency));
+};
+
+const BRACKETED = /[(（]([^()（）]*)[)）]/gu;
+
+/** The currencies a row label names in brackets (送金手数料（USD）); 円 in a word (円滑化) names none. */
+const bracketedCurrencies = (label: string, words: readonly CurrencyWord[]): Set<string> =>
+  new Set([...label.matchAll(BRACKETED)].flatMap((match) => [...namedCurrencies(match[1] ?? "", words)]));
+
+type Priced = { readonly cell: TableCell; readonly label: string; readonly currency: string };
+
+/** The cells of one column with an amount in exactly one currency; undefined when a cell gives two (¥12,500 (USD 85)). */
+const pricedCells = (rows: readonly (readonly TableCell[])[], column: number, words: CurrencyColumnWords): Priced[] | undefined => {
+  const read = rows.flatMap((row) => {
+    const cell = row[column];
+    if (cell === undefined) return [];
+    const currencies = [...new Set(words.amountCurrencies(cell.text))];
+    return currencies.length === 0 ? [] : [{ cell, label: plain(row[0]?.text ?? ""), currencies }];
+  });
+  if (read.some((entry) => entry.currencies.length > 1)) return undefined;
+  return read.flatMap(({ cell, label, currencies: [currency] }) => (currency === undefined ? [] : [{ cell, label, currency }]));
+};
+
+const countsOf = (cells: readonly Priced[]): Map<string, number> =>
+  cells.reduce((counts, { currency }) => counts.set(currency, (counts.get(currency) ?? 0) + 1), new Map<string, number>());
+
+/**
+ * The one cell whose currency differs from the rest: the column holds two currencies, the majority in at least two cells
+ * and the other in exactly one. A row whose label names the odd currency (送金手数料（USD）) says so itself.
+ */
+const oddCell = (cells: readonly Priced[], words: CurrencyColumnWords): { odd: Priced; usual: Priced } | undefined => {
+  const counts = [...countsOf(cells).entries()].toSorted((left, right) => right[1] - left[1]);
+  const [major, minor] = counts;
+  if (counts.length !== CURRENCIES_IN_MIX || major === undefined || minor === undefined) return undefined;
+  if (major[1] < MIN_MAJORITY || minor[1] !== 1) return undefined;
+  const odd = cells.find((cell) => cell.currency === minor[0]);
+  const usual = cells.find((cell) => cell.currency === major[0]);
+  if (odd === undefined || usual === undefined || bracketedCurrencies(odd.label, words.currencies).has(odd.currency)) return undefined;
+  return { odd, usual };
+};
+
+const columnIssue = (table: ChangeTable, column: number, words: CurrencyColumnWords): StructureIssue[] => {
+  const heading = table.header[column]?.text ?? "";
+  if (namedCurrencies(heading, words.currencies).size >= CURRENCIES_IN_MIX) return [];
+  const cells = pricedCells(bodyRows(table), column, words);
+  const found = cells === undefined ? undefined : oddCell(cells, words);
+  if (found === undefined) return [];
+  const { odd, usual } = found;
+  return [
+    {
+      offset: offsetOf(odd.cell),
+      values: { item: odd.label, written: plain(odd.cell.text), usual: plain(usual.cell.text), currency: odd.currency, majority: usual.currency },
+    },
+  ];
+};
+
+const listsCurrencies = (table: ChangeTable, columns: readonly string[]): boolean =>
+  table.header.some((cell) => {
+    const key = plain(cell.text).toLowerCase();
+    return columns.some((word) => holds(key, word));
+  });
+
+/**
+ * Each column of amounts with one cell in another currency than the rest. A table with a column of currencies or of exchange
+ * rates converts on purpose, and a column whose heading names two currencies (金額（円/USD）) holds both on purpose.
+ */
+export const currencyColumnMix = (tables: readonly ChangeTable[], words: CurrencyColumnWords): StructureIssue[] =>
+  tables.flatMap((table) => {
+    if (listsCurrencies(table, words.columns)) return [];
+    return table.header.flatMap((_, column) => columnIssue(table, column, words));
+  });

package/src/structure/date-deadline-mark.ts

@@ -0,0 +1,30 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 日付を締め切りにする語が、その日付に付いているか（9月18日までに、by September 18）。語の position が日付のどちら側に立つかを言う
+ * （「までに」は after、「by」は before）。position の無い語は読まない。日付の後ろの語との間には空白、曜日などの括弧（（金））、
+ * 時刻（17時、5:00 p.m.）を置いてよく、日付の前の語との間には空白だけを置く。行はまたがない。Pure.
+ */
+export type DateSpan = { readonly offset: number; readonly end: number };
+export type DeadlineMark = { readonly pattern: string; readonly position?: "before" | "after" | undefined };
+
+const SPACE = String.raw`[^\S\n]`;
+const GAP_AFTER = String.raw`${SPACE}*(?:[（(][^）)\n]{1,8}[）)])?${SPACE}*(?:\d{1,2}(?:[:：]\d{2}|時(?:\d{1,2}分)?)(?:${SPACE}*[ap]\.?m\.?)?)?${SPACE}*`;
+const NEAR = 40;
+
+const isWordy = (text: string): boolean => /[a-z]/iu.test(text);
+
+const followingPattern = (word: string): RegExp => new RegExp(`^${GAP_AFTER}${escapeRegExp(word)}${isWordy(word) ? "(?![a-z])" : ""}`, "iu");
+const precedingPattern = (word: string): RegExp => new RegExp(`${isWordy(word) ? "(?<![a-z])" : ""}${escapeRegExp(word)}${SPACE}+$`, "iu");
+
+export const isDeadlineDate = (source: string, date: DateSpan, marks: readonly DeadlineMark[]): boolean => {
+  const following = source.slice(date.end, date.end + NEAR);
+  const preceding = source.slice(Math.max(0, date.offset - NEAR), date.offset);
+  return marks.some((mark) => {
+    const word = mark.pattern.trim();
+    if (word === "") return false;
+    if (mark.position === "after") return followingPattern(word).test(following);
+    if (mark.position === "before") return precedingPattern(word).test(preceding);
+    return false;
+  });
+};

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

@@ -2,14 +2,17 @@ import { escapeRegExp } from "../orthography.ts";
 import type { StructureIssue } from "./issues.ts";
 import { TABLE_ROW } from "./runs.ts";
 import { deadlineVerdict } from "./term-deadline.ts";
+import { isDeadlineDate, type DeadlineMark } from "./date-deadline-mark.ts";
+import { tableAround } from "./key-value-row.ts";
 import { statedPeriod, type DateMention, type Period, type PeriodWords } from "./stated-period.ts";
 
 /**
  * 書いた期間の外の日付。期間の語で始まる一行（旅行期間：…）が期間を書き、その後ろ、同じ節の中の箇条書きの項目、表の行、見出しの日付を比べる。
  * 地の文の日付は、年の無いもの（2月12日（金）の午前は…）だけを比べる。年のある日付は、過去の回や別の年の出来事を挙げることが多い。
  * 期間の前後に置く予定（前泊、follow-up）、締め切りや予約の日、過去の回を言う語（period-aside）が、その行、文、節の見出しにあれば比べない。
+ * 地の文で締め切りの語が付いた日付（9月18日までにお知らせください、by September 18）も、期間の後の返事の期限なので比べない。項目の日付は日程なので、付いていても比べる。
  * 年の無い期間（12月28日〜1月4日）は年をまたいで読む。
- * 文書の仕事の期間（開講期間：…）を文書の頭か概要の節で書いたものは文書全体の期間で、後ろのどの節でも、締め切りの語（period-deadline）のある項目や文の、
+ * 文書の仕事の期間（開講期間：…、二列の表の | 開講期間 | … |）を文書の頭か概要の節で書いたものは文書全体の期間で、後ろのどの節でも、締め切りの語（period-deadline）のある項目や文の、
  * 期間の終わりより後の日付を指す（課題の提出が学期の後）。年の無い日付は、期間が一つの年に収まるときだけその年と読む。成績発表や再試験の語（period-after-term）のある日付は比べない。期間の前の締め切り（申込締切）と、旅行期間のように後に締め切りが来てよい期間は比べない。
  */
 export type HeadingSpan = { readonly start: number; readonly end: number; readonly depth: number };
@@ -23,6 +26,8 @@ export type OutsideWords = PeriodWords & {
   readonly overviews: readonly string[];
   /** 期間の後に来てよい仕事の語（成績発表、再試験）。この語のある締め切りは期間と比べない。 */
   readonly afterTerm: readonly string[];
+  /** 日付を締め切りにする語（までに、by）。地の文でこの語の付いた日付は期間の中の予定ではないので、期間と比べない。 */
+  readonly deadlineMarks: readonly DeadlineMark[];
 };
 
 const LIST_ITEM = /^[ \t]{0,12}(?:[-*+]|\d{1,3}[.)])[ \t]/u;
@@ -82,15 +87,18 @@ const scopeEnd = (line: Span, next: number, headings: readonly HeadingSpan[], le
   return Math.min(closing, next);
 };
 
+/** readTables: 二列の表の一行も読むか。期間の語（Conference、日程）は催しを並べた表の最初の列にも来るので、仕事の期間の語でだけ読む。 */
 const statedPeriods = (
   source: string,
   lines: readonly Span[],
   dates: readonly DateMention[],
   headings: readonly HeadingSpan[],
   words: OutsideWords,
+  readTables: boolean,
 ): Stated[] => {
-  const found = lines.flatMap((line) => {
-    const period = statedPeriod(source.slice(line.start, line.end), line.start, dates, words);
+  const texts = lines.map((line) => source.slice(line.start, line.end));
+  const found = lines.flatMap((line, index) => {
+    const period = statedPeriod(texts[index] ?? "", line.start, dates, words, readTables ? () => tableAround(texts, index) : undefined);
     return period === undefined ? [] : [{ period, line }];
   });
   return found.map(({ period, line }, index) => ({
@@ -114,13 +122,13 @@ const surroundings = (date: DateMention, line: Span, item: boolean, context: Con
   return [context.source.slice(unit.start, unit.end), heading === undefined ? "" : context.source.slice(heading.start, heading.end)];
 };
 
-const outsideOne = (date: DateMention, period: Stated, context: Context, asides: readonly string[]): boolean => {
+const outsideOne = (date: DateMention, period: Stated, context: Context, words: OutsideWords): boolean => {
   if (!DAY_VALUE.test(date.value) || insidePeriod(date.value, period)) return false;
   const line = containing(context.lines, date.offset);
   if (line === undefined) return false;
   const item = isItem(context.source.slice(line.start, line.end), line, context.headings);
-  if (!item && hasYear(date.value)) return false;
-  return !surroundings(date, line, item, context).some((text) => mentions(text, asides));
+  if (!item && (hasYear(date.value) || isDeadlineDate(context.source, date, words.deadlineMarks))) return false;
+  return !surroundings(date, line, item, context).some((text) => mentions(text, words.asides));
 };
 
 const boundaryPattern = (word: string): RegExp => {
@@ -166,15 +174,15 @@ const issueOf = (source: string, date: DateMention, period: Stated): StructureIs
 
 /** 期間の行の後ろ、同じ節の日程の日付で、期間の外のもの。 */
 const outsideInSection = (dates: readonly DateMention[], context: Context, words: OutsideWords): StructureIssue[] =>
-  statedPeriods(context.source, context.lines, dates, context.headings, words).flatMap((period) =>
+  statedPeriods(context.source, context.lines, dates, context.headings, words, false).flatMap((period) =>
     dates
-      .filter((date) => date.offset > period.scopeStart && date.offset < period.scopeEnd && outsideOne(date, period, context, words.asides))
+      .filter((date) => date.offset > period.scopeStart && date.offset < period.scopeEnd && outsideOne(date, period, context, words))
       .map((date) => issueOf(context.source, date, period)),
   );
 
 /** 文書の仕事の期間の行の後ろ、次の仕事の期間の行までの、期間の終わりより後の締め切り。 */
 const lateDeadlines = (dates: readonly DateMention[], context: Context, words: OutsideWords): StructureIssue[] =>
-  statedPeriods(context.source, context.lines, dates, context.headings, { ...words, labels: words.terms })
+  statedPeriods(context.source, context.lines, dates, context.headings, { ...words, labels: words.terms }, true)
     .filter((period) => isDocumentTerm(period, context, words.overviews))
     .flatMap((period) =>
       dates

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,10 +52,6 @@ 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;
 
@@ -172,7 +169,7 @@ export const reversedRanges = (
 ): 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)) 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);
 };