chaffjs 0.28.0 → 0.29.0

package/src/structure/release-list.ts

@@ -0,0 +1,69 @@
+// The releases a document lists: a run of version headings (## 3.2.0 - 2026-09-14), each with its section, or a run of
+// list items that start with a version (- 3.2.0 (2026-09-14): ...). Pure: reads the source, its headings and code fences.
+import type { Span } from "../plugin.ts";
+import type { Release } from "./install-pin.ts";
+import { runsOf, type Line } from "./runs.ts";
+import { isVersionHistory, leadingVersion } from "./version-order.ts";
+
+export type Heading = Span & { readonly depth: number; readonly text: string };
+
+const BARE = /\d[\w.-]*/u;
+
+/** The version as compared: 3.2.0 from [v3.2.0]. */
+const bareVersion = (label: string): string => BARE.exec(label)?.[0] ?? label;
+
+type Labelled = Release & { readonly label: string };
+
+/** Kept only when its versions read as a history (all versions, newest or oldest first), not as section numbers. */
+const asHistory = (run: readonly Labelled[]): Release[] =>
+  isVersionHistory(run.map((release) => release.label)) ? run.map(({ version, start, end }) => ({ version, start, end })) : [];
+
+/** A heading's section: up to the next heading of its depth or shallower. */
+const sectionEnd = (headings: readonly Heading[], index: number, length: number): number => {
+  const depth = headings[index]?.depth ?? 0;
+  return headings.slice(index + 1).find((later) => later.depth <= depth)?.start ?? length;
+};
+
+/**
+ * Version headings one after another at one depth. A deeper heading (### Added) stays inside the run; any other heading
+ * at its depth or shallower (## Install) ends it, so versioned headings spread over a manual are no release list.
+ */
+const headingReleases = (headings: readonly Heading[], length: number): Release[] => {
+  const runs: Labelled[][] = [];
+  const open: { depth: number; run: Labelled[] } = { depth: 0, run: [] };
+  headings.forEach((heading, index) => {
+    const label = leadingVersion(heading.text);
+    const continues = label !== undefined && heading.depth === open.depth;
+    if (!continues && (label !== undefined || heading.depth <= open.depth)) {
+      open.run = [];
+      open.depth = label === undefined ? 0 : heading.depth;
+      runs.push(open.run);
+    }
+    if (label !== undefined) open.run.push({ label, version: bareVersion(label), start: heading.start, end: sectionEnd(headings, index, length) });
+  });
+  return runs.flatMap(asHistory);
+};
+
+const ITEM_MARKER = /^[ \t]*(?:[-*+]|\d{1,3}[.)])[ \t]*/u;
+
+const itemReleases = (source: string, run: readonly Line[]): Release[] =>
+  asHistory(
+    run.flatMap((line) => {
+      const text = source.slice(line.start, line.end);
+      const marker = ITEM_MARKER.exec(text)?.[0];
+      const label = marker === undefined ? undefined : leadingVersion(text.slice(marker.length));
+      return label === undefined ? [] : [{ label, version: bareVersion(label), start: line.start, end: line.end }];
+    }),
+  );
+
+/** Every release the document lists, outside code fences (an example changelog in a block is not the document's). */
+export const releasesOf = (source: string, headings: readonly Heading[], fences: readonly Span[]): Release[] => {
+  const inFence = (line: Line): boolean => fences.some((fence) => line.start >= fence.start && line.start < fence.end);
+  const items = runsOf(source).flatMap((run) =>
+    itemReleases(
+      source,
+      run.filter((line) => line.kind === "list" && !inFence(line)),
+    ),
+  );
+  return [...headingReleases(headings, source.length), ...items].toSorted((left, right) => left.start - right.start);
+};

package/src/structure/share-column.ts

@@ -0,0 +1,25 @@
+/**
+ * 表の列の見出しが、それだけで全体を分けた割合の列と名指すか（割合、配点、Weight）。これらの語は文の中では行ごとの率にも使うので、
+ * 見出しの升がその語だけ（単位の括弧と % は除く）のときに限る。
+ */
+
+/** 見出しの升から外す飾り: 括弧に入れた単位（(%)、（％）、[%]）、% の記号、強調の印。単位でない括弧（（達成率））は残す。 */
+const DECORATION = /[(（［[](?:\s|[%％]|percent|pct)*[)）］\]]|[%％*_]/giu;
+const LATIN = /^\p{ASCII}+$/u;
+const WORD_BREAK = /[^\p{L}\p{N}]+/u;
+
+const bareCell = (cell: string): string => cell.replace(DECORATION, "").trim().toLowerCase();
+
+export const isShareColumn = (cell: string, columnLabels: readonly string[]): boolean => {
+  const bare = bareCell(cell);
+  return bare.length > 0 && columnLabels.some((label) => label.toLowerCase() === bare);
+};
+
+/** 英字の語は語の切れ目で探す（rate を separate に当てない）。日本語の語は文字列の中で探す。 */
+const mentions = (text: string, word: string): boolean => {
+  const lowered = word.toLowerCase();
+  if (!LATIN.test(lowered)) return text.includes(word);
+  return ` ${text.toLowerCase().split(WORD_BREAK).join(" ")} `.includes(` ${lowered} `);
+};
+
+export const mentionsAny = (text: string, words: readonly string[]): boolean => words.some((word) => mentions(text, word));

