chaffjs 0.28.0 → 0.29.0

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

@@ -0,0 +1,127 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+import { TABLE_ROW } from "./runs.ts";
+import { statedPeriod, type DateMention, type Period, type PeriodWords } from "./stated-period.ts";
+
+/**
+ * 書いた期間の外の日付。期間の語で始まる一行（旅行期間：…）が期間を書き、その後ろ、同じ節の中の箇条書きの項目、表の行、見出しの日付を比べる。
+ * 地の文の日付は、年の無いもの（2月12日（金）の午前は…）だけを比べる。年のある日付は、過去の回や別の年の出来事を挙げることが多い。
+ * 期間の前後に置く予定（前泊、follow-up）、締め切りや予約の日、過去の回を言う語（period-aside）が、その行、文、節の見出しにあれば比べない。
+ * 年の無い期間（12月28日〜1月4日）は年をまたいで読む。
+ */
+export type HeadingSpan = { readonly start: number; readonly end: number; readonly depth: number };
+type Span = { readonly start: number; readonly end: number };
+
+export type OutsideWords = PeriodWords & { readonly asides: readonly string[] };
+
+const LIST_ITEM = /^[ \t]{0,12}(?:[-*+]|\d{1,3}[.)])[ \t]/u;
+const DAY_VALUE = /^(?:\d{4}-)?\d{2}-\d{2}$/u;
+
+const hasYear = (value: string): boolean => value.length === "2026-01-01".length;
+const monthDay = (value: string): string => value.slice(-"01-01".length);
+
+/** 期間の中か。両方に年があれば年月日で、どちらかに年が無ければ月日で比べ、終わりが始まりより前の月日は年をまたぐ期間と読む。 */
+export const insidePeriod = (value: string, period: Pick<Period, "start" | "end">): boolean => {
+  if (hasYear(value) && hasYear(period.start)) return value >= period.start && value <= period.end;
+  const [from, to, day] = [monthDay(period.start), monthDay(period.end), monthDay(value)];
+  return from <= to ? day >= from && day <= to : day >= from || day <= to;
+};
+
+const linesOf = (source: string): Span[] =>
+  source.split("\n").reduce<Span[]>((lines, text) => {
+    const start = (lines.at(-1)?.end ?? -1) + 1;
+    return [...lines, { start, end: start + text.length }];
+  }, []);
+
+const containing = <Item extends Span>(spans: readonly Item[], offset: number): Item | undefined =>
+  spans.find((span) => span.start <= offset && offset <= span.end);
+
+/** 英字の語は語の切れ目で、ほかは含むかで照らす。 */
+export const mentions = (text: string, words: readonly string[]): boolean => {
+  const lower = text.toLowerCase();
+  return words.some((word) => {
+    const target = word.toLowerCase();
+    if (!/[a-z]/u.test(target)) return lower.includes(target);
+    return new RegExp(`(?<![a-z])${escapeRegExp(target)}(?![a-z])`, "u").test(lower);
+  });
+};
+
+type Stated = Period & { readonly scopeStart: number; readonly scopeEnd: number };
+
+/**
+ * 期間の及ぶ範囲の始まり: 期間の行の後ろ。期間の行が箇条書きの項目なら、その箇条書きの後ろ。
+ * 「- Conference: May 3–5」「- Workshop: May 7」は催しを並べた一覧で、並んだ項目は期間の中の予定ではない。
+ */
+const scopeStart = (source: string, lines: readonly Span[], line: Span): number => {
+  const isListLine = (span: Span): boolean => LIST_ITEM.test(source.slice(span.start, span.end));
+  if (!isListLine(line)) return line.end;
+  const after = lines.filter((span) => span.start > line.start);
+  const listEnd = after.findIndex((span) => !isListLine(span));
+  return (listEnd === -1 ? (after.at(-1) ?? line) : (after[listEnd - 1] ?? line)).end;
+};
+
+/** 期間の行が属する節の深さ。行が見出しならその深さ、そうでなければ前の見出しの深さ（見出しの前なら 0）。 */
+const depthAt = (line: Span, headings: readonly HeadingSpan[]): number =>
+  (containing(headings, line.start) ?? headings.filter((heading) => heading.start < line.start).at(-1))?.depth ?? 0;
+
+/** 期間の及ぶ範囲の終わり: 同じか浅い深さの次の見出しか、次の期間の行。 */
+const scopeEnd = (line: Span, next: number, headings: readonly HeadingSpan[], length: number): number => {
+  const depth = depthAt(line, headings);
+  const closing = headings.find((heading) => heading.start > line.end && heading.depth <= depth)?.start ?? length;
+  return Math.min(closing, next);
+};
+
+const statedPeriods = (
+  source: string,
+  lines: readonly Span[],
+  dates: readonly DateMention[],
+  headings: readonly HeadingSpan[],
+  words: OutsideWords,
+): Stated[] => {
+  const found = lines.flatMap((line) => {
+    const period = statedPeriod(source.slice(line.start, line.end), line.start, dates, words);
+    return period === undefined ? [] : [{ period, line }];
+  });
+  return found.map(({ period, line }, index) => ({
+    ...period,
+    scopeStart: scopeStart(source, lines, line),
+    scopeEnd: scopeEnd(line, found[index + 1]?.line.start ?? source.length, headings, source.length),
+  }));
+};
+
+const isItem = (text: string, line: Span, headings: readonly HeadingSpan[]): boolean =>
+  LIST_ITEM.test(text) || TABLE_ROW.test(text) || containing(headings, line.start) !== undefined;
+
+type Context = { readonly source: string; readonly lines: readonly Span[]; readonly headings: readonly HeadingSpan[]; readonly sentences: readonly Span[] };
+
+/** 日付を囲む行（項目）か文（地の文）と、その節の見出し。期間の外に置く語を探す所。 */
+const surroundings = (date: DateMention, line: Span, item: boolean, context: Context): string[] => {
+  const unit = item ? line : (containing(context.sentences, date.offset) ?? line);
+  const heading = context.headings.filter((candidate) => candidate.start <= date.offset).at(-1);
+  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 => {
+  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));
+};
+
+export const datesOutsidePeriod = (
+  source: string,
+  dates: readonly DateMention[],
+  headings: readonly HeadingSpan[],
+  sentences: readonly Span[],
+  words: OutsideWords,
+): StructureIssue[] => {
+  const lines = linesOf(source);
+  const context: Context = { source, lines, headings, sentences };
+  return statedPeriods(source, lines, dates, headings, words).flatMap((period) =>
+    dates
+      .filter((date) => date.offset > period.scopeStart && date.offset < period.scopeEnd && outsideOne(date, period, context, words.asides))
+      .map((date) => ({ offset: date.offset, values: { date: source.slice(date.offset, date.end), period: period.written } })),
+  );
+};

