chaffjs 0.30.0 → 0.32.0

package/src/structure/closing-balance.ts

@@ -0,0 +1,104 @@
+/**
+ * closing-balance-mismatch: the deciding half. A closing balance (当月末残高, Closing balance) against the opening balance
+ * (前月末残高, Opening balance) plus the total paid in (お預入れ合計, Total deposits) less the total paid out (お引出し合計,
+ * Total withdrawals), written in the same table or the same section. Which words name them is data (lexicon
+ * closing-balance-label, grouped opening / inflow / outflow / closing); an amount is read as net-amount-mismatch reads one.
+ * Pure.
+ */
+import { keyOf, labelKey, noteOf } from "./ratio.ts";
+import { amountOf, isExact, shown, type LabelledLine, type NetAmount, type NetCell, type NetIssue, type NetWords } from "./net-amount.ts";
+
+export const BALANCE_ROLES = ["opening", "inflow", "outflow", "closing"] as const;
+export type BalanceRole = (typeof BALANCE_ROLES)[number];
+
+export type BalanceWords = Pick<NetWords, "magnitudes" | "percentUnits"> & { readonly labels: Readonly<Record<BalanceRole, readonly string[]>> };
+
+export type BalanceAmount = NetAmount & { readonly role: BalanceRole };
+
+const DECIMAL_BASE = 10;
+const HALF = 0.5;
+/** Four amounts each rounded on their own to nearest may leave the sum off by up to two steps of the coarsest digit. */
+const ROUNDED_STEPS = 2;
+
+export const balanceRoleOf = (label: string, words: BalanceWords): BalanceRole | undefined =>
+  BALANCE_ROLES.find((role) => words.labels[role].some((pattern) => keyOf(pattern) === labelKey(label)));
+
+/** The one amount of a role in a scope; undefined when the role is missing or written more than once. */
+const onlyAmount = (amounts: readonly BalanceAmount[], role: BalanceRole): BalanceAmount | undefined => {
+  const mine = amounts.filter((amount) => amount.role === role);
+  return mine.length === 1 ? mine[0] : undefined;
+};
+
+const allowedGap = (amounts: readonly BalanceAmount[], words: BalanceWords): number => {
+  const finest = Math.max(...amounts.map((amount) => amount.decimals));
+  const coarsest = Math.min(...amounts.map((amount) => amount.decimals));
+  const exact = amounts.every((amount) => isExact(amount, words));
+  return HALF * DECIMAL_BASE ** -finest + (exact ? 0 : ROUNDED_STEPS * DECIMAL_BASE ** -coarsest);
+};
+
+/**
+ * One scope: opening, inflow, outflow and closing each found once, all in one unit. The closing balance is reported when it
+ * is not opening + inflow − outflow beyond rounding. A sum below zero is not compared: an overdrawn balance is written with
+ * a sign, which is not read as an amount.
+ */
+export const closingMismatch = (amounts: readonly BalanceAmount[], words: BalanceWords): NetIssue | undefined => {
+  const found = BALANCE_ROLES.map((role) => onlyAmount(amounts, role));
+  const [opening, inflow, outflow, closing] = found;
+  if (opening === undefined || inflow === undefined || outflow === undefined || closing === undefined) return undefined;
+  const four = [opening, inflow, outflow, closing];
+  if (four.some((amount) => amount.unit !== closing.unit)) return undefined;
+  const decimals = Math.max(...four.map((amount) => amount.decimals));
+  const expected = Math.round((opening.value + inflow.value - outflow.value) * DECIMAL_BASE ** decimals) / DECIMAL_BASE ** decimals;
+  if (!Number.isSafeInteger(Math.round(expected * DECIMAL_BASE ** decimals))) return undefined;
+  if (expected < 0 || Math.abs(expected - closing.value) <= allowedGap(four, words)) return undefined;
+  return { offset: closing.start, values: { written: closing.written, expected: shown(expected, closing, decimals) } };
+};
+
+const labelledCells = (labels: readonly NetCell[], values: readonly NetCell[], words: BalanceWords): BalanceAmount[] =>
+  labels.flatMap((label, column) => {
+    const role = balanceRoleOf(label.text, words);
+    const value = values[column];
+    const amount = role === undefined || value === undefined ? undefined : amountOf(value.text, value.start, noteOf(label.text), words);
+    return role === undefined || amount === undefined ? [] : [{ ...amount, role }];
+  });
+
+const issuesOf = (scopes: readonly (readonly BalanceAmount[])[], words: BalanceWords): NetIssue[] =>
+  scopes.flatMap((amounts) => {
+    const issue = closingMismatch(amounts, words);
+    return issue === undefined ? [] : [issue];
+  });
+
+/** A table whose header names the four columns (one month a row): each body row of the same width is one scope. */
+const byColumns = (header: readonly NetCell[], rows: readonly (readonly NetCell[])[], words: BalanceWords): NetIssue[] =>
+  issuesOf(
+    rows.filter((row) => row.length === header.length).map((row) => labelledCells(header, row, words)),
+    words,
+  );
+
+/** A table whose rows are labelled in their first cell: each column after the labels is one scope. */
+const byRows = (rows: readonly (readonly NetCell[])[], words: BalanceWords): NetIssue[] => {
+  const labelled = rows.filter((row) => row[0] !== undefined && balanceRoleOf(row[0].text, words) !== undefined);
+  const width = labelled[0]?.length ?? 0;
+  if (labelled.length === 0 || labelled.some((row) => row.length !== width)) return [];
+  const columns = Array.from({ length: width - 1 }, (_, index) => index + 1);
+  return issuesOf(
+    columns.map((column) => labelled.flatMap((row) => labelledCells(row.slice(0, 1), row.slice(column, column + 1), words))),
+    words,
+  );
+};
+
+/**
+ * One table, read both ways. A table of transactions with a running balance (日付, お預入れ, お引出し, 残高) names none of the
+ * four totals in its header or its first column, so it gives no scope; running-balance-mismatch reads it row by row.
+ */
+export const tableClosingMismatches = (header: readonly NetCell[], rows: readonly (readonly NetCell[])[], words: BalanceWords): NetIssue[] => {
+  const issues = [...byColumns(header, rows, words), ...byRows(rows, words)];
+  return issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
+};
+
+/** The labelled lines of one section (前月末残高：412,350円). */
+export const sectionClosingMismatch = (lines: readonly LabelledLine[], words: BalanceWords): NetIssue | undefined =>
+  closingMismatch(
+    lines.flatMap((line) => labelledCells([{ start: 0, text: line.label }], [line.value], words)),
+    words,
+  );