package/src/structure/stated-period.ts

@@ -0,0 +1,161 @@
+import { escapeRegExp } from "../orthography.ts";
+import { withoutTrailingWeekday } from "./date-range.ts";
+
+/**
+ * 文書が書いた期間（旅行期間：10月12日〜10月15日、Trip period: Oct 12–15）。期間の語（period-label）で始まる一行だけを読む。
+ * 日付は年月日（2026-10-12）か月日（10-12）。片方にだけ年があれば、もう片方にも同じ年を補う。
+ * 言語の知識（期間の語、範囲の記号、月の名、曜日の名）は語彙表から受け取る。
+ */
+export type DateMention = { readonly offset: number; readonly end: number; readonly value: string };
+
+export type PeriodWords = {
+  readonly labels: readonly string[];
+  /** 二つの日付の間に置いて期間を作る記号と語（〜、–、から、to）。 */
+  readonly connectors: readonly string[];
+  /** 月の名。頭の 12 個が 1 月から 12 月、略した名はその頭の字で月を決める。 */
+  readonly months: readonly string[];
+  readonly weekdays: readonly string[];
+};
+
+export type Period = { readonly start: string; readonly end: string; readonly written: string };
+
+/**
+ * 行の頭の印（見出し、箇条書き、引用）と、語を囲む太字や括弧の開き。表の行は読まない。
+ * 「| Conference | May 3–5 |」は催しを並べた表の一行で、文書の期間ではない。
+ */
+const LINE_MARKS = /^[ \t]*(?:(?:#{1,6}|[-*+>]|\d{1,3}[.)])[ \t]*)*/u;
+const LABEL_OPEN = /^(?:\*\*|__|【|\[)?/u;
+const LABEL_END = /^(?:\*\*|__|】|\])?(?:[ \t]*[:：][ \t]*|[ \t\u3000]+)/u;
+
+const leadOf = (line: string): number => {
+  const marks = LINE_MARKS.exec(line)?.[0].length ?? 0;
+  return marks + (LABEL_OPEN.exec(line.slice(marks))?.[0].length ?? 0);
+};
+
+/** 期間の語に続く、期間を書いた部分の行の中の位置。期間の語で始まらない行は undefined。 */
+export const afterLabel = (line: string, labels: readonly string[]): number | undefined => {
+  const lead = leadOf(line);
+  const rest = line.slice(lead);
+  const label = labels.find((word) => rest.toLowerCase().startsWith(word.toLowerCase()) && LABEL_END.test(rest.slice(word.length)));
+  if (label === undefined) return undefined;
+  return lead + label.length + (LABEL_END.exec(rest.slice(label.length))?.[0].length ?? 0);
+};
+
+/** 日付に添えた曜日（（水））と時刻（10:00）。期間のつなぎ目ではない。 */
+const ASIDES = /[（(][^（()）\n]{1,6}[）)]|\d{1,2}[:：]\d{2}/gu;
+
+const isJoint = (between: string, words: PeriodWords): boolean => {
+  const bare = between
+    .replace(ASIDES, "")
+    .replace(/^[\s,]+/u, "")
+    .trim()
+    .toLowerCase();
+  const joint = withoutTrailingWeekday(bare, words.weekdays).trim();
+  return words.connectors.some((connector) => connector.toLowerCase() === joint);
+};
+
+const connectorPattern = (words: PeriodWords): string =>
+  words.connectors
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+const hasYear = (value: string): boolean => /^\d{4}-/u.test(value);
+const DAY_VALUE = /^(?:\d{4}-)?\d{2}-\d{2}$/u;
+
+const withDay = (value: string, day: string): string => `${value.slice(0, -2)}${day.padStart(2, "0")}`;
+
+const shiftYear = (value: string, by: number): string => `${String(Number(value.slice(0, 4)) + by)}${value.slice(4)}`;
+
+/** 年を片方にだけ書いた期間に、もう片方の年を補う（December 28 – January 4, 2027 は 2026 年の 12 月から）。 */
+const withYears = (start: string, end: string): string[] => {
+  if (hasYear(start) === hasYear(end)) return [start, end];
+  if (hasYear(start)) {
+    const filled = `${start.slice(0, 4)}-${end}`;
+    return [start, filled < start ? shiftYear(filled, 1) : filled];
+  }
+  const filled = `${end.slice(0, 4)}-${start}`;
+  return [filled > end ? shiftYear(filled, -1) : filled, end];
+};
+
+type Dates = Omit<Period, "written">;
+
+const periodOf = (start: string, end: string): Dates | undefined => {
+  if (!DAY_VALUE.test(start) || !DAY_VALUE.test(end)) return undefined;
+  const [from = start, to = end] = withYears(start, end);
+  return hasYear(from) && to < from ? undefined : { start: from, end: to };
+};
+
+/** 時刻の範囲の終わり（May 3, 3–5pm）。日の範囲ではない。 */
+const CLOCK = "\\s*[AaPp]\\.?[Mm]\\b";
+
+/** 一つ書いた日付の後ろに日だけを書いた終わり（10月12日〜15日、Oct 12–15）。 */
+const dayAfter = (text: string, date: DateMention, lineStart: number, words: PeriodWords): Dates | undefined => {
+  const tail = text.slice(date.end - lineStart).replace(ASIDES, "");
+  const found = new RegExp(`^\\s*(?:${connectorPattern(words)})\\s*(\\d{1,2})(?:st|nd|rd|th|日)?(?![\\d/:月.]|\\s*\\p{Lu}|${CLOCK})`, "u").exec(tail);
+  const day = found?.[1];
+  return day === undefined ? undefined : periodOf(date.value, withDay(date.value, day));
+};
+
+/** 一つ書いた日付の前に日だけを書いた始まり（3–5 May 2026）。前に月の名がある日（May 3–June 5）は、終わりの月の日ではない。 */
+const dayBefore = (text: string, date: DateMention, lineStart: number, words: PeriodWords): Dates | undefined => {
+  const head = text.slice(0, date.offset - lineStart);
+  const found = new RegExp(`(?<![\\d/.]|\\p{L}\\.?\\s)(\\d{1,2})\\s*(?:${connectorPattern(words)})\\s*$`, "u").exec(head);
+  const day = found?.[1];
+  return day === undefined ? undefined : periodOf(withDay(date.value, day), date.value);
+};
+
+const MONTHS_IN_YEAR = 12;
+const ABBREVIATION = 3;
+
+const monthNumber = (name: string, months: readonly string[]): number => {
+  const head = name.slice(0, ABBREVIATION).toLowerCase();
+  return months.slice(0, MONTHS_IN_YEAR).findIndex((month) => month.slice(0, ABBREVIATION).toLowerCase() === head) + 1;
+};
+
+const monthDay = (name: string, day: string, months: readonly string[]): string | undefined => {
+  const month = monthNumber(name, months);
+  return month === 0 ? undefined : `${String(month).padStart(2, "0")}-${day.padStart(2, "0")}`;
+};
+
+const DAY = "(\\d{1,2})(?:st|nd|rd|th)?";
+
+/**
+ * 日付として読まれなかった、月の名と日の範囲（May 3–5, 2026、Dec 28–Jan 4, 2027）。英語の日付は、年を終わりにだけ書くと始まりを日付にしない。
+ * 年は終わりの日付のもので、始まりには年をまたいで補う。
+ */
+const monthRange = (text: string, words: PeriodWords): Dates | undefined => {
+  const names = words.months.map(escapeRegExp).join("|");
+  if (names === "") return undefined;
+  const month = `(${names})\\.?\\s+`;
+  const pattern = `(?<!\\p{L})${month}${DAY}\\s*(?:${connectorPattern(words)})\\s*(?:${month})?${DAY}(?![\\d:]|${CLOCK})(?:,?\\s+(\\d{4}))?`;
+  const found = new RegExp(pattern, "u").exec(text);
+  if (found === null) return undefined;
+  const [, startMonth = "", first = "", endMonth, last = "", year] = found;
+  const start = monthDay(startMonth, first, words.months);
+  const end = monthDay(endMonth ?? startMonth, last, words.months);
+  if (start === undefined || end === undefined) return undefined;
+  return periodOf(start, year === undefined ? end : `${year}-${end}`);
+};
+
+const fromTwo = (text: string, lineStart: number, first: DateMention, second: DateMention, words: PeriodWords): Dates | undefined =>
+  isJoint(text.slice(first.end - lineStart, second.offset - lineStart), words) ? periodOf(first.value, second.value) : undefined;
+
+const datesOf = (line: string, lineStart: number, from: number, dates: readonly DateMention[], words: PeriodWords): Dates | undefined => {
+  const inside = dates.filter((date) => date.offset >= lineStart + from && date.end <= lineStart + line.length);
+  const [first, second] = inside;
+  if (first !== undefined && second !== undefined) return fromTwo(line, lineStart, first, second, words);
+  if (first !== undefined) return dayAfter(line, first, lineStart, words) ?? dayBefore(line, first, lineStart, words) ?? monthRange(line.slice(from), words);
+  return monthRange(line.slice(from), words);
+};
+
+/**
+ * 期間の語で始まる一行の期間。行の中の日付が二つで間が範囲の記号なら、その二つ。一つなら、その前か後ろに日だけを書いた片方を読む。
+ * 日付の無い行は、月の名と日の範囲を読む。読めなければ undefined。
+ */
+export const statedPeriod = (line: string, lineStart: number, dates: readonly DateMention[], words: PeriodWords): Period | undefined => {
+  const from = afterLabel(line, words.labels);
+  if (from === undefined) return undefined;
+  const found = datesOf(line, lineStart, from, dates, words);
+  return found === undefined ? undefined : { ...found, written: line.slice(from).trim() };
+};

package/src/structure/tax.ts

@@ -0,0 +1,114 @@
+import type { StructureIssue } from "./issues.ts";
+import { runsOf, type Line } from "./runs.ts";
+import { columnOf, isTotalLabel, shownTotal, type Amount } from "./total.ts";
+
+/**
+ * 税の行と、その上の金額に率を掛けた額。表か箇条書きの並びで、税の語（消費税・Sales tax）で始まり率（10%）を書いた行の
+ * 金額を、上の最後の合計の行（小計）の金額に率を掛けた額と比べる。合計の行が無ければ、上の項目の和に掛ける。
+ * 端数は切り捨て・四捨五入・切り上げのどれでもよく、円の位でも銭（セント）の位でもよい。
+ * 内税（「うち消費税」）の行と、率の違う税の行が並ぶ並び（軽減税率）は読まない。Pure.
+ */
+export type TaxWords = {
+  /** 税の行の頭の語（消費税、Sales tax）。 */
+  readonly labels: readonly string[];
+  /** 合計の行の頭の語（小計、Subtotal）。 */
+  readonly totals: readonly string[];
+  /** 税の行が内税だと分かる語（うち、included）。 */
+  readonly included: readonly string[];
+};
+
+const RATE = /(\d{1,2}(?:\.\d{1,2})?)[ \t]?[%％]/u;
+const PERCENT = new Set(["%", "％"]);
+/** A sign or an opening bracket right before an amount (-$200, ▲500, (1,200)): the amount may be negative. */
+const SIGNED = /[-−▲△(（][ \t]?(?:[$€£¥￥][ \t]?)?$/u;
+const CENTS = 100;
+const MAX_RATE = 100;
+
+type Row = { readonly line: Line; readonly text: string; readonly amounts: readonly Amount[] };
+
+const rowsOf = (source: string, run: readonly Line[], amounts: readonly Amount[]): Row[] =>
+  run.map((line) => ({
+    line,
+    text: source.slice(line.start, line.end),
+    amounts: amounts.filter((amount) => amount.offset >= line.start && amount.offset <= line.end && !PERCENT.has(amount.unit)),
+  }));
+
+const rateOf = (text: string): number | undefined => {
+  const rate = Number(RATE.exec(text)?.[1]);
+  return Number.isFinite(rate) && rate > 0 && rate < MAX_RATE ? rate : undefined;
+};
+
+const isTaxRow = (row: Row, words: TaxWords): boolean =>
+  isTotalLabel(row.text, words.labels) && !words.included.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
+
+/** The list marker at the start of a line (- $500) is not a sign. */
+const isSigned = (source: string, row: Row, amount: Amount): boolean => {
+  const before = source.slice(row.line.start, amount.offset);
+  const sign = SIGNED.exec(before);
+  return sign !== null && before.slice(0, sign.index).trim().length > 0;
+};
+
+/**
+ * The one amount of the row in the column and unit of the tax amount, undefined when there is none, more than one, or
+ * one that may be negative (a discount is not added as written).
+ */
+const amountAt = (source: string, row: Row, column: number, unit: string): Amount | undefined => {
+  const matching = row.amounts.filter((amount) => amount.unit === unit && columnOf(source, row.line, amount.offset) === column);
+  const [only] = matching;
+  return matching.length === 1 && only !== undefined && !isSigned(source, row, only) ? only : undefined;
+};
+
+/**
+ * The base the tax is on: the last total row above, or the sum of the item rows above when there is no total row. A row
+ * with an amount between the total and the tax (a discount, shipping) may or may not be taxed, so there is no base.
+ */
+const baseOf = (source: string, above: readonly Row[], tax: Amount, column: number, words: TaxWords): Amount | undefined => {
+  const lastTotalIndex = above.findLastIndex((row) => isTotalLabel(row.text, words.totals));
+  const lastTotal = above[lastTotalIndex];
+  if (lastTotal !== undefined) {
+    const between = above.slice(lastTotalIndex + 1);
+    return between.some((row) => row.amounts.length > 0) ? undefined : amountAt(source, lastTotal, column, tax.unit);
+  }
+  const items = above.map((row) => amountAt(source, row, column, tax.unit));
+  if (items.length === 0 || items.some((item) => item === undefined)) return undefined;
+  const values = items.flatMap((item) => (item === undefined ? [] : [item.value]));
+  return { offset: tax.offset, end: tax.end, unit: tax.unit, value: values.reduce((sum, value) => sum + value, 0) };
+};
+
+/**
+ * Whether a written amount is an exact one rounded down, to nearest or up, to the cent or (when toUnit) to the unit. Both
+ * in cents. An amount written with cents ($59.00) is rounded to the cent only.
+ */
+export const roundedMatches = (writtenCents: number, exactCents: number, toUnits = true): boolean => {
+  const toCent = [Math.floor(exactCents), Math.round(exactCents), Math.ceil(exactCents)];
+  const toUnit = toUnits ? [Math.floor, Math.round, Math.ceil].map((round) => round(exactCents / CENTS) * CENTS) : [];
+  return [...toCent, ...toUnit].some((candidate) => Math.abs(candidate - writtenCents) < 1);
+};
+
+/** Whether the written tax is base × rate, rounded down, to nearest or up, to the unit or to the cent. */
+// base × rate% in cents: base × 100 × rate / 100.
+export const taxMatches = (writtenCents: number, base: number, rate: number): boolean => roundedMatches(writtenCents, base * rate);
+
+const issueOf = (source: string, rows: readonly Row[], index: number, rate: number, words: TaxWords): StructureIssue[] => {
+  const row = rows[index];
+  const tax = row?.amounts.length === 1 ? row.amounts[0] : undefined;
+  if (row === undefined || tax === undefined || isSigned(source, row, tax)) return [];
+  const column = columnOf(source, row.line, tax.offset);
+  const base = baseOf(source, rows.slice(0, index), tax, column, words);
+  if (base === undefined || taxMatches(Math.round(tax.value * CENTS), base.value, rate)) return [];
+  const expectedCents = Math.round(base.value * rate);
+  const shown = shownTotal(source, tax, expectedCents);
+  return [{ offset: tax.offset, values: { written: shown.written ?? "", expected: shown.sum ?? "", rate: `${String(rate)}%` } }];
+};
+
+const runIssues = (source: string, rows: readonly Row[], words: TaxWords): StructureIssue[] => {
+  const taxRows = rows.flatMap((row, index) => {
+    const rate = isTaxRow(row, words) ? rateOf(row.text) : undefined;
+    return rate === undefined ? [] : [{ index, rate }];
+  });
+  if (new Set(taxRows.map((row) => row.rate)).size > 1) return [];
+  return taxRows.flatMap(({ index, rate }) => issueOf(source, rows, index, rate, words));
+};
+
+export const taxMismatches = (source: string, amounts: readonly Amount[], words: TaxWords): StructureIssue[] =>
+  words.labels.length === 0 ? [] : runsOf(source).flatMap((run) => runIssues(source, rowsOf(source, run, amounts), words));

package/src/structure/time-marks.ts

@@ -0,0 +1,127 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 時刻のまわりに書く印を読む。発・着（departs、arr）、翌日（翌、+1、next day）、時間帯（JST、現地時間）。
+ * 語は言語パッケージの語彙表（leg-mark、leg-column、day-shift-mark、time-zone、local-time-mark）から来る。ここは字面を照らすだけで、語を知らない。
+ */
+
+/** 語彙表の一語。position は時刻のどちら側に書くか、group は語の組（departure と arrival、next と previous、local）。 */
+export type Mark = { readonly pattern: string; readonly position?: "before" | "after" | undefined; readonly group?: string | undefined };
+
+/** 時刻と、その原文の範囲。seconds は 0 時からの秒。 */
+export type TimeSpan = { readonly start: number; readonly end: number; readonly seconds: number };
+
+/** 日付と、その原文の範囲。value は年月日、年月、月日のいずれか（2026-04-01、04-01）。 */
+export type DateSpan = { readonly start: number; readonly end: number; readonly value: string };
+
+/** legs は時刻の前後に書く発着の印、columns は表の発着の列の名前、dayShifts は翌日・前日の印、zones は時間帯の印。 */
+export type TimeWords = {
+  readonly legs: readonly Mark[];
+  readonly columns: readonly Mark[];
+  readonly dayShifts: readonly Mark[];
+  readonly zones: readonly Mark[];
+};
+
+export const SECONDS_PER_DAY = 86_400;
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_MINUTE = 60;
+
+/** 「09:30」「21:05:10」の鍵を 0 時からの秒にする。 */
+export const secondsOf = (key: string): number => {
+  const [hour = 0, minute = 0, second = 0] = key.split(":").map(Number);
+  return hour * SECONDS_PER_HOUR + minute * SECONDS_PER_MINUTE + second;
+};
+
+/** 語の端の字の種類。英字は英字と、数字は数字と続けば一つの語（dep と department、+1 と +10）。 */
+const KINDS = [/[A-Za-z]/u, /[0-9０-９]/u];
+
+const joins = (edge: string, beside: string): boolean => KINDS.some((kind) => kind.test(edge) && kind.test(beside));
+
+/** text の at から pattern が、前後の字と続かない一語として書かれているか。 */
+export const isWordAt = (text: string, at: number, pattern: string): boolean => {
+  if (pattern === "" || !text.startsWith(pattern, at)) return false;
+  return !joins(pattern.charAt(0), text.charAt(at - 1)) && !joins(pattern.charAt(pattern.length - 1), text.charAt(at + pattern.length));
+};
+
+/** text の中で pattern が語として書かれた位置。 */
+export const wordOffsets = (text: string, pattern: string): number[] =>
+  [...text.matchAll(new RegExp(escapeRegExp(pattern), "gu"))].flatMap((match) => (isWordAt(text, match.index, pattern) ? [match.index] : []));
+
+const sidesOf = (marks: readonly Mark[], side: "before" | "after"): Mark[] => marks.filter((mark) => mark.position === side);
+
+/** 長い語から照らす（「翌日」を「翌」より先に）。 */
+const longestFirst = (marks: readonly Mark[]): Mark[] => marks.toSorted((left, right) => right.pattern.length - left.pattern.length);
+
+/** 時刻のすぐ後ろ（間を空けない）に書いた印。「08:00発」の「発」。 */
+export const markRightAfter = (text: string, end: number, marks: readonly Mark[]): Mark | undefined =>
+  longestFirst(sidesOf(marks, "after")).find((mark) => isWordAt(text, end, mark.pattern));
+
+/** 時刻の前の、間に letters 字までしか挟まない印。「departs Boston 7:30」の departs、「翌 0:15」の翌。 */
+export const markBefore = (head: string, marks: readonly Mark[], letters: number): Mark | undefined => {
+  const found = longestFirst(sidesOf(marks, "before")).flatMap((mark) =>
+    wordOffsets(head, mark.pattern).map((at) => ({ mark, gap: head.length - at - mark.pattern.length })),
+  );
+  const nearest = found.filter((entry) => entry.gap >= 0 && entry.gap <= letters).toSorted((left, right) => left.gap - right.gap)[0];
+  return nearest?.mark;
+};
+
+/** 時刻の後ろで、空白と開き括弧と発着の印を飛ばした所に書いた印。「0:15（翌日）」「9:50着 +1」。 */
+const SKIPPED_AFTER = /^[\s(（[［]*/u;
+
+export const markSoonAfter = (text: string, end: number, marks: readonly Mark[], skipped: readonly Mark[]): Mark | undefined => {
+  const leg = markRightAfter(text, end, skipped);
+  const from = end + (leg?.pattern.length ?? 0);
+  const gap = SKIPPED_AFTER.exec(text.slice(from))?.[0].length ?? 0;
+  return markRightAfter(text, from + gap, marks);
+};
+
+/** 日をまたぐ印の向き。翌日なら 1、前日なら -1、無ければ 0。 */
+const shiftOf = (mark: Mark | undefined): number => {
+  if (mark === undefined) return 0;
+  return mark.group === "previous" ? -1 : 1;
+};
+
+/** 「翌 0:15」のように前に書く翌日は、間に空白一つまで。 */
+const DAY_SHIFT_GAP = 1;
+
+/** 時刻の前置きから、時刻の直前に書いた翌日・前日の印（「翌 」）を除いたもの。印が無ければそのまま。 */
+export const withoutDayShiftBefore = (head: string, words: TimeWords): string => {
+  const mark = markBefore(head, words.dayShifts, DAY_SHIFT_GAP);
+  return mark === undefined ? head : head.slice(0, head.lastIndexOf(mark.pattern));
+};
+
+/** 時刻に付けた翌日・前日の印。head は時刻の前の原文、text と end は時刻の後ろを読むため。 */
+export const dayShiftOf = (head: string, text: string, end: number, words: TimeWords): number =>
+  shiftOf(markBefore(head, words.dayShifts, DAY_SHIFT_GAP) ?? markSoonAfter(text, end, words.dayShifts, words.legs));
+
+/** 時間帯の印に続けて書いた時差（UTC+9、GMT-5:00）。時差まで含めて一つの時間帯と読む。 */
+const ZONE_OFFSET = /^[+\-−＋]\d{1,2}(?::?\d{2})?/u;
+
+/** 書かれた時間帯。text は時差まで含めた字面。 */
+export type Zone = { readonly text: string; readonly group?: string | undefined };
+
+type ZoneSpan = Zone & { readonly start: number; readonly end: number };
+
+const zoneSpansOf = (text: string, mark: Mark): ZoneSpan[] =>
+  wordOffsets(text, mark.pattern).map((start) => {
+    const after = start + mark.pattern.length;
+    const offset = ZONE_OFFSET.exec(text.slice(after))?.[0] ?? "";
+    return { start, end: after + offset.length, text: mark.pattern + offset, group: mark.group };
+  });
+
+/** text に書かれた時間帯の印（JST、UTC+9、現地時間）。同じ字面は一度だけ。長い語から照らし、短い語が長い語の中で重ねて読まれない。 */
+export const zonesIn = (text: string, words: TimeWords): Zone[] => {
+  const spans = longestFirst(words.zones).reduce<ZoneSpan[]>(
+    (taken, mark) => [...taken, ...zoneSpansOf(text, mark).filter((span) => !taken.some((other) => span.start < other.end && other.start < span.end))],
+    [],
+  );
+  return spans
+    .filter((span, index) => spans.findIndex((other) => other.text === span.text) === index)
+    .map(({ text: written, group }) => ({ text: written, group }));
+};
+
+/**
+ * 時間帯をまたぐ行か。違う時間帯の印が二つ以上あるか、「現地時間」のように時間帯がどこかを言わない印（組 local）があれば、
+ * 時刻をそのまま比べられない。
+ */
+export const crossesZones = (zones: readonly Zone[]): boolean => zones.length >= 2 || zones.some((mark) => mark.group === "local");

package/src/structure/time-order.ts

@@ -0,0 +1,140 @@
+import type { StructureIssue } from "./issues.ts";
+import { runsOf, type Line } from "./runs.ts";
+import { longestInOrder, outOfPlace } from "./date-order.ts";
+import { crossesZones, dayShiftOf, withoutDayShiftBefore, zonesIn, SECONDS_PER_DAY, type DateSpan, type TimeSpan, type TimeWords } from "./time-marks.ts";
+
+/**
+ * 一日の予定として並べた時刻の順番。箇条書きの続いた項目と表の続いた行のうち、頭に時刻を書いたもの（「- 09:00 集合」
+ * 「| 2月9日 09:30 | 受付 |」）を並びとして読む。一日の予定は早い順に並ぶので、向きは決めずに早い順と見る。
+ * 日付の見出しが変われば並びは切れる。行の頭に書いた日付が変わるところ（表の日付の列）、時間帯の印が変わるところでも切る。
+ * 23:30 の次の 0:15 は、翌日の印（翌、+1、next day）があれば翌日の時刻と読む。印が無くても、半日より大きく戻る時刻は
+ * 夜をまたいだものと読み、言わない。打ち間違いの多くは数時間の戻りで、半日を超えて戻る予定は夜通しの予定のほうが多い。
+ * 早い順に並ぶ時刻が半分以下の並びは、時刻で並べた一覧ではないとして何も言わない。
+ */
+
+/** 頭に時刻を書いた項目。seconds は 0 時からの秒、shift は翌日の印（1）か無印（0）。 */
+type Stop = {
+  readonly offset: number;
+  readonly written: string;
+  readonly seconds: number;
+  readonly shift: number;
+  readonly date: string | undefined;
+  readonly zone: string;
+  /** 「09:00–10:30」のように範囲で書いた時刻の終わり。範囲でなければ無い。 */
+  readonly until: number | undefined;
+};
+
+/** 並びとして言うのに要る時刻の数。二つでは、どちらが外れたかも、並べたものかどうかも決められない。 */
+const MIN_STOPS = 3;
+/** 印の無い戻りを夜をまたいだと読む幅。 */
+const HALF_DAY = SECONDS_PER_DAY / 2;
+/** 頭の日付と時刻の間に挟んでよい字（曜日「Monday,」「（火）」）。 */
+const LEAD_BESIDE_DATE = 12;
+
+const ITEM_OPENER = /^[ \t]*(?:(?:[-*+]|\d{1,3}[.)])[ \t]+|\|)?/u;
+const MARKS_ONLY = /^[\s\p{P}\p{S}]*$/u;
+const DIGIT = /[0-9０-９]/u;
+
+/** 頭に書いた日付を除いた残り。日付があれば短い曜日まで、無ければ記号と空白だけなら、時刻が項目の頭にある。 */
+const leadsWithTime = (lead: string, leadStart: number, dates: readonly DateSpan[]): boolean => {
+  if (lead.includes("|")) return false;
+  const inLead = dates.filter((date) => date.start >= leadStart && date.end <= leadStart + lead.length);
+  const rest = inLead.reduceRight((text, date) => text.slice(0, date.start - leadStart) + text.slice(date.end - leadStart), lead).trim();
+  if (inLead.length === 0) return MARKS_ONLY.test(rest);
+  return !DIGIT.test(rest) && rest.length <= LEAD_BESIDE_DATE;
+};
+
+const zoneKeyOf = (text: string, words: TimeWords): string | undefined => {
+  const zones = zonesIn(text, words);
+  if (zones.length >= 2) return undefined;
+  return crossesZones(zones) ? `local:${zones[0]?.text ?? ""}` : (zones[0]?.text ?? "");
+};
+
+type Inputs = { readonly source: string; readonly times: readonly TimeSpan[]; readonly dates: readonly DateSpan[]; readonly words: TimeWords };
+
+/** 時刻と時刻の間が範囲の印だけなら、後ろの時刻は範囲の終わり。 */
+const RANGE_GAP = /^\s?[-–—~〜～]\s?$/u;
+
+const rangeEndOf = (source: string, time: TimeSpan, times: readonly TimeSpan[]): number | undefined => {
+  const next = times.find((candidate) => candidate.start >= time.end);
+  return next !== undefined && RANGE_GAP.test(source.slice(time.end, next.start)) ? next.seconds : undefined;
+};
+
+/** 行の頭の時刻。頭に時刻が無い行、時間帯の印が二つある行、前日の印の付いた時刻は並びに入れない。 */
+const stopOf = (line: Line, inputs: Inputs): Stop | undefined => {
+  const { source, times, dates, words } = inputs;
+  const text = source.slice(line.start, line.end);
+  const time = times.find((candidate) => candidate.start >= line.start && candidate.end <= line.end);
+  const leadStart = line.start + (ITEM_OPENER.exec(text)?.[0].length ?? 0);
+  if (time === undefined || !leadsWithTime(withoutDayShiftBefore(source.slice(leadStart, time.start), words), leadStart, dates)) return undefined;
+  const zone = zoneKeyOf(text, words);
+  const shift = dayShiftOf(source.slice(line.start, time.start), source, time.end, words);
+  if (zone === undefined || shift < 0) return undefined;
+  const date = dates.filter((span) => span.start >= leadStart && span.end <= time.start).at(-1)?.value;
+  const until = rangeEndOf(source, time, times);
+  return { offset: time.start, written: source.slice(time.start, time.end), seconds: time.seconds, shift, date, zone, until };
+};
+
+/** 一日の並びを切る所: 頭の日付が前と違う、時間帯の印が前と違う。 */
+const startsNewDay = (stop: Stop, day: readonly Stop[]): boolean => {
+  const last = day.at(-1);
+  if (last === undefined) return false;
+  const lastDate = day.findLast((earlier) => earlier.date !== undefined)?.date;
+  return (stop.date !== undefined && lastDate !== undefined && stop.date !== lastDate) || stop.zone !== last.zone;
+};
+
+const daysOf = (stops: readonly Stop[]): Stop[][] =>
+  stops.reduce<Stop[][]>((days, stop) => {
+    const day = days.at(-1) ?? [];
+    return startsNewDay(stop, day) ? [...days, [stop]] : [...days.slice(0, -1), [...day, stop]];
+  }, []);
+
+/**
+ * 並びの中の、日をまたいだ秒。翌日の印のある時刻は翌日、印の無い時刻は前の時刻と同じ日。
+ * 前の時刻より半日を超えて戻る無印の時刻は、夜をまたいだ翌日の時刻。
+ */
+export const elapsedSeconds = (stops: readonly { readonly seconds: number; readonly shift: number }[]): number[] =>
+  stops
+    .reduce<{ day: number; seconds: number }[]>((placed, stop) => {
+      const previous = placed.at(-1);
+      const rolled = previous !== undefined && previous.seconds - stop.seconds > HALF_DAY ? previous.day + 1 : (previous?.day ?? 0);
+      return [...placed, { day: stop.shift > 0 ? Math.max(rolled, stop.shift) : rolled, seconds: stop.seconds }];
+    }, [])
+    .map((placed) => placed.day * SECONDS_PER_DAY + placed.seconds);
+
+/** 文字の並びで比べられるよう、秒を桁をそろえた文字にする。 */
+const PADDED = 8;
+const sortable = (seconds: number): string => String(seconds).padStart(PADDED, "0");
+
+/** 外れた時刻に、前の時刻を添える。先頭の時刻には前が無いので、次の時刻を添える。 */
+const issueAt = (day: readonly Stop[], at: number): StructureIssue[] => {
+  const stop = day[at];
+  if (stop === undefined) return [];
+  const neighbour = at === 0 ? { next: day[1]?.written ?? "" } : { previous: day[at - 1]?.written ?? "" };
+  return [{ offset: stop.offset, values: { time: stop.written, ...neighbour } }];
+};
+
+/**
+ * 範囲で書いた時刻の並びで、前の範囲が終わる前に次が始まる一歩が半分を超えるもの。曜日ごとの営業時間（9:00–18:00 が続く）
+ * のように時刻で並べたものではない一覧で、一日の予定ではない。
+ */
+export const isOverlappingRanges = (ranges: readonly { readonly seconds: number; readonly until: number | undefined }[]): boolean => {
+  const steps = ranges.slice(1).map((range, index) => ranges[index]?.until !== undefined && range.seconds < (ranges[index]?.until ?? 0));
+  return steps.length > 0 && steps.filter(Boolean).length * 2 > steps.length;
+};
+
+/** 早い順に逆らう一歩ごとに、並びから外れた時刻を指す。早い順に並ぶ時刻が半分以下の並びと、重なる範囲の並びは言わない。 */
+const breaksIn = (day: readonly Stop[]): StructureIssue[] => {
+  const values = elapsedSeconds(day).map(sortable);
+  if (values.length < MIN_STOPS || longestInOrder(values, 1) * 2 <= values.length || isOverlappingRanges(day)) return [];
+  return values.slice(1).flatMap((value, index) => (value < (values[index] ?? "") ? issueAt(day, outOfPlace(values, index + 1, 1)) : []));
+};
+
+/** 一日の予定の時刻のうち、早い順から外れたもの。 */
+export const timeOrderBreaks = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords): StructureIssue[] => {
+  const inputs = { source, times, dates, words };
+  return runsOf(source).flatMap((run) => {
+    const stops = run.flatMap((line) => stopOf(line, inputs) ?? []);
+    return daysOf(stops).flatMap(breaksIn);
+  });
+};