package/src/structure/definition-use.ts

@@ -135,6 +135,19 @@ const LABEL_SLACK = 3;
 const isLabel = (body: BodyText | undefined, term: string): boolean =>
   body !== undefined && (body.text.replaceAll(term, "").match(LETTER) ?? []).length <= LABEL_SLACK;
 
+/** 文書の位置が、題・見出し・条の見出しの行にあるか。見出しは節の中身に名前を付けるだけで、語を使った所ではない。 */
+export type IsTitle = (offset: number) => boolean;
+
+const NEVER_TITLE: IsTitle = () => false;
+
+const HAN = /\p{Script=Han}/u;
+
+/** 漢字で終わる語の後ろに漢字が続く現れは、もっと長い語の一部（監査委員会の監査委員、保険金請求権の保険金請求）。 */
+const continuesInHan = (texts: readonly BodyText[], term: string, offset: number): boolean => {
+  const body = sentenceAt(texts, offset);
+  return body !== undefined && HAN.test(term.at(-1) ?? "") && HAN.test(body.text.charAt(offset - body.start + term.length));
+};
+
 const CAPITAL_OR_NON_LATIN = /\p{Lu}|[^\p{Script=Latin}\p{N}\s\p{P}]/u;
 
 /**
@@ -145,18 +158,26 @@ const isDistinctive = (term: string): boolean => CAPITAL_OR_NON_LATIN.test(term)
 
 /**
  * 文の途中で括弧に入れて定義した語（(the "Seller")、以下「甲」という）を、その定義の文より前で使っている所。最初の一つだけ。
- * 定義の文の中の現れ（株式会社GovTech東京（以下「GovTech東京」という。））は、定義する名前そのものなので数えない。札の文も数えない。
+ * 定義の文の中の現れ（株式会社GovTech東京（以下「GovTech東京」という。））は、定義する名前そのものなので数えない。札の文も、
+ * isTitle が言う題・見出しの行も、漢字で終わる語にさらに漢字が続く長い語の一部も数えない。
  * 定義の条（"Seller" means、「甲」とは）は条の並びの頭にも終わりにも置く書き方があるので、前で使っても言わない。
  * 定義の語の無い括弧の引用（("The key point is")）は例の引用と同じ形なので、その語を引用符で挙げただけの現れ
  * （Its sentences open with "The key point is"）は使用ではない。定義の語のある定義（(the "Seller")、以下「買主」という）は、
  * 引用符に入れた現れ（The "Seller" ships）も使用。
  */
