chaffjs 0.31.0 → 0.32.0

package/src/structure/interest.ts

@@ -0,0 +1,133 @@
+// interest-mismatch: an interest calculation written on one line (「お利息の計算：対象残高400,000円 × 利率0.10% ＝ 400円」,
+// "Interest for the month: average balance $3,600.00 × rate 0.05% = $1.80") whose amount is not the balance times the
+// rate. The rate is read as written: one marked for a period (年利, APR) is used only when the line names the same period
+// for the interest, and is never converted by a day count. A line marked after tax is not read. Pure.
+import type { Line } from "./lines.ts";
+import type { StructureIssue } from "./issues.ts";
+import { plain, valueIn } from "./change-rate-table.ts";
+import { shownLike, type Money } from "./share-amount.ts";
+import { roundedMatches } from "./tax.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+/** interest: the interest itself. base: the balance it is on. rate: the rate. net: interest after tax, not compared. */
+export type InterestRole = "interest" | "base" | "rate" | "net";
+export type InterestPeriod = "year" | "month";
+export type InterestWord = { readonly pattern: string; readonly role: InterestRole };
+/** A word that says what period a rate is for (年利, APR), or what period the interest is for (年間, for the month). */
+export type PeriodWord = { readonly pattern: string; readonly period: InterestPeriod; readonly of: "rate" | "interest" };
+export type InterestWords = { readonly labels: readonly InterestWord[]; readonly periods: readonly PeriodWord[] };
+
+const TIMES = /[×✕]/gu;
+const EQUALS = /[=＝]/gu;
+const PERCENT = /(?<![\d.])(\d+(?:\.\d+)?)[ \t]?%/gu;
+const TRAILING_STOP = /[.。]\s*$/u;
+const NUMBER = /\d[\d,]*(?:\.(\d+))?/u;
+const FIRST_FIGURE = /[\d$€£¥￥]/u;
+/** A bracketed note as written, in either width: blanked to spaces so the figure after it keeps its place. */
+const WRITTEN_BRACKETED = /[(（][^()（）]*[)）]/gu;
+const LATIN = /[a-z]/u;
+const MAX_RATE = 100;
+const CENTS = 100;
+
+type Rate = { readonly value: number; readonly written: string };
+type Calculation = { readonly before: string; readonly rate: string; readonly amount: string; readonly amountAt: number };
+
+const keyOf = (text: string): string => plain(text).toLowerCase();
+
+/** Where each whole occurrence of a word ends in a key: a Latin word stands as a whole word, anything else as written. */
+const endsOf = (key: string, pattern: string): number[] => {
+  const word = keyOf(pattern);
+  if (word === "") return [];
+  const source = LATIN.test(word) ? `(?<![a-z0-9])${escapeRegExp(word)}(?![a-z0-9])` : escapeRegExp(word);
+  return [...key.matchAll(new RegExp(source, "gu"))].map((match) => match.index + word.length);
+};
+
+const patternsOf = (words: InterestWords, role: InterestRole): string[] => words.labels.flatMap((word) => (word.role === role ? [word.pattern] : []));
+
+const holdsAny = (key: string, patterns: readonly string[]): boolean => patterns.some((pattern) => endsOf(key, pattern).length > 0);
+
+/** Where the last of the words ends in the key, -1 when none is there. */
+const lastEnd = (key: string, patterns: readonly string[]): number => Math.max(-1, ...patterns.flatMap((pattern) => endsOf(key, pattern)));
+
+// The text that may name the interest and its period: before × and after =, not the rate between.
+const interestKeyOf = (calculation: Calculation): string => `${keyOf(calculation.before)} ${keyOf(calculation.amount)}`;
+
+/** The line cut at its one × and its one =: what is before ×, between them (empty when = comes first), and after =. */
+const calculationOf = (text: string): Calculation | undefined => {
+  const times = [...text.matchAll(TIMES)];
+  const equals = [...text.matchAll(EQUALS)];
+  const [timesMatch, equalsMatch] = [times[0], equals[0]];
+  if (times.length !== 1 || equals.length !== 1 || timesMatch === undefined || equalsMatch === undefined) return undefined;
+  const amount = text.slice(equalsMatch.index + 1);
+  const figure = amount.replace(WRITTEN_BRACKETED, (note) => " ".repeat(note.length)).search(FIRST_FIGURE);
+  return {
+    before: text.slice(0, timesMatch.index),
+    rate: text.slice(timesMatch.index + 1, equalsMatch.index),
+    amount,
+    amountAt: equalsMatch.index + 1 + Math.max(figure, 0),
+  };
+};
+
+/** The one percentage written between × and =, with a rate word: 利率0.10%, rate 0.05%. */
+const rateIn = (segment: string, words: InterestWords): Rate | undefined => {
+  const key = keyOf(segment);
+  const rates = [...key.matchAll(PERCENT)];
+  const [only] = rates;
+  if (rates.length !== 1 || only === undefined || !holdsAny(key, patternsOf(words, "rate"))) return undefined;
+  const value = Number(only[1]);
+  return value > 0 && value < MAX_RATE ? { value, written: only[0] } : undefined;
+};
+
+const moneyIn = (text: string): Money | undefined => {
+  const value = valueIn(text);
+  if (value === undefined) return undefined;
+  const decimals = NUMBER.exec(text)?.[1]?.length ?? 0;
+  return { value: value.value, decimals, marks: value.marks, offset: 0, text: plain(text) };
+};
+
+/** The balance: what follows the last balance word before ×: 「対象残高1,200,000円」, "average balance $12,400.00". */
+const baseIn = (segment: string, words: InterestWords): Money | undefined => {
+  const text = plain(segment);
+  const end = lastEnd(text.toLowerCase(), patternsOf(words, "base"));
+  return end < 0 ? undefined : moneyIn(text.slice(end));
+};
+
+/** The amount after =, less a bracketed note, a closing stop and an interest word before it (＝ お利息400円). */
+const amountIn = (segment: string, words: InterestWords): Money | undefined => {
+  const text = plain(segment).replace(WRITTEN_BRACKETED, "").replace(TRAILING_STOP, "");
+  return moneyIn(text.slice(Math.max(0, lastEnd(text.toLowerCase(), patternsOf(words, "interest")))));
+};
+
+/** The one period the words of this kind name in the key; undefined when none or two. */
+const periodIn = (key: string, words: InterestWords, of: PeriodWord["of"]): InterestPeriod | undefined => {
+  const periods = new Set(words.periods.filter((word) => word.of === of && endsOf(key, word.pattern).length > 0).map((word) => word.period));
+  return periods.size === 1 ? [...periods][0] : undefined;
+};
+
+/** A rate marked for a period (年利, APR) is the interest's only when the line names that period for the interest. */
+const ratePeriodFits = (calculation: Calculation, words: InterestWords): boolean => {
+  const rateKey = keyOf(calculation.rate);
+  const ratePeriods = words.periods.filter((word) => word.of === "rate" && endsOf(rateKey, word.pattern).length > 0);
+  if (ratePeriods.length === 0) return true;
+  const ratePeriod = periodIn(rateKey, words, "rate");
+  return ratePeriod !== undefined && ratePeriod === periodIn(interestKeyOf(calculation), words, "interest");
+};
+
+/** The line is an interest calculation: an interest word before × or after =, and no word of interest after tax. */
+const isGrossInterest = (line: Line, calculation: Calculation, words: InterestWords): boolean => {
+  return holdsAny(interestKeyOf(calculation), patternsOf(words, "interest")) && !holdsAny(keyOf(line.text), patternsOf(words, "net"));
+};
+
+const lineIssues = (line: Line, words: InterestWords): StructureIssue[] => {
+  const calculation = calculationOf(line.text);
+  if (calculation === undefined || !isGrossInterest(line, calculation, words) || !ratePeriodFits(calculation, words)) return [];
+  const [base, rate, amount] = [baseIn(calculation.before, words), rateIn(calculation.rate, words), amountIn(calculation.amount, words)];
+  if (base === undefined || rate === undefined || amount === undefined || base.marks !== amount.marks) return [];
+  if (roundedMatches(Math.round(amount.value * CENTS), base.value * rate.value, amount.decimals === 0)) return [];
+  const expected = shownLike(amount, (base.value * rate.value) / MAX_RATE, undefined);
+  return [{ offset: line.start + calculation.amountAt, values: { written: amount.text, expected, rate: rate.written, base: base.text } }];
+};
+
+/** Each interest calculation line whose amount is not the balance times the rate, rounded down, to nearest or up. */
+export const interestMismatches = (lines: readonly Line[], words: InterestWords): StructureIssue[] =>
+  words.labels.length === 0 ? [] : lines.flatMap((line) => lineIssues(line, words));