package/src/structure/column-date-order.ts

@@ -0,0 +1,73 @@
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import type { PairedIssue, OrderDate } from "./labelled-date-order.ts";
+import { labelPairsOf, type LabelPair, type OrderLabel } from "./labelled-order.ts";
+import { linesOf, type Line } from "./lines.ts";
+
+/**
+ * Two dates of one table row that must come in order: a table whose header names an earlier-date column and a
+ * later-date column of one pair (| ご利用日 | 獲得ポイント | 有効期限 |, | Date | Points | Expires |). Each row is compared
+ * with itself only: a column is never paired with another table's. A header naming either side twice is not read, nor is
+ * a cell without exactly one full date, nor a row with a passed word (期限切れ, expired). A group with context words is
+ * read only when another header column contains one: a Date and Expiration date of a claims log are not a points table. Pure.
+ */
+
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
+
+const keyOf = (text: string): string => withoutEdgeMarks(text).normalize("NFKC").toLowerCase().replace(/\s+/gu, " ");
+
+type Column = { readonly index: number; readonly label: string };
+
+/** The one header column that is one of the words, and the word; undefined when none or more than one is. */
+const columnNamed = (header: readonly Cell[], words: readonly string[]): Column | undefined => {
+  const named = header.flatMap((cell, index) => {
+    const label = words.find((word) => keyOf(word) === keyOf(cell.text));
+    return label === undefined ? [] : [{ index, label }];
+  });
+  return named.length === 1 ? named[0] : undefined;
+};
+
+const oneDateIn = (cell: Cell | undefined, dates: readonly OrderDate[]): OrderDate | undefined => {
+  if (cell === undefined) return undefined;
+  const within = dates.filter((date) => date.offset >= cell.start && (date.end ?? date.offset) <= cell.end && FULL_DATE.test(date.value));
+  return within.length === 1 ? within[0] : undefined;
+};
+
+type Table = { readonly header: Line; readonly rows: readonly Line[] };
+
+/** A group's words without a position name what the table is about: another header column must contain one (獲得ポイント). */
+type GroupPair = LabelPair & { readonly context: readonly string[] };
+
+const groupPairsOf = (labels: readonly OrderLabel[]): GroupPair[] =>
+  [...new Set(labels.flatMap((label) => (label.group === undefined ? [] : [label.group])))].flatMap((group) => {
+    const ofGroup = labels.filter((label) => label.group === group);
+    const context = ofGroup.flatMap((label) => (label.position === undefined ? [keyOf(label.pattern)] : []));
+    return labelPairsOf(ofGroup).map((pair) => ({ ...pair, context }));
+  });
+
+const aboutContext = (header: readonly Cell[], context: readonly string[]): boolean =>
+  context.length === 0 || header.some((cell) => context.some((word) => keyOf(cell.text).includes(word)));
+
+const rowOutOfOrder = (row: Line, earlier: Column, later: Column, dates: readonly OrderDate[]): PairedIssue[] => {
+  const cells = cellsOf(row);
+  const from = oneDateIn(cells[earlier.index], dates);
+  const to = oneDateIn(cells[later.index], dates);
+  if (from === undefined || to === undefined || to.value >= from.value) return [];
+  const values = { later: to.value, earlier: from.value, later_label: later.label, earlier_label: earlier.label };
+  return [{ offset: Math.max(from.offset, to.offset), values, period: false }];
+};
+
+const rowsOutOfOrder = (table: Table, pair: GroupPair, dates: readonly OrderDate[], passed: readonly string[]): PairedIssue[] => {
+  const header = cellsOf(table.header);
+  const earlier = columnNamed(header, pair.earlier);
+  const later = columnNamed(header, pair.later);
+  if (earlier === undefined || later === undefined || !aboutContext(header, pair.context)) return [];
+  const reported = (row: Line): boolean => passed.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
+  return table.rows.flatMap((row) => (reported(row) ? [] : rowOutOfOrder(row, earlier, later, dates)));
+};
+
+/** Every row of a table whose later-column date is before its earlier-column date, for each pair the lexicon names. */
+export const columnDatesOutOfOrder = (source: string, dates: readonly OrderDate[], labels: readonly OrderLabel[], passed: readonly string[]): PairedIssue[] => {
+  const tables = tablesOf(linesOf(source));
+  return groupPairsOf(labels).flatMap((pair) => tables.flatMap((table) => rowsOutOfOrder(table, pair, dates, passed)));
+};