-export const usesBeforeDefinition = (terms: readonly DefinedTerm[], texts: readonly BodyText[], mentioned: Mentioned = NEVER_MENTIONED): TermUse[] =>
+export const usesBeforeDefinition = (
+  terms: readonly DefinedTerm[],
+  texts: readonly BodyText[],
+  mentioned: Mentioned = NEVER_MENTIONED,
+  isTitle: IsTitle = NEVER_TITLE,
+): TermUse[] =>
   groupsOf(terms)
     .filter((group) => group.first.inline && isDistinctive(group.first.term))
     .flatMap(({ first: defined, spans }) => {
       const defining = sentenceAt(texts, defined.span.start)?.start ?? defined.span.start;
       const uses = usesOf(defined.term, texts, spans, "exact", defined.bare === true ? mentioned : NEVER_MENTIONED);
-      const first = uses.find((offset) => !isLabel(sentenceAt(texts, offset), defined.term));
+      const first = uses.find(
+        (offset) => !isLabel(sentenceAt(texts, offset), defined.term) && !isTitle(offset) && !continuesInHan(texts, defined.term, offset),
+      );
       return first !== undefined && first < defining ? [{ term: defined, offset: first }] : [];
     });

package/src/structure/due-date.ts

@@ -0,0 +1,46 @@
+import type { StructureIssue } from "./issues.ts";
+import { linesOf } from "./lines.ts";
+import { isTotalLabel } from "./total.ts";
+
+/**
+ * A due date before the issue date. A line (or a list item, or a table's first column) starting with an issue-date word
+ * (発行日, Issued) and one starting with a due-date word (お支払期限, Payment due), each with a full date on it: a due date
+ * earlier than the first issue date, and written near it (the header block of an invoice or a quote), is reported. A due
+ * line that says its deadline has passed (期限切れ, overdue) reports on a deadline rather than setting one. Pure.
+ */
+export type DueWords = { readonly issue: readonly string[]; readonly due: readonly string[]; readonly passed: readonly string[] };
+
+/** How many lines from the issue date a due date may be and still be read as the same document's deadline. */
+const MAX_LINE_GAP = 8;
+
+/** A date of the structure tree: where it starts and its value (2026-11-25). */
+export type DatedPoint = { readonly offset: number; readonly value: string };
+
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
+
+type Labelled = { readonly kind: "issue" | "due"; readonly date: DatedPoint; readonly line: number };
+
+const kindOf = (text: string, words: DueWords): Labelled["kind"] | undefined => {
+  if (isTotalLabel(text, words.issue)) return "issue";
+  return isTotalLabel(text, words.due) ? "due" : undefined;
+};
+
+const labelledDates = (source: string, dates: readonly DatedPoint[], words: DueWords): Labelled[] =>
+  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 dueBeforeIssue = (source: string, dates: readonly DatedPoint[], words: DueWords): StructureIssue[] => {
+  if (words.issue.length === 0 || words.due.length === 0) return [];
+  const labelled = labelledDates(source, dates, words);
+  const issued = labelled.find((entry) => entry.kind === "issue");
+  if (issued === undefined) return [];
+  return labelled
+    .filter((entry) => entry.kind === "due" && entry.date.value < issued.date.value && Math.abs(entry.line - issued.line) < MAX_LINE_GAP)
+    .map((entry) => ({ offset: entry.date.offset, values: { due: entry.date.value, issued: issued.date.value } }));
+};

package/src/structure/heading-runs.ts