package/src/structure/key-value-row.ts

@@ -0,0 +1,45 @@
+import { cellsOf } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { TABLE_ROW } from "./runs.ts";
+
+/**
+ * 項目と内容の二列の表で、項目の升に期間の語だけを書いた一行（| 対象期間 | 2026年4月1日〜9月30日 |）。その表で期間の語を項目に書いた行が
+ * それ一つのときだけ、内容の升を期間として読む。期間の語の項目が何行も並ぶ表（回ごとの | 期間 | … |）は期間の一覧で、文書の期間ではない。
+ * 項目の升が語を含むだけのもの（| Conference room | … |、| 第1期 | … |）は読まない。Pure.
+ */
+export type ValueCell = { readonly from: number; readonly to: number };
+
+const KEY_VALUE_CELLS = 2;
+const TRAILING_COLON = /[:：]$/u;
+
+const cellsOfRow = (row: string): { readonly start: number; readonly end: number; readonly text: string }[] => cellsOf({ text: row, start: 0, number: 0 });
+
+const isLabelCell = (text: string, labels: readonly string[]): boolean => {
+  const name = withoutEdgeMarks(withoutEdgeMarks(text).replace(TRAILING_COLON, "")).toLowerCase();
+  return labels.some((label) => label.toLowerCase() === name);
+};
+
+const isLabelRow = (row: string, labels: readonly string[]): boolean => {
+  const first = cellsOfRow(row)[0];
+  return TABLE_ROW.test(row) && first !== undefined && isLabelCell(first.text, labels);
+};
+
+/** 表の一行の、期間を書いた内容の升（行の中の位置）。tableOf はその行を含む表の全部の行を返す（項目が期間の語の行でだけ呼ぶ）。読まない行は undefined。 */
+export const keyValueCell = (row: string, tableOf: () => readonly string[], labels: readonly string[]): ValueCell | undefined => {
+  if (!TABLE_ROW.test(row)) return undefined;
+  const cells = cellsOfRow(row);
+  const [label, value] = cells;
+  if (cells.length !== KEY_VALUE_CELLS || label === undefined || value === undefined || !isLabelCell(label.text, labels)) return undefined;
+  return tableOf().filter((other) => isLabelRow(other, labels)).length === 1 ? { from: value.start, to: value.end } : undefined;
+};
+
+/** index の行を含む、続いた表の行（| で始まる行）。表の行でなければ空。 */
+export const tableAround = (rows: readonly string[], index: number): string[] => {
+  const isRow = (at: number): boolean => TABLE_ROW.test(rows[at] ?? "");
+  if (!isRow(index)) return [];
+  let first = index;
+  while (isRow(first - 1)) first -= 1;
+  let last = index;
+  while (isRow(last + 1)) last += 1;
+  return rows.slice(first, last + 1);
+};