package/src/structure/compound-hours.ts

@@ -0,0 +1,49 @@
+import type { Amount } from "./total.ts";
+import type { TimeLength } from "../derived/time-lengths.ts";
+
+/**
+ * 時間と分を続けて書いた長さ（9時間30分、7 hours 30 minutes、7時間半）を、一つの時間の量（9.5時間）として足す。
+ * 木は 9時間 と 30分 を別の量に読むので、そのままでは 30分 が落ちた和を合計と比べてしまう。Pure.
+ */
+
+const MINUTES_PER_HOUR = 60;
+const HUNDREDTHS = 100;
+
+/** 足さない長さの単位に付ける印。どの量とも同じ単位にならないので、その長さがある列の和は取らない。 */
+const UNSUMMABLE = "?";
+
+/** 時間の百分の一で割り切れる長さか（15分、30分、45分）。20分は割り切れず、丸めの差が書き誤りに見える。 */
+const exactInHundredths = (minutes: number): boolean => Number.isInteger((minutes * HUNDREDTHS) / MINUTES_PER_HOUR);
+
+const unsummable = (length: TimeLength, unit: string): Amount => ({
+  offset: length.start,
+  end: length.end,
+  value: length.minutes / MINUTES_PER_HOUR,
+  unit: `${unit}${UNSUMMABLE}${String(length.start)}`,
+});
+
+/**
+ * 長さ一つを足す量に直す。時間の量の後ろに分か半を続けた長さは時間の量に、分が 60 以上か百分の一で割り切れなければ足さない量に、
+ * 木が量と読まなかった長さ（8 h）も足さない量にする。時間だけの長さ（8時間、木が数だけを量と読む 8 hours も）と、分から始まる長さ（90分）は、木の量のまま（undefined）。
+ */
+const compoundOf = (length: TimeLength, amounts: readonly Amount[], hourUnits: ReadonlySet<string>): Amount | undefined => {
+  const first = amounts.find((amount) => amount.offset === length.start);
+  if (first === undefined) return unsummable(length, "");
+  if (!hourUnits.has(first.unit)) return undefined;
+  const extraMinutes = length.minutes - first.value * MINUTES_PER_HOUR;
+  if (extraMinutes === 0) return undefined;
+  const readable = extraMinutes > 0 && extraMinutes < MINUTES_PER_HOUR && exactInHundredths(length.minutes);
+  if (!readable) return unsummable(length, first.unit);
+  return { offset: length.start, end: length.end, value: length.minutes / MINUTES_PER_HOUR, unit: first.unit };
+};
+
+/** amounts の中の、時間と分を続けて書いた長さを、一つの量に置き換える。hourUnits は時間の単位（時間、hours）。 */
+export const withCompoundHours = (amounts: readonly Amount[], lengths: readonly TimeLength[], hourUnits: readonly string[]): Amount[] => {
+  const units = new Set(hourUnits);
+  const compounds = lengths.flatMap((length) => {
+    const compound = compoundOf(length, amounts, units);
+    return compound === undefined ? [] : [compound];
+  });
+  const covered = (amount: Amount): boolean => compounds.some((compound) => amount.offset >= compound.offset && amount.offset < compound.end);
+  return [...amounts.filter((amount) => !covered(amount)), ...compounds].toSorted((left, right) => left.offset - right.offset);
+};