@@ -0,0 +1,24 @@
+/**
+ * Headings at one depth under one parent heading, as a changelog's version or dated headings stand. A shallower heading
+ * closes the runs deeper than it; a deeper heading (### Added) ends none. A heading pointOf turns down still closes the
+ * deeper runs but joins no run and opens none, so "## Install" between two version headings does not split them.
+ */
+export const siblingHeadingRunsOf = <Heading extends { readonly depth: number }, Point>(
+  headings: readonly Heading[],
+  pointOf: (heading: Heading) => Point | undefined,
+): Point[][] => {
+  const runs: Point[][] = [];
+  const open = new Map<number, Point[]>();
+  headings.forEach((heading) => {
+    [...open.keys()].filter((depth) => depth > heading.depth).forEach((depth) => open.delete(depth));
+    const point = pointOf(heading);
+    if (point === undefined) return;
+    const run = open.get(heading.depth) ?? [];
+    if (!open.has(heading.depth)) {
+      open.set(heading.depth, run);
+      runs.push(run);
+    }
+    run.push(point);
+  });
+  return runs;
+};

package/src/structure/install-pin.ts

@@ -0,0 +1,115 @@
+// An install command that pins the document's own package (npm install wrapkit@3.1.0) to a version other than the one its
+// release list says is current. Pure: reads the source, the releases the document lists, and the install command shapes.
+import { escapeRegExp } from "../orthography.ts";
+
+/** One release the document lists: a version heading with its section, or a list item that starts with a version. */
+export type Release = { readonly version: string; readonly start: number; readonly end: number };
+
+/** A package pinned to one exact version by an install command. */
+export type Pin = { readonly offset: number; readonly name: string; readonly version: string };
+
+/** Where the document names itself: its title, and the paragraph that opens it. */
+export type OwnText = { readonly title: string; readonly opening: string };
+
+export type PinIssue = {
+  readonly offset: number;
+  readonly variant: "newest" | "section";
+  readonly values: { readonly pinned: string; readonly release: string };
+};
+
+const NAME = "(@?[A-Za-z0-9][\\w.\\/-]*)";
+/**
+ * Exactly one version: not a range (^3.0.0, >=3.0.0), not a prerelease or build (3.0.0-beta.1), not a tag (latest). A
+ * sentence's period may follow (install wrapkit@3.1.0.), a fourth part may not (3.1.0.1).
+ */
+const EXACT_VERSION = "(\\d{1,4}\\.\\d{1,4}\\.\\d{1,4})(?![\\w+-]|\\.\\w)";
+/** The rest of a command: on its line, up to a ; && | or a closing backtick. */
+const COMMAND_REST = "[^\\n;&|`]*";
+
+/** A lexicon shape ("npm install {name}@{version}") as the command and the pin it takes. */
+export type InstallShape = { readonly command: RegExp; readonly pin: RegExp };
+
+/** A shape read from the lexicon; undefined when it does not name a command, then both parts in that order. */
+export const installShape = (shape: string): InstallShape | undefined => {
+  const [command = "", rest = ""] = shape.split("{name}");
+  const [separator, tail] = rest.split("{version}");
+  if (command.trim() === "" || separator === undefined || tail === undefined) return undefined;
+  const words = command.trim().split(/\s+/u).map(escapeRegExp).join("[ \\t]+");
+  const pin = escapeRegExp(separator).replaceAll(" ", "[ \\t]+");
+  return {
+    command: new RegExp(`(?<![\\w.-])${words}(?=[ \\t])${COMMAND_REST}`, "gu"),
+    pin: new RegExp(`(?<=[ \\t])${NAME}${pin}${EXACT_VERSION}`, "gu"),
+  };
+};
+
+const pinsAfter = (command: RegExpExecArray, shape: InstallShape): Pin[] =>
+  [...command[0].matchAll(shape.pin)].flatMap((match) => {
+    const [whole, name, version] = match;
+    if (name === undefined || version === undefined) return [];
+    return [{ offset: command.index + match.index + whole.length - version.length, name, version }];
+  });
+
+/** Each pin an install command makes, read with the lexicon's command shapes. Flags and other packages may come first. */
+export const pinsIn = (source: string, shapes: readonly string[]): Pin[] =>
+  shapes
+    .flatMap((text) => {
+      const shape = installShape(text);
+      return shape === undefined ? [] : [...source.matchAll(shape.command)].flatMap((command) => pinsAfter(command, shape));
+    })
+    .filter((pin, index, pins) => pins.findIndex((other) => other.offset === pin.offset) === index);
+
+/** The whole name, scope included: a page about react does not own @types/react. */
+const names = (text: string, name: string): boolean => new RegExp(`(?<![\\w@/.-])${escapeRegExp(name)}(?![\\w/-])`, "iu").test(text);
+
+/**
+ * The pins of the document's own package: those its title names, or, when the title names none (a changelog titled
+ * "Changelog"), those its opening paragraph names. Another package pinned in the same document is a dependency.
+ */
+const ownPins = (pins: readonly Pin[], own: OwnText): Pin[] => {
+  const titled = pins.filter((pin) => names(own.title, pin.name));
+  return titled.length > 0 ? titled : pins.filter((pin) => names(own.opening, pin.name));
+};
+
+const PARAGRAPH_BREAK = /\n[ \t]*\n/u;
+
+/** The document's title, its first top-level heading, and the paragraph that opens the text after it. */
+export const ownTextOf = (source: string, headings: readonly { readonly depth: number; readonly text: string; readonly end: number }[]): OwnText => {
+  const title = headings.find((heading) => heading.depth === 1);
+  const rest = source.slice(title?.end ?? 0).trimStart();
+  const opening = rest.startsWith("#") ? "" : (rest.split(PARAGRAPH_BREAK)[0] ?? "");
+  return { title: title?.text ?? "", opening };
+};
+
+const partsOf = (version: string): number[] => version.split(".").map(Number);
+
+const isNewer = (left: string, right: string): boolean => {
+  const [a, b] = [partsOf(left), partsOf(right)];
+  const differing = a.findIndex((part, index) => part !== b[index]);
+  return differing !== -1 && (a[differing] ?? 0) > (b[differing] ?? 0);
+};
+
+/** The newest release by version order; a prerelease (4.0.0-beta.1) is not the one a reader is told to install. */
+const newestOf = (releases: readonly Release[]): string | undefined =>
+  releases
+    .map((release) => release.version)
+    .filter((version) => !version.includes("-"))
+    .reduce<string | undefined>((newest, version) => (newest === undefined || isNewer(version, newest) ? version : newest), undefined);
+
+/** The release whose section holds a position, innermost first: a pin under "## 3.2.0" belongs to 3.2.0. */
+const sectionAt = (releases: readonly Release[], offset: number): Release | undefined =>
+  releases.filter((release) => release.start <= offset && offset < release.end).at(-1);
+
+/**
+ * Each pin of the document's own package that differs from its release: the release whose section it is in, or else the
+ * newest the document lists. A document that lists no release says nothing to compare.
+ */
+export const installPinMismatches = (pins: readonly Pin[], releases: readonly Release[], own: OwnText): PinIssue[] => {
+  const newest = newestOf(releases);
+  if (newest === undefined) return [];
+  return ownPins(pins, own).flatMap((pin) => {
+    const section = sectionAt(releases, pin.offset);
+    const release = section?.version ?? newest;
+    if (release === pin.version) return [];
+    return [{ offset: pin.offset, variant: section === undefined ? "newest" : "section", values: { pinned: pin.version, release } }];
+  });
+};