package/src/structure/lab-columns.ts

@@ -0,0 +1,21 @@
+// The columns of a lab or checkup results table, named by their headings: the result, the reference range, the flag and
+// the unit. reference-flag-mismatch and reference-unit-mismatch both read a table through this; each brings its own way of
+// reducing a heading (which brackets it leaves out) and its own choice of which columns it needs. Pure.
+
+export type LabColumn = "result" | "range" | "flag" | "unit";
+
+export type LabColumnWord = { readonly pattern: string; readonly column: LabColumn };
+
+/** A heading reduced to what is compared with the words: case, width and a note in brackets left out. */
+type HeadingKey = (heading: string) => string;
+
+const LAB_COLUMNS: ReadonlySet<string> = new Set<LabColumn>(["result", "range", "flag", "unit"]);
+
+export const isLabColumn = (group: string | undefined): group is LabColumn => group !== undefined && LAB_COLUMNS.has(group);
+
+/** The column each heading names, by the first word whose key is the heading's key; undefined for a heading no word names. */
+export const labColumnsOf = (headings: readonly string[], words: readonly LabColumnWord[], keyOf: HeadingKey): (LabColumn | undefined)[] =>
+  headings.map((heading) => {
+    const key = keyOf(heading);
+    return words.find((word) => keyOf(word.pattern) === key)?.column;
+  });

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

@@ -1,84 +1,100 @@
 import type { DatedPoint } from "./due-date.ts";
 import type { StructureIssue } from "./issues.ts";