package/src/structure/counted-amounts.ts

@@ -7,10 +7,10 @@ import type { Amount } from "./total.ts";
 export type SummedCounter = { readonly pattern: string; readonly unit: string };
 
 /** 前に英字や数や小数点が続く数（v2、A4、1.2.3 の 2）は読まない。日本語は数の前に空白を置かないので、仮名や漢字の後ろはよい。 */
-const NUMBER = /(?<![\p{Script=Latin}\p{N}.,．，])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
+export const NUMBER = /(?<![\p{Script=Latin}\p{N}.,．，])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
 
 /** 助数詞に文字や数、つなぎの - _ が詰めて続くもの（3単位目、4コマ漫画、3 unit-priced）は、別の語の一部。 */
-const CONTINUES_WORD = /^[\p{L}\p{N}_-]/u;
+export const CONTINUES_WORD = /^[\p{L}\p{N}_-]/u;
 
 /** 序数の印（第3回）。 */
 const ORDINAL_MARK = "第";
@@ -18,7 +18,7 @@ const ORDINAL_MARK = "第";
 /** 助数詞を探す長さ。どの助数詞よりも長い。 */
 const LOOKAHEAD = 32;
 
-const valueOf = (written: string): number => Number(written.normalize("NFKC").replace(/,/gu, ""));
+export const valueOf = (written: string): number => Number(written.normalize("NFKC").replace(/,/gu, ""));
 
 /** 数のすぐ後ろ（空白一つまで）の助数詞。長い語から試す。大文字小文字は区別しない（4 Credits）。 */
 const counterAfter = (source: string, end: number, counters: readonly SummedCounter[]): { unit: string; end: number } | undefined => {
@@ -28,7 +28,8 @@ const counterAfter = (source: string, end: number, counters: readonly SummedCoun
   return counter === undefined ? undefined : { unit: counter.unit, end: end + gap + counter.pattern.length };
 };
 
-const overlapsAny = (start: number, end: number, amounts: readonly Amount[]): boolean => amounts.some((amount) => start < amount.end && amount.offset < end);
+export const overlapsAny = (start: number, end: number, amounts: readonly Amount[]): boolean =>
+  amounts.some((amount) => start < amount.end && amount.offset < end);
 
 /** 文書の中の、足してよい助数詞の付いた数。木がすでに数量として読んだもの（known）とは重ねない。 */
 export const countedAmounts = (source: string, counters: readonly SummedCounter[], known: readonly Amount[]): Amount[] => {

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

@@ -1,15 +1,19 @@
 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 };
 type Span = { readonly start: number; readonly end: number };
@@ -20,6 +24,10 @@ export type OutsideWords = PeriodWords & {
   readonly terms: readonly string[];
   readonly deadlines: readonly string[];
   readonly overviews: readonly string[];
+  /** 期間の後に来てよい仕事の語（成績発表、再試験）。この語のある締め切りは期間と比べない。 */
+  readonly afterTerm: readonly string[];
+  /** 日付を締め切りにする語（までに、by）。地の文でこの語の付いた日付は期間の中の予定ではないので、期間と比べない。 */
+  readonly deadlineMarks: readonly DeadlineMark[];
 };
 
 const LIST_ITEM = /^[ \t]{0,12}(?:[-*+]|\d{1,3}[.)])[ \t]/u;