package/src/structure/leg-times.ts

@@ -0,0 +1,198 @@
+import type { StructureIssue } from "./issues.ts";
+import { TABLE_RULE } from "./runs.ts";
+import {
+  crossesZones,
+  dayShiftOf,
+  markBefore,
+  markRightAfter,
+  wordOffsets,
+  zonesIn,
+  SECONDS_PER_DAY,
+  type DateSpan,
+  type Mark,
+  type TimeSpan,
+  type TimeWords,
+} from "./time-marks.ts";
+
+/**
+ * 一つの行（箇条書きの項目、表の行、文の一行）に書いた発と着の時刻。着が発より前なら、どちらかの書き間違い。
+ * 発・着は、時刻のすぐ後ろの印（「08:00発」）か、時刻の少し前の印（「departs Boston 7:30 AM」「dep 10:30」）、
+ * または表の列の見出し（出発、到着、Departs、Arrives。語彙表 leg-column）で読む。
+ * 着に翌日の印（翌、+1、next day）があれば一日足す。発と着の両方に日付があれば日付で比べ、片方だけなら比べない。
+ * 違う時間帯の印が二つある行と、「現地時間」のようにどこの時刻かを言わない印のある行は、時刻をそのまま比べられないので言わない。
+ */
+
+/** 発か着の時刻。date はその時刻の前に書いた日付、shift は翌日（1）か前日（-1）の印、zone は時刻の後ろに書いた時間帯（無ければ空）。 */
+type LegTime = {
+  readonly offset: number;
+  readonly end: number;
+  readonly written: string;
+  readonly seconds: number;
+  readonly shift: number;
+  readonly date: string | undefined;
+  readonly zone: string;
+};
+
+type Leg = LegTime & { readonly side: string };
+
+const DEPARTURE = "departure";
+const ARRIVAL = "arrival";
+
+/** 「departs Washington Reagan 1:30 PM」のように、発着の語と時刻の間に挟んでよい字の数（地名）。 */
+const LEG_WORD_GAP = 32;
+/** 発着の語と時刻の間に来れば、その語は時刻にかからない（文や句の切れ目）。 */
+const BREAK = /[。．;；!?！？]|\.\s/u;
+
+type Inputs = { readonly source: string; readonly times: readonly TimeSpan[]; readonly dates: readonly DateSpan[]; readonly words: TimeWords };
+
+const timesWithin = (times: readonly TimeSpan[], start: number, end: number): TimeSpan[] => times.filter((time) => time.start >= start && time.end <= end);
+
+/** 時刻の日付と読む、時刻の前に書いた日付までの字の数（「Feb 8, 1:00 PM」「2月8日 13:00」）。 */
+const DATE_WINDOW = 4;
+
+/** 時刻の後ろで、その時刻の時間帯の印（17:00 JST）を探す字の数。 */
+const ZONE_WINDOW = 12;
+
+/** 時刻を、from から to までの原文（前の時刻の後ろから次の時刻の前まで、表なら升）の中で読む。 */
+const legTimeOf = (time: TimeSpan, from: number, to: number, inputs: Inputs): LegTime => {
+  const head = inputs.source.slice(from, time.start);
+  const date = inputs.dates.filter((span) => span.start >= from && span.end <= time.start && time.start - span.end <= DATE_WINDOW).at(-1)?.value;
+  const shift = dayShiftOf(head, inputs.source, time.end, inputs.words);
+  const zone = zonesIn(inputs.source.slice(time.end, Math.min(to, time.end + ZONE_WINDOW)), inputs.words)[0]?.text ?? "";
+  return { offset: time.start, end: time.end, written: inputs.source.slice(time.start, time.end), seconds: time.seconds, shift, date, zone };
+};
+
+/** 時刻の前の語（departs、dep）。間に句の切れ目があれば、その語はこの時刻のものではない。 */
+const sideBefore = (head: string, legs: readonly Mark[]): string | undefined => {
+  const mark = markBefore(head, legs, LEG_WORD_GAP);
+  if (mark === undefined) return undefined;
+  const at = Math.max(...wordOffsets(head, mark.pattern));
+  return BREAK.test(head.slice(at + mark.pattern.length)) ? undefined : mark.group;
+};
+
+/** 一行の中の発着の時刻を、書いた順に。前の時刻から後ろだけを、その時刻の前置きとして読む。 */
+const legsInLine = (start: number, end: number, inputs: Inputs): Leg[] =>
+  timesWithin(inputs.times, start, end).flatMap((time, index, all) => {
+    const from = all[index - 1]?.end ?? start;
+    const to = all[index + 1]?.start ?? end;
+    const side = markRightAfter(inputs.source, time.end, inputs.words.legs)?.group ?? sideBefore(inputs.source.slice(from, time.start), inputs.words.legs);
+    return side === DEPARTURE || side === ARRIVAL ? [{ ...legTimeOf(time, from, to, inputs), side }] : [];
+  });
+
+/** 発のあとに来た最初の着を、その発の組にする。間に文の切れ目があれば、着は別の文のもので組にしない。 */
+const pairsOf = (source: string, legs: readonly Leg[]): [LegTime, LegTime][] =>
+  legs.reduce<{ pending: LegTime | undefined; pairs: [LegTime, LegTime][] }>(
+    (found, leg) => {
+      if (leg.side === DEPARTURE) return { ...found, pending: leg };
+      if (found.pending === undefined || BREAK.test(source.slice(found.pending.end, leg.offset))) return { ...found, pending: undefined };
+      return { pending: undefined, pairs: [...found.pairs, [found.pending, leg]] };
+    },
+    { pending: undefined, pairs: [] },
+  ).pairs;
+
+/** 年月日、年月、月日は、同じ書き方どうしでしか比べない。 */
+const sameShape = (left: string, right: string): boolean => left.length === right.length;
+
+/**
+ * 着が発より前か。両方に日付があれば日付で、日付が同じなら時刻で比べる。片方だけに日付があれば、もう片方の日が分からない。
+ * 時間帯の印が発と着で違えば（片方だけに書いたときも）、時刻をそのまま比べられない。
+ */
+export const arrivesFirst = (departure: LegTime, arrival: LegTime): boolean => {
+  if ((departure.date === undefined) !== (arrival.date === undefined) || departure.zone !== arrival.zone) return false;
+  if (departure.date !== undefined && arrival.date !== undefined) {
+    if (!sameShape(departure.date, arrival.date)) return false;
+    if (departure.date !== arrival.date) return arrival.date < departure.date;
+  }
+  return arrival.shift * SECONDS_PER_DAY + arrival.seconds < departure.shift * SECONDS_PER_DAY + departure.seconds;
+};
+
+const issueOf = ([departure, arrival]: [LegTime, LegTime]): StructureIssue => ({
+  offset: arrival.offset,
+  values: { arrival: arrival.written, departure: departure.written },
+});
+
+const linesOf = (source: string): { start: number; end: number }[] =>
+  source.split("\n").reduce<{ start: number; end: number }[]>((lines, text) => {
+    const start = (lines.at(-1)?.end ?? -1) + 1;
+    return [...lines, { start, end: start + text.length }];
+  }, []);
+
+/** 行の中で発と着の印から読む組。 */
+const inlinePairs = (inputs: Inputs, zonesOf: (start: number, end: number) => boolean): [LegTime, LegTime][] =>
+  linesOf(inputs.source).flatMap((line) => (zonesOf(line.start, line.end) ? [] : pairsOf(inputs.source, legsInLine(line.start, line.end, inputs))));
+
+type Cell = { readonly start: number; readonly end: number };
+
+/** 表の一行を、| で区切った升に分ける。先頭と末尾の | の外は升ではない。 */
+export const cellsOf = (source: string, start: number, end: number): Cell[] => {
+  const text = source.slice(start, end);
+  const bars = [...text.matchAll(/(?<!\\)\|/gu)].map((match) => start + match.index);
+  const edges = [text.trimStart().startsWith("|") ? undefined : start - 1, ...bars, text.trimEnd().endsWith("|") ? undefined : end].filter(
+    (edge) => edge !== undefined,
+  );
+  return edges.slice(1).map((edge, index) => ({ start: (edges[index] ?? start) + 1, end: edge }));
+};
+
+/** 見出しの升の後ろの括弧書き（「出発（現地時間）」「Departs (JST)」）。列の名前はその前まで。 */
+const NOTE_OPENER = /[(（[［]/u;
+
+const columnName = (heading: string): string => {
+  const note = heading.search(NOTE_OPENER);
+  return (note === -1 ? heading : heading.slice(0, note)).trim();
+};
+
+/** 見出しの升の名前が、発着の列の名前（語彙表 leg-column）と同じ最初の列。 */
+const columnOf = (source: string, header: readonly Cell[], columns: readonly Mark[], side: string): number =>
+  header.findIndex((cell) => {
+    const name = columnName(source.slice(cell.start, cell.end));
+    return columns.some((mark) => mark.group === side && mark.pattern === name);
+  });
+
+/** 升の中の最初の時刻を、発か着として読む。 */
+const cellTime = (cell: Cell | undefined, inputs: Inputs): LegTime | undefined => {
+  if (cell === undefined) return undefined;
+  const time = timesWithin(inputs.times, cell.start, cell.end)[0];
+  return time === undefined ? undefined : legTimeOf(time, cell.start, cell.end, inputs);
+};
+
+type Table = { readonly header: Cell[]; readonly rows: { start: number; end: number }[] };
+
+/** 見出しの行、区切りの行、| のある行が続くあいだを一つの表にする。 */
+const tablesOf = (source: string): Table[] => {
+  const lines = linesOf(source);
+  return lines.flatMap((line, index) => {
+    const header = lines[index - 1];
+    if (header === undefined || !TABLE_RULE.test(source.slice(line.start, line.end))) return [];
+    const after = lines.slice(index + 1);
+    const stop = after.findIndex((row) => !source.slice(row.start, row.end).includes("|"));
+    return [{ header: cellsOf(source, header.start, header.end), rows: stop === -1 ? after : after.slice(0, stop) }];
+  });
+};
+
+/** 発の列と着の列を見出しから読む表の組。見出しに時間帯の印があれば、行と合わせて時間帯を見る。 */
+const columnPairs = (inputs: Inputs, zonesOf: (start: number, end: number) => boolean): [LegTime, LegTime][] =>
+  tablesOf(inputs.source).flatMap((table) => {
+    const departs = columnOf(inputs.source, table.header, inputs.words.columns, DEPARTURE);
+    const arrives = columnOf(inputs.source, table.header, inputs.words.columns, ARRIVAL);
+    const headerLine = { start: table.header[0]?.start ?? 0, end: table.header.at(-1)?.end ?? 0 };
+    if (departs === -1 || arrives === -1) return [];
+    return table.rows.flatMap((row): [LegTime, LegTime][] => {
+      const cells = cellsOf(inputs.source, row.start, row.end);
+      const departure = cellTime(cells[departs], inputs);
+      const arrival = cellTime(cells[arrives], inputs);
+      const zoned = zonesOf(row.start, row.end) || zonesOf(headerLine.start, headerLine.end);
+      return departure === undefined || arrival === undefined || zoned ? [] : [[departure, arrival]];
+    });
+  });
+
+/** 着が発より前の組。同じ着を表の列と行の中の印の両方から読んでも、一度だけ言う。 */
+export const arrivalsBeforeDeparture = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords): StructureIssue[] => {
+  const inputs = { source, times, dates, words };
+  const zonesOf = (start: number, end: number): boolean => crossesZones(zonesIn(source.slice(start, end), words));
+  const issues = [...inlinePairs(inputs, zonesOf), ...columnPairs(inputs, zonesOf)]
+    .filter(([departure, arrival]) => arrivesFirst(departure, arrival))
+    .map(issueOf);
+  return issues
+    .filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index)
+    .toSorted((left, right) => left.offset - right.offset);
+};