-import { linesOf } from "./lines.ts";
-import { isTotalLabel } from "./total.ts";
+import type { Line } from "./lines.ts";
+import { labelPairsOf, pointsOutOfOrder, type OrderLabel, type PairWords, type PointOf } from "./labelled-order.ts";
+import { TABLE_ROW } from "./runs.ts";
+import { statedPeriod, type DateMention, type PeriodWords } from "./stated-period.ts";
 
 /**
  * Two labelled dates that must come in order: a line (or a list item, or a table's first column) starting with an
  * earlier-date word and one starting with a later-date word, each with one full date on it. A later date before the
  * first earlier date, and written near it, is out of order. A line with a passed word (期限切れ, overdue) reports on a
- * date rather than setting one and is not read. Pure.
+ * date rather than setting one and is not read. A span word (対象期間, Reporting period) labels a period, and the
+ * period's end is its date. Pure.
  */
-export type DateOrderWords = {
-  readonly earlier: readonly string[];
-  readonly later: readonly string[];
-  readonly passed: readonly string[];
-  /** How many lines from the earlier date a later date may be and still be read as the same record's. */
-  readonly maxLineGap: number;
+export type DateOrderWords = PairWords & {
+  /** The words whose line states a period rather than one date (labels), with the range signs and names to read it. */
+  readonly spans?: PeriodWords | undefined;
 };
 
-/** A labelled date: the word that labels it, as the lexicon writes it. */
-export type LabelledDate = { readonly label: string; readonly date: DatedPoint; readonly line: number };
+/** A date from the tree; end is where its text ends, needed only to read a period. */
+export type OrderDate = DatedPoint & { readonly end?: number | undefined };
+
+/** A labelled date: the word that labels it, as the lexicon writes it. span is set when the date ends a stated period. */
+export type LabelledDate = { readonly label: string; readonly date: DatedPoint; readonly line: number; readonly span: boolean };
 
 export type OutOfOrder = { readonly earlier: LabelledDate; readonly later: LabelledDate };
 
 const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
 
-type Read = LabelledDate & { readonly kind: "earlier" | "later" };
-
-const labelOf = (text: string, words: readonly string[]): string | undefined => words.find((word) => isTotalLabel(text, [word]));
+const mentionsOf = (dates: readonly OrderDate[]): DateMention[] => dates.flatMap((date) => (date.end === undefined ? [] : [{ ...date, end: date.end }]));
 
-const kindOf = (text: string, words: DateOrderWords): Pick<Read, "kind" | "label"> | undefined => {
-  const earlier = labelOf(text, words.earlier);
-  if (earlier !== undefined) return { kind: "earlier", label: earlier };
-  const later = labelOf(text, words.later);
-  return later === undefined ? undefined : { kind: "later", label: later };
+/**
+ * The end of the period a span word's line states (対象期間：2026年4月1日〜9月30日 ends 2026-09-30), with its year.
+ * A period without a year, or a line that states no period, gives undefined. tableOf gives the table the line is a row of
+ * (| 対象期間 | 2026年4月1日〜9月30日 |), read when the row is the table's only row labelled with any span word: a table with
+ * both Reporting period and Period covered rows lists periods. A row's label cell is the span word itself, so all of them are passed.
+ */
+export const periodEndOf = (
+  line: Line,
+  label: string,
+  dates: readonly OrderDate[],
+  spans: PeriodWords,
+  tableOf: () => readonly string[] = () => [],
+): DatedPoint | undefined => {
+  const labels = TABLE_ROW.test(line.text) ? spans.labels : [label];
+  const period = statedPeriod(line.text, line.start, mentionsOf(dates), { ...spans, labels }, tableOf);
+  return period === undefined || !FULL_DATE.test(period.end) ? undefined : { offset: line.start, value: period.end };
 };
 
-const labelledDates = (source: string, dates: readonly DatedPoint[], words: DateOrderWords): Read[] =>
-  linesOf(source).flatMap((line) => {
-    const passed = words.passed.some((word) => line.text.toLowerCase().includes(word.toLowerCase()));
-    const kind = passed ? undefined : kindOf(line.text, words);
-    const end = line.start + line.text.length;
-    const onLine = dates.filter((date) => date.offset >= line.start && date.offset <= end && FULL_DATE.test(date.value));
-    const [date] = onLine;
-    return kind === undefined || date === undefined || onLine.length > 1 ? [] : [{ ...kind, date, line: line.number }];
-  });
-
-export const datesOutOfOrder = (source: string, dates: readonly DatedPoint[], words: DateOrderWords): OutOfOrder[] => {
-  if (words.earlier.length === 0 || words.later.length === 0) return [];
-  const labelled = labelledDates(source, dates, words);
-  const earlier = labelled.find((entry) => entry.kind === "earlier");
-  if (earlier === undefined) return [];
-  return labelled
-    .filter((entry) => entry.kind === "later" && entry.date.value < earlier.date.value && Math.abs(entry.line - earlier.line) < words.maxLineGap)
-    .map((later) => ({ earlier, later }));
+const oneDateOf = (line: Line, dates: readonly OrderDate[]): DatedPoint | undefined => {
+  const end = line.start + line.text.length;
+  const onLine = dates.filter((date) => date.offset >= line.start && date.offset <= end && FULL_DATE.test(date.value));
+  return onLine.length === 1 ? onLine[0] : undefined;
 };
 
-/** A lexicon entry naming its pair (group) and its side: before for the earlier date, after for the later one. */
-export type OrderLabel = { readonly pattern: string; readonly group?: string | undefined; readonly position?: "before" | "after" | undefined };
+const dateOf =
+  (dates: readonly OrderDate[], spans: PeriodWords | undefined): PointOf =>
+  (line, label, tableOf) => {
+    if (spans === undefined || !spans.labels.includes(label)) {
+      const date = oneDateOf(line, dates);
+      return date === undefined ? undefined : { point: date, span: false };
+    }
+    const end = periodEndOf(line, label, dates, spans, tableOf);
+    return end === undefined ? undefined : { point: end, span: true };
+  };
 
-const groupsOf = (labels: readonly OrderLabel[]): string[] => [...new Set(labels.flatMap((label) => (label.group === undefined ? [] : [label.group])))];
+/**
+ * A later date before the first earlier date. When both sides are written more than once (a history listing one record
+ * per row, newest first), the later date must also be before the earlier date written closest to it: that is its own
+ * record's. A later date written once (an issue date below the records) belongs to the whole document and keeps the first.
+ */
+export const datesOutOfOrder = (source: string, dates: readonly OrderDate[], words: DateOrderWords): OutOfOrder[] =>
+  pointsOutOfOrder(source, words, dateOf(dates, words.spans)).map(({ earlier, later }) => ({
+    earlier: { label: earlier.label, date: earlier.point, line: earlier.line, span: earlier.span },
+    later: { label: later.label, date: later.point, line: later.line, span: later.span },
+  }));
 
-const sideOf = (labels: readonly OrderLabel[], group: string, position: "before" | "after"): string[] =>
-  labels.filter((label) => label.group === group && label.position === position).map((label) => label.pattern);
+/** An out-of-order pair; period is set when the earlier date is the end of a stated period. */
+export type PairedIssue = StructureIssue & { readonly period: boolean };
 
 /**
  * Every pair of a dated-pair lexicon: the entries of one group with position before label the earlier date, those with
- * position after the later one. The values name both labels, so the message can quote them.
+ * position after the later one. The values name both labels, so the message can quote them. The issue is on whichever
+ * of the two dates is written second: a reader meets the contradiction there (a cancellation deadline below check-in).
  */
 export const pairedDatesOutOfOrder = (
   source: string,
-  dates: readonly DatedPoint[],
+  dates: readonly OrderDate[],
   labels: readonly OrderLabel[],
   passed: readonly string[],
   maxLineGap: number,
-): StructureIssue[] =>
-  groupsOf(labels).flatMap((group) =>
-    datesOutOfOrder(source, dates, { earlier: sideOf(labels, group, "before"), later: sideOf(labels, group, "after"), passed, maxLineGap }).map(
-      ({ earlier, later }) => ({
-        offset: later.date.offset,
-        values: { later: later.date.value, earlier: earlier.date.value, later_label: later.label, earlier_label: earlier.label },
-      }),
-    ),
+  spans?: PeriodWords,
+): PairedIssue[] =>
+  labelPairsOf(labels).flatMap((pair) =>
+    datesOutOfOrder(source, dates, { ...pair, passed, maxLineGap, spans }).map(({ earlier, later }) => ({
+      offset: Math.max(later.date.offset, earlier.date.offset),
+      values: { later: later.date.value, earlier: earlier.date.value, later_label: later.label, earlier_label: earlier.label },
+      period: earlier.span,
+    })),
   );

package/src/structure/labelled-order.ts

@@ -0,0 +1,122 @@
+import { linesOf, type Line } from "./lines.ts";
+import { tableAround } from "./key-value-row.ts";
+import { isTotalLabel } from "./total.ts";
+
+/**
+ * Two labelled points that must come in order: a line (or a list item, or a table's first column) starting with an
+ * earlier-side word and one starting with a later-side word, each giving one point. What a point is (a date, a time of
+ * day) is the caller's: pointOf reads it off the line, and its value sorts as text. Pure.
+ */
+
+/** A point in the text: where it is written, and a value that sorts as text (2026-04-01, a padded count of seconds). */
+export type OrderPoint = { readonly offset: number; readonly value: string };
+
+export type PairWords = {
+  readonly earlier: readonly string[];
+  readonly later: readonly string[];
+  /** A line with one of these words reports on a point rather than setting one (期限切れ, overdue) and is not read. */
+  readonly passed: readonly string[];
+  /** How many lines from the earlier point a later point may be and still be read as the same record's. */
+  readonly maxLineGap: number;
+};
+
+/** A labelled point: the word that labels it, as the lexicon writes it. span is set when the point ends a stated period. */
+export type LabelledPoint = { readonly label: string; readonly point: OrderPoint; readonly line: number; readonly span: boolean };
+
+export type PointPair = { readonly earlier: LabelledPoint; readonly later: LabelledPoint };
+
+/** The point a labelled line gives, or undefined when it gives none. tableOf gives the table the line is a row of. */
+export type PointOf = (line: Line, label: string, tableOf: () => readonly string[]) => Pick<LabelledPoint, "point" | "span"> | undefined;
+
+type Read = LabelledPoint & { readonly kind: "earlier" | "later" };
+
+const labelOf = (text: string, words: readonly string[]): string | undefined => words.find((word) => isTotalLabel(text, [word]));
+
+const kindOf = (text: string, words: PairWords): Pick<Read, "kind" | "label"> | undefined => {
+  const earlier = labelOf(text, words.earlier);
+  if (earlier !== undefined) return { kind: "earlier", label: earlier };
+  const later = labelOf(text, words.later);
+  return later === undefined ? undefined : { kind: "later", label: later };
+};
+
+const labelledPoints = (source: string, words: PairWords, pointOf: PointOf): Read[] => {
+  const lines = linesOf(source);
+  const texts = lines.map((line) => line.text);
+  return lines.flatMap((line, index) => {
+    const passed = words.passed.some((word) => line.text.toLowerCase().includes(word.toLowerCase()));
+    const kind = passed ? undefined : kindOf(line.text, words);
+    const read = kind === undefined ? undefined : pointOf(line, kind.label, () => tableAround(texts, index));
+    return kind === undefined || read === undefined ? [] : [{ ...kind, ...read, line: line.number }];
+  });
+};
+
+/** The earlier point written closest to a later one; of two as close, the one above. */
+const nearestEarlier = (earliers: readonly Read[], later: Read): Read | undefined =>
+  earliers.reduce<Read | undefined>((nearest, entry) => {
+    if (nearest === undefined) return entry;
+    const distance = Math.abs(entry.line - later.line);
+    const nearestDistance = Math.abs(nearest.line - later.line);
+    return distance < nearestDistance || (distance === nearestDistance && entry.line < nearest.line) ? entry : nearest;
+  }, undefined);
+
+/** How a later point finds the earlier point it is compared with, and which pairs the caller can compare at all. */
+export type PairReading = {
+  /**
+   * first: the first earlier point of the document, and, when the later side is written more than once, the nearest one
+   * too (an issue date heads the whole document). nearest: only the earlier point written closest (each show of a
+   * programme has its own doors and start).
+   */
+  readonly anchor?: "first" | "nearest" | undefined;
+  /** Drops a pair the caller cannot compare (two times of different days). */
+  readonly related?: ((pair: PointPair) => boolean) | undefined;
+};
+
+/** Each later point before the earlier point written closest to it. */
+const nearestOutOfOrder = (labelled: readonly Read[], earliers: readonly Read[], maxLineGap: number): PointPair[] =>
+  labelled.flatMap((later) => {
+    const earlier = later.kind === "later" ? nearestEarlier(earliers, later) : undefined;
+    return earlier !== undefined && later.point.value < earlier.point.value && Math.abs(later.line - earlier.line) < maxLineGap ? [{ earlier, later }] : [];
+  });
+
+/**
+ * A later point before the first earlier point. When both sides are written more than once (a history listing one record
+ * per row, newest first), the later point must also be before the earlier point written closest to it: that is its own
+ * record's. A later point written once (an issue date below the records) belongs to the whole document and keeps the first.
+ */
+const firstOutOfOrder = (labelled: readonly Read[], earliers: readonly Read[], maxLineGap: number): PointPair[] => {
+  const earlier = earliers[0];
+  if (earlier === undefined) return [];
+  const records = labelled.filter((entry) => entry.kind === "later").length > 1;
+  const beforeOwnRecord = (later: Read): boolean => !records || later.point.value < (nearestEarlier(earliers, later) ?? earlier).point.value;
+  return labelled
+    .filter(
+      (entry) =>
+        entry.kind === "later" && entry.point.value < earlier.point.value && Math.abs(entry.line - earlier.line) < maxLineGap && beforeOwnRecord(entry),
+    )
+    .map((later) => ({ earlier, later }));
+};
+
+/** The labelled pairs out of order, each with the earlier point it is compared with. */
+export const pointsOutOfOrder = (source: string, words: PairWords, pointOf: PointOf, reading: PairReading = {}): PointPair[] => {
+  if (words.earlier.length === 0 || words.later.length === 0) return [];
+  const labelled = labelledPoints(source, words, pointOf);
+  const earliers = labelled.filter((entry) => entry.kind === "earlier");
+  const pairs = reading.anchor === "nearest" ? nearestOutOfOrder(labelled, earliers, words.maxLineGap) : firstOutOfOrder(labelled, earliers, words.maxLineGap);
+  return reading.related === undefined ? pairs : pairs.filter(reading.related);
+};
+
+/** A lexicon entry naming its pair (group) and its side: before for the earlier point, after for the later one. */
+export type OrderLabel = { readonly pattern: string; readonly group?: string | undefined; readonly position?: "before" | "after" | undefined };
+
+/** One pair of a lexicon: the words of its group that label the earlier point, and those that label the later one. */
+export type LabelPair = { readonly earlier: string[]; readonly later: string[] };
+
+const sideOf = (labels: readonly OrderLabel[], group: string, position: "before" | "after"): string[] =>
+  labels.filter((label) => label.group === group && label.position === position).map((label) => label.pattern);
+
+/** Every pair a lexicon names, in the order its groups first appear. */
+export const labelPairsOf = (labels: readonly OrderLabel[]): LabelPair[] =>
+  [...new Set(labels.flatMap((label) => (label.group === undefined ? [] : [label.group])))].map((group) => ({
+    earlier: sideOf(labels, group, "before"),
+    later: sideOf(labels, group, "after"),
+  }));

package/src/structure/labelled-time-order.ts

@@ -0,0 +1,100 @@
+import type { StructureIssue } from "./issues.ts";
+import { labelPairsOf, pointsOutOfOrder, type OrderLabel, type PointOf, type PointPair } from "./labelled-order.ts";
+import { crossesZones, dayShiftOf, withoutDayShiftBefore, zonesIn, SECONDS_PER_DAY, type DateSpan, type TimeSpan, type TimeWords } from "./time-marks.ts";
+
+/**
+ * Two labelled times of one day that must come in order: doors open before the show starts (開場 before 開演), the group
+ * meets before it departs. A line (or a list item, or a table's first column) starting with an earlier-time word and one
+ * starting with a later-time word, each with one time on it; each later time is compared with the earlier time written
+ * closest to it, so a programme of two shows pairs each start with its own doors. Times of different days are not
+ * compared: the date in force on each line (the last date written before its end) must be the same, and a later time
+ * more than half a day back is past midnight (23:30 then 0:15). Two lines with different time-zone marks are not
+ * compared. A time marked as the next day (翌 1:00, +1) counts a day on; one marked as the day before is not read. Pure.
+ */
+
+/** How many lines from the earlier time a later time may be and still be read as the same event's. */
+const MAX_LINE_GAP = 10;
+/** A later time further back than this is read as past midnight, as time-order reads a day's schedule. */
+const HALF_DAY = SECONDS_PER_DAY / 2;
+/** Digits enough for a few days of seconds, so the values sort as text. */
+const PADDED = 8;
+
+const sortable = (seconds: number): string => String(seconds).padStart(PADDED, "0");
+
+type Inputs = { readonly source: string; readonly times: readonly TimeSpan[]; readonly dates: readonly DateSpan[]; readonly words: TimeWords };
+
+/**
+ * The line's one time, counted from the day's start: a next-day mark adds a day. A line with two times states a range.
+ * The point starts at a next-day mark written before the time (翌0:30), so the message quotes it.
+ */
+const timeOf =
+  ({ source, times, words }: Inputs): PointOf =>
+  (line) => {
+    const end = line.start + line.text.length;
+    const onLine = times.filter((time) => time.start >= line.start && time.end <= end);
+    const time = onLine.length === 1 ? onLine[0] : undefined;
+    if (time === undefined) return undefined;
+    const head = source.slice(line.start, time.start);
+    const shift = dayShiftOf(head, source, time.end, words);
+    const offset = line.start + withoutDayShiftBefore(head, words).length;
+    return shift < 0 ? undefined : { point: { offset, value: sortable(shift * SECONDS_PER_DAY + time.seconds) }, span: false };
+  };
+
+const lineEndAt = (source: string, offset: number): number => {
+  const end = source.indexOf("\n", offset);
+  return end === -1 ? source.length : end;
+};
+
+const lineTextAt = (source: string, offset: number): string => source.slice(source.lastIndexOf("\n", offset - 1) + 1, lineEndAt(source, offset));
+
+/** The date in force on a time's line: the last date written before the line ends, or "" before any date. */
+const dayOf = (source: string, dates: readonly DateSpan[], offset: number): string => {
+  const end = lineEndAt(source, offset);
+  return dates.findLast((date) => date.start < end)?.value ?? "";
+};
+
+/** The line's time-zone marks, or undefined when the line crosses zones (two zones, 現地時間). */
+const zoneOf = (text: string, words: TimeWords): string | undefined => {
+  const zones = zonesIn(text, words);
+  return crossesZones(zones) ? undefined : (zones[0]?.text ?? "");
+};
+
+/** Whether the two times can be compared: one date in force, one time zone, and the later time not more than half a day back. */
+const comparable =
+  ({ source, dates, words }: Inputs) =>
+  ({ earlier, later }: PointPair): boolean => {
+    const zone = zoneOf(lineTextAt(source, earlier.point.offset), words);
+    return (
+      dayOf(source, dates, earlier.point.offset) === dayOf(source, dates, later.point.offset) &&
+      zone !== undefined &&
+      zone === zoneOf(lineTextAt(source, later.point.offset), words) &&
+      Number(earlier.point.value) - Number(later.point.value) <= HALF_DAY
+    );
+  };
+
+/** The text of a point: from its start (a next-day mark, or the time) to the end of the time. */
+const writtenAt = (source: string, times: readonly TimeSpan[], offset: number): string => {
+  const time = times.find((candidate) => candidate.start >= offset);
+  return time === undefined ? "" : source.slice(offset, time.end);
+};
+
+/**
+ * Every pair of a timed-pair lexicon (group, position before and after, as dated-pair-label) whose later-labelled time is
+ * before its earlier-labelled one on the same day. The issue is on the earlier-labelled time (doors open at 18:45): the
+ * later one is the event's own time, the one a reader plans around and the one most often written again elsewhere.
+ */
+export const pairedTimesOutOfOrder = (inputs: Inputs, labels: readonly OrderLabel[]): StructureIssue[] =>
+  labelPairsOf(labels).flatMap((pair) =>
+    pointsOutOfOrder(inputs.source, { ...pair, passed: [], maxLineGap: MAX_LINE_GAP }, timeOf(inputs), {
+      anchor: "nearest",
+      related: comparable(inputs),
+    }).map(({ earlier, later }) => ({
+      offset: earlier.point.offset,
+      values: {
+        time: writtenAt(inputs.source, inputs.times, earlier.point.offset),
+        later: writtenAt(inputs.source, inputs.times, later.point.offset),
+        earlier_label: earlier.label,
+        later_label: later.label,
+      },
+    })),
+  );