@@ -79,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) => ({
@@ -111,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 => {
@@ -143,15 +154,17 @@ const isDocumentTerm = (period: Stated, context: Context, overviews: readonly st
   return enclosingHeadings(period.line.start, context.headings).some((heading) => mentions(context.source.slice(heading.start, heading.end), overviews));
 };
 
-const afterEnd = (value: string, period: Period): boolean => hasYear(value) && hasYear(period.end) && value > period.end;
-
 const lateDeadline = (date: DateMention, period: Stated, context: Context, words: OutsideWords): boolean => {
-  if (!DAY_VALUE.test(date.value) || !afterEnd(date.value, period)) return false;
+  if (!DAY_VALUE.test(date.value)) return false;
   const line = containing(context.lines, date.offset);
   if (line === undefined) return false;
   const texts = surroundings(date, line, isItem(context.source.slice(line.start, line.end), line, context.headings), context);
-  if (!mentions(texts[0] ?? "", words.deadlines)) return false;
-  return !texts.some((text) => mentions(withoutWords(text, words.deadlines), words.asides));
+  const marks = {
+    deadline: mentions(texts[0] ?? "", words.deadlines),
+    aside: texts.some((text) => mentions(withoutWords(text, words.deadlines), words.asides)),
+    afterTerm: mentions(texts[0] ?? "", words.afterTerm),
+  };
+  return deadlineVerdict(date.value, period, marks) === "late";
 };
 
 const issueOf = (source: string, date: DateMention, period: Stated): StructureIssue => ({
@@ -161,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;
 
@@ -140,7 +137,7 @@ const bareFramed = (source: string, start: DatedSpan, end: DatedSpan, written: s
   return (isLabelled(start.offset) || withWeekdays) && !isChange(source, start, end, words);
 };
 
-const isRange = (source: string, start: DatedSpan, end: DatedSpan, words: RangeWords, isLabelled: (offset: number) => boolean): boolean => {
+export const isRange = (source: string, start: DatedSpan, end: DatedSpan, words: RangeWords, isLabelled: (offset: number) => boolean): boolean => {
   const written = jointOf(source, start, end);
   if (written === undefined) return false;
   const joint = withoutTrailingWeekday(written, words.weekdays ?? []);
@@ -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) } }];
   });