package/src/structure/line-amount-unit.ts

@@ -0,0 +1,35 @@
+/**
+ * 明細の一行で、数量と単価が同じ単位を数えているか。単価が何かあたり（$100/hour、月額、Rate の列）なら、数量はその単位で
+ * 書かれているか単位の無い数でなければ、掛けても金額にならない。語はすべて語彙表から来る。Pure.
+ */
+export type UnitWord = { readonly pattern: string; readonly unit: string };
+
+/** The marks of a price cell with its per-unit mark taken off, and the unit it named. */
+export type PerUnitPrice = { readonly before: string; readonly after: string; readonly unit: string };
+
+const longestFirst = (words: readonly UnitWord[]): UnitWord[] => words.toSorted((left, right) => right.pattern.length - left.pattern.length);
+
+const lower = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+/** "$" "/hour" → "$" "" hour; "月額" "円" → "" "円" month. Undefined when neither mark says a unit. */
+export const perUnitPrice = (before: string, after: string, marks: readonly UnitWord[]): PerUnitPrice | undefined => {
+  const sorted = longestFirst(marks);
+  const ending = sorted.find((mark) => lower(after).endsWith(lower(mark.pattern)));
+  if (ending !== undefined) return { before, after: after.slice(0, after.length - ending.pattern.length).trim(), unit: ending.unit };
+  const opening = sorted.find((mark) => lower(before).startsWith(lower(mark.pattern)));
+  return opening === undefined ? undefined : { before: before.slice(opening.pattern.length).trim(), after, unit: opening.unit };
+};
+
+/** The unit of a quantity's word ("days" → day), "" when the cell has no word after its number, undefined when the word is not a unit. */
+export const quantityUnit = (word: string, units: readonly UnitWord[]): string | undefined => {
+  const wanted = lower(word).trim().replace(/\.$/u, "");
+  if (wanted === "") return "";
+  return units.find((unit) => lower(unit.pattern) === wanted)?.unit;
+};
+
+/**
+ * Whether quantity × price is meaningful. A price that is per no unit is per whatever the quantity counts. A price per a
+ * unit goes with a bare number (a count of that unit) or a quantity in that unit, and with nothing else.
+ */
+export const unitsAgree = (quantity: string | undefined, pricePer: string | undefined): boolean =>
+  pricePer === undefined || quantity === "" || quantity === pricePer;