chaffjs 0.29.0 → 0.30.0

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

@@ -0,0 +1,86 @@
+import { versionsAlong } from "./version-order.ts";
+
+/**
+ * 隣どうしの二つの日付が入れ替わったように見えて、どちらを取り除いても同じだけ揃う（引き分け）とき、同じ項目の手がかりで決める。
+ * 項目がみな版を持ち、版が向きに沿って並ぶなら、並びの位置は版が裏付ける。位置に照らして逆らう相手の多い日付を指す。
+ * 版が無いか、版も乱れているなら、二つだけが入れ替わった並びに限り、外側の隣（前の日付の前、後ろの日付の後ろ）から遠いほうを指す。書き間違えた日付は隣から跳ぶ。
+ * どちらでも決まらなければ undefined（呼ぶ側はこれまでどおり後ろを指す）。
+ */
+export type TieEntry = { readonly value: string; readonly version: string | undefined };
+
+const DAY_MS = 86_400_000;
+const MONTHS_PER_YEAR = 12;
+/** 年の無い月日（09-14）を日数にするための、閏年の仮の年。 */
+const LEAP_YEAR = 2000;
+
+/** 同じ書き方の日付どうしで差をとれる数。年月日と月日は日数、年月は月数。 */
+const pointOf = (value: string): number | undefined => {
+  const full = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(value);
+  if (full !== null) return Date.UTC(Number(full[1]), Number(full[2]) - 1, Number(full[3])) / DAY_MS;
+  const month = /^(\d{4})-(\d{2})$/u.exec(value);
+  if (month !== null) return Number(month[1]) * MONTHS_PER_YEAR + Number(month[2]);
+  const day = /^(\d{2})-(\d{2})$/u.exec(value);
+  return day === null ? undefined : Date.UTC(LEAP_YEAR, Number(day[1]) - 1, Number(day[2])) / DAY_MS;
+};
+
+/** 位置に照らして向きに逆らう相手の数。 */
+const disagreements = (values: readonly string[], index: number, direction: number): number =>
+  values.filter((other, at) => {
+    if (at === index) return false;
+    const [earlier, later] = at < index ? [other, values[index] ?? ""] : [values[index] ?? "", other];
+    return Math.sign(later.localeCompare(earlier)) === -direction;
+  }).length;
+
+/** 多いほうを指す。同じなら決めない。 */
+const larger = (before: number, after: number, scores: readonly [number, number]): number | undefined => {
+  if (scores[0] === scores[1]) return undefined;
+  return scores[0] > scores[1] ? before : after;
+};
+
+const byVersion = (entries: readonly TieEntry[], before: number, after: number, direction: number): number | undefined => {
+  if (
+    !versionsAlong(
+      entries.map((entry) => entry.version),
+      direction,
+    )
+  )
+    return undefined;
+  const values = entries.map((entry) => entry.value);
+  return larger(before, after, [disagreements(values, before, direction), disagreements(values, after, direction)]);
+};
+
+const distance = (entries: readonly TieEntry[], from: number, to: number): number | undefined => {
+  const start = pointOf(entries[from]?.value ?? "");
+  const end = pointOf(entries[to]?.value ?? "");
+  return start === undefined || end === undefined ? undefined : Math.abs(end - start);
+};
+
+/** from から to へ、向きに逆らわない（等しくてもよい）。 */
+const along = (from: string, to: string, direction: number): boolean => Math.sign(to.localeCompare(from)) !== -direction;
+
+/** 隣どうしの入れ替わりだけ: 外側の二つが向きに沿い、入れ替わった二つがどちらもその間に収まる。乱れが広い並びでは、外側の隣も当てにならない。 */
+const isSwap = (values: readonly string[], before: number, after: number, direction: number): boolean => {
+  const [outerBefore, outerAfter] = [values[before - 1], values[after + 1]];
+  if (outerBefore === undefined || outerAfter === undefined) return false;
+  return [values[before] ?? "", values[after] ?? ""].every((value) => along(outerBefore, value, direction) && along(value, outerAfter, direction));
+};
+
+const byGap = (entries: readonly TieEntry[], before: number, after: number, direction: number): number | undefined => {
+  if (
+    !isSwap(
+      entries.map((entry) => entry.value),
+      before,
+      after,
+      direction,
+    )
+  )
+    return undefined;
+  const outerBefore = distance(entries, before - 1, before);
+  const outerAfter = distance(entries, after, after + 1);
+  if (outerBefore === undefined || outerAfter === undefined) return undefined;
+  return larger(before, after, [outerBefore, outerAfter]);
+};
+
+/** 引き分けの二つ（before = at - 1、after = at）のうち外れたほう。決まらなければ undefined。 */
+export const breakDateTie = (entries: readonly TieEntry[], before: number, after: number, direction: number): number | undefined =>
+  byVersion(entries, before, after, direction) ?? byGap(entries, before, after, direction);

package/src/structure/date-order.ts

@@ -1,6 +1,8 @@
 import type { StructureIssue } from "./issues.ts";
 import { siblingHeadingRunsOf } from "./heading-runs.ts";
 import { runsOf } from "./runs.ts";
+import { breakDateTie, type TieEntry } from "./date-order-tie.ts";
+import { leadingVersion } from "./version-order.ts";
 
 /**
  * 日程として並べた日付の順番。箇条書きの続いた項目、表の続いた行、同じ親の下で同じ深さに並ぶ見出しで、
@@ -32,17 +34,30 @@ const onlyDateIn = (line: Span, points: readonly DatedPoint[]): DatedPoint | und
   return inside.length === 1 ? inside[0] : undefined;
 };
 
-const datedLines = (run: readonly Span[], points: readonly DatedPoint[]): DatedPoint[] =>
+/** 日付を一つ持つ一行。行が版で始まれば（「## 3.1.1 - 2026-05-08」「- 3.1.0 (2026-06-02)」）その版を添える。 */
+type DatedEntry = DatedPoint & Pick<TieEntry, "version">;
+
+/** 見出しの #、箇条書きの記号、表の最初の |。 */
+const LINE_MARKER = /^[ \t]*(?:#{1,6}|[-*+]|\d{1,3}[.)]|\|)?[ \t]*/u;
+
+const entryOf = (source: string, line: Span, points: readonly DatedPoint[]): DatedEntry | undefined => {
+  const date = onlyDateIn(line, points);
+  if (date === undefined) return undefined;
+  const text = source.slice(line.start, line.end);
+  return { ...date, version: leadingVersion(text.slice(LINE_MARKER.exec(text)?.[0].length ?? 0)) };
+};
+
+const datedLines = (source: string, run: readonly Span[], points: readonly DatedPoint[]): DatedEntry[] =>
   run.flatMap((line) => {
-    const date = onlyDateIn(line, points);
-    return date === undefined ? [] : [date];
+    const entry = entryOf(source, line, points);
+    return entry === undefined ? [] : [entry];
   });
 
 /** 見出しの並びは、日付を一つ持つ見出しが続くあいだだけ。日付の無い見出しが混じる並び（問いに更新日を添えた FAQ）は、日付で並べたものではない。 */
-const datedStretches = (run: readonly Span[], points: readonly DatedPoint[]): DatedPoint[][] =>
-  run.reduce<DatedPoint[][]>(
+const datedStretches = (source: string, run: readonly Span[], points: readonly DatedPoint[]): DatedEntry[][] =>
+  run.reduce<DatedEntry[][]>(
     (stretches, heading) => {
-      const date = onlyDateIn(heading, points);
+      const date = entryOf(source, heading, points);
       if (date === undefined) return [...stretches, []];
       return [...stretches.slice(0, -1), [...(stretches.at(-1) ?? []), date]];
     },
@@ -71,10 +86,19 @@ const without = (values: readonly string[], index: number): string[] => values.f
 
 /**
  * 向きに逆らう一歩（at - 1 から at）のうち、並びから外れているほう。取り除いたとき残りが長く揃うほうを指す。
- * 前を取っても後ろを取っても同じだけ揃う（隣どうしの入れ替わり）なら、どちらとも決められないので後ろを指す。
+ * 前を取っても後ろを取っても同じだけ揃う（隣どうしの入れ替わり）なら、tieBreak が決めたほう、決まらなければ後ろを指す。
  */
-export const outOfPlace = (values: readonly string[], at: number, direction: number): number =>
-  longestInOrder(without(values, at - 1), direction) > longestInOrder(without(values, at), direction) ? at - 1 : at;
+export const outOfPlace = (
+  values: readonly string[],
+  at: number,
+  direction: number,
+  tieBreak: (before: number, after: number) => number | undefined = () => undefined,
+): number => {
+  const withoutBefore = longestInOrder(without(values, at - 1), direction);
+  const withoutAfter = longestInOrder(without(values, at), direction);
+  if (withoutBefore === withoutAfter) return tieBreak(at - 1, at) ?? at;
+  return withoutBefore > withoutAfter ? at - 1 : at;
+};
 
 /** 外れた日付に、前の日付を添える。先頭の日付には前が無いので、次の日付を添える。 */
 const issueAt = (dated: readonly DatedPoint[], at: number): StructureIssue[] => {
@@ -85,18 +109,21 @@ const issueAt = (dated: readonly DatedPoint[], at: number): StructureIssue[] =>
 };
 
 /** 多いほうの向きに逆らう一歩ごとに、並びから外れた日付を指す。 */
-const againstMajority = (dated: readonly DatedPoint[]): StructureIssue[] => {
+const againstMajority = (dated: readonly DatedEntry[]): StructureIssue[] => {
   const values = dated.map((point) => point.value);
   const signs = values.slice(1).map((value, index) => Math.sign(value.localeCompare(values[index] ?? "")));
   const majority = majorityOf(signs.filter((sign) => sign > 0).length, signs.filter((sign) => sign < 0).length);
   if (majority === 0 || !mostlyInOrder(values, majority)) return [];
   return signs.flatMap((sign, index) => {
     if (sign !== -majority) return [];
-    return issueAt(dated, outOfPlace(values, index + 1, majority));
+    return issueAt(
+      dated,
+      outOfPlace(values, index + 1, majority, (before, after) => breakDateTie(dated, before, after, majority)),
+    );
   });
 };
 
-const breaksIn = (dated: readonly DatedPoint[]): StructureIssue[] => (samePrecision(dated) ? againstMajority(dated) : []);
+const breaksIn = (dated: readonly DatedEntry[]): StructureIssue[] => (samePrecision(dated) ? againstMajority(dated) : []);
 
 /** 見出しを箇条書きの中に書けば（「- ## 3.1.0 - 2026-10-02」）、同じ日付が両方の並びに入る。一度だけ言う。 */
 const oncePerOffset = (issues: readonly StructureIssue[]): StructureIssue[] =>
@@ -104,6 +131,6 @@ const oncePerOffset = (issues: readonly StructureIssue[]): StructureIssue[] =>
 
 export const dateOrderBreaks = (source: string, points: readonly DatedPoint[], headings: readonly HeadingSpan[] = []): StructureIssue[] =>
   oncePerOffset([
-    ...runsOf(source).flatMap((run) => breaksIn(datedLines(run, points))),
-    ...siblingHeadingRuns(headings).flatMap((run) => datedStretches(run, points).flatMap(breaksIn)),
+    ...runsOf(source).flatMap((run) => breaksIn(datedLines(source, run, points))),
+    ...siblingHeadingRuns(headings).flatMap((run) => datedStretches(source, run, points).flatMap(breaksIn)),
   ]);

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

@@ -8,11 +8,19 @@ import { statedPeriod, type DateMention, type Period, type PeriodWords } from ".
  * 地の文の日付は、年の無いもの（2月12日（金）の午前は…）だけを比べる。年のある日付は、過去の回や別の年の出来事を挙げることが多い。
  * 期間の前後に置く予定（前泊、follow-up）、締め切りや予約の日、過去の回を言う語（period-aside）が、その行、文、節の見出しにあれば比べない。
  * 年の無い期間（12月28日〜1月4日）は年をまたいで読む。
+ * 文書の仕事の期間（開講期間：…）を文書の頭か概要の節で書いたものは文書全体の期間で、後ろのどの節でも、締め切りの語（period-deadline）のある項目や文の、
+ * 期間の終わりより後の年のある日付を指す（課題の提出が学期の後）。期間の前の締め切り（申込締切）と、旅行期間のように後に締め切りが来てよい期間は比べない。
  */
 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[] };
+export type OutsideWords = PeriodWords & {
+  readonly asides: readonly string[];
+  /** 文書の仕事がその中で済む期間の語（開講期間、Term）。この期間は締め切りとだけ比べる。 */
+  readonly terms: readonly string[];
+  readonly deadlines: readonly string[];
+  readonly overviews: readonly string[];
+};
 
 const LIST_ITEM = /^[ \t]{0,12}(?:[-*+]|\d{1,3}[.)])[ \t]/u;
 const DAY_VALUE = /^(?:\d{4}-)?\d{2}-\d{2}$/u;
@@ -46,7 +54,7 @@ export const mentions = (text: string, words: readonly string[]): boolean => {
   });
 };
 
-type Stated = Period & { readonly scopeStart: number; readonly scopeEnd: number };
+type Stated = Period & { readonly line: Span; readonly scopeStart: number; readonly scopeEnd: number; readonly nextPeriod: number };
 
 /**
  * 期間の及ぶ範囲の始まり: 期間の行の後ろ。期間の行が箇条書きの項目なら、その箇条書きの後ろ。
@@ -84,6 +92,8 @@ const statedPeriods = (
   });
   return found.map(({ period, line }, index) => ({
     ...period,
+    line,
+    nextPeriod: found[index + 1]?.line.start ?? source.length,
     scopeStart: scopeStart(source, lines, line),
     scopeEnd: scopeEnd(line, found[index + 1]?.line.start ?? source.length, headings, source.length),
   }));
@@ -110,6 +120,63 @@ const outsideOne = (date: DateMention, period: Stated, context: Context, asides:
   return !surroundings(date, line, item, context).some((text) => mentions(text, asides));
 };
 
+const boundaryPattern = (word: string): RegExp => {
+  const target = escapeRegExp(word.toLowerCase());
+  return /[a-z]/u.test(word.toLowerCase()) ? new RegExp(`(?<![a-z])${target}(?![a-z])`, "gu") : new RegExp(target, "gu");
+};
+
+/** 締め切りの語を除いた文。「提出期限」の「期限」、「submit by」の「submit」は、期間の外に置く語として読まない。 */
+const withoutWords = (text: string, words: readonly string[]): string =>
+  words.toSorted((left, right) => right.length - left.length).reduce((rest, word) => rest.replace(boundaryPattern(word), " "), text.toLowerCase());
+
+/** 節の見出しの並び（その行の見出しと、それを囲む浅い見出し）。 */
+const enclosingHeadings = (offset: number, headings: readonly HeadingSpan[]): HeadingSpan[] =>
+  headings
+    .filter((heading) => heading.start < offset)
+    .toReversed()
+    .reduce<HeadingSpan[]>((chain, heading) => (heading.depth < (chain.at(-1)?.depth ?? Infinity) ? [...chain, heading] : chain), []);
+
+/** 文書の仕事の期間か: 表題（文書の頭の # の見出し）のほかの見出しより前か、概要の節（period-overview-heading）の行。 */
+const isDocumentTerm = (period: Stated, context: Context, overviews: readonly string[]): boolean => {
+  const sections = context.headings.filter((heading, index) => heading.start < period.line.start && !(index === 0 && heading.depth === 1));
+  if (sections.length === 0) return true;
+  return enclosingHeadings(period.line.start, context.headings).some((heading) => mentions(context.source.slice(heading.start, heading.end), overviews));
+};
+
+const afterEnd = (value: string, period: Period): boolean => hasYear(value) && hasYear(period.end) && value > period.end;
+
+const lateDeadline = (date: DateMention, period: Stated, context: Context, words: OutsideWords): boolean => {
+  if (!DAY_VALUE.test(date.value) || !afterEnd(date.value, period)) return false;
+  const line = containing(context.lines, date.offset);
+  if (line === undefined) return false;
+  const texts = surroundings(date, line, isItem(context.source.slice(line.start, line.end), line, context.headings), context);
+  if (!mentions(texts[0] ?? "", words.deadlines)) return false;
+  return !texts.some((text) => mentions(withoutWords(text, words.deadlines), words.asides));
+};
+
+const issueOf = (source: string, date: DateMention, period: Stated): StructureIssue => ({
+  offset: date.offset,
+  values: { date: source.slice(date.offset, date.end), period: period.written },
+});
+
+/** 期間の行の後ろ、同じ節の日程の日付で、期間の外のもの。 */
+const outsideInSection = (dates: readonly DateMention[], context: Context, words: OutsideWords): StructureIssue[] =>
+  statedPeriods(context.source, context.lines, dates, context.headings, words).flatMap((period) =>
+    dates
+      .filter((date) => date.offset > period.scopeStart && date.offset < period.scopeEnd && outsideOne(date, period, context, words.asides))
+      .map((date) => issueOf(context.source, date, period)),
+  );
+
+/** 文書の仕事の期間の行の後ろ、次の仕事の期間の行までの、期間の終わりより後の締め切り。 */
+const lateDeadlines = (dates: readonly DateMention[], context: Context, words: OutsideWords): StructureIssue[] =>
+  statedPeriods(context.source, context.lines, dates, context.headings, { ...words, labels: words.terms })
+    .filter((period) => isDocumentTerm(period, context, words.overviews))
+    .flatMap((period) =>
+      dates
+        .filter((date) => date.offset > period.line.end && date.offset < period.nextPeriod && lateDeadline(date, period, context, words))
+        .map((date) => issueOf(context.source, date, period)),
+    );
+
 export const datesOutsidePeriod = (
   source: string,
   dates: readonly DateMention[],
@@ -119,9 +186,7 @@ export const datesOutsidePeriod = (
 ): 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 } })),
-  );
+  const inSection = outsideInSection(dates, context, words);
+  const reported = new Set(inSection.map((issue) => issue.offset));
+  return [...inSection, ...lateDeadlines(dates, context, words).filter((issue) => !reported.has(issue.offset))];
 };

package/src/structure/date-range.ts

@@ -107,20 +107,48 @@ const sentenceAround = (source: string, start: DatedSpan, end: DatedSpan): { rea
   return { text: flat(source.slice(paragraphStart + from, end.end + to)), before: flat(head.slice(from)).trimEnd() };
 };
 
-/** 前の語と間の語の組（from … to）。同じ文のどこかに変更の語（moved、postponed）があれば、日付を動かした文で、期間ではない。 */
+/** 同じ文のどこかに変更の語（moved、postponed）があれば、日付を動かした文で、期間ではない。 */
+const isChange = (source: string, start: DatedSpan, end: DatedSpan, words: RangeWords): boolean => {
+  const sentence = sentenceAround(source, start, end).text;
+  return words.changes.some((change) => hasWord(sentence, change.toLowerCase()));
+};
+
+/** 前の語と間の語の組（from … to）。 */
 const framed = (source: string, start: DatedSpan, end: DatedSpan, joint: string, words: RangeWords): boolean => {
-  const sentence = sentenceAround(source, start, end);
-  const before = withoutTrailingWeekday(sentence.before, words.weekdays ?? []);
+  const before = withoutTrailingWeekday(sentenceAround(source, start, end).before, words.weekdays ?? []);
   const frame = words.frames.find((candidate) => candidate.joint === joint && endsWithWord(before, candidate.lead));
-  return frame !== undefined && !words.changes.some((change) => hasWord(sentence.text, change.toLowerCase()));
+  return frame !== undefined && !isChange(source, start, end, words);
+};
+
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
+
+/** 日付の前に曜日の名を添えた（Monday, October 5, 2026）。同じ行の、日付の直前だけを見る。 */
+const weekdayBefore = (source: string, date: DatedSpan, weekdays: readonly string[]): boolean => {
+  const before = source.slice(source.lastIndexOf("\n", date.offset - 1) + 1, date.offset).trimEnd();
+  return before !== "" && withoutTrailingWeekday(before, weekdays) !== before;
 };
 
-const isRange = (source: string, start: DatedSpan, end: DatedSpan, words: RangeWords): boolean => {
+/**
+ * 前の語の無い組の間の語だけ（October 5, 2026 to October 30, 2026）。「to」は日付を動かす文にも出るので、
+ * 期間の語で始まる行（Dates: …）か、両方が曜日を添えた年月日のときだけ期間と読む。変更の語のある文は読まない。
+ */
+const bareFramed = (source: string, start: DatedSpan, end: DatedSpan, written: string, words: RangeWords, isLabelled: (offset: number) => boolean): boolean => {
+  const weekdays = words.weekdays ?? [];
+  const joint = withoutTrailingWeekday(written, weekdays);
+  if (!words.frames.some((frame) => frame.joint === joint)) return false;
+  const withWeekdays = FULL_DATE.test(start.value) && FULL_DATE.test(end.value) && joint !== written && weekdayBefore(source, start, weekdays);
+  return (isLabelled(start.offset) || withWeekdays) && !isChange(source, start, end, words);
+};
+
+const isRange = (source: string, start: DatedSpan, end: DatedSpan, words: RangeWords, isLabelled: (offset: number) => boolean): boolean => {
   const written = jointOf(source, start, end);
   if (written === undefined) return false;
   const joint = withoutTrailingWeekday(written, words.weekdays ?? []);
   return (
-    isOneOf(joint, words.connectors) || (isOneOf(joint, words.openers) && closedAfter(source, end, words.closers)) || framed(source, start, end, joint, words)
+    isOneOf(joint, words.connectors) ||
+    (isOneOf(joint, words.openers) && closedAfter(source, end, words.closers)) ||
+    framed(source, start, end, joint, words) ||
+    bareFramed(source, start, end, written, words, isLabelled)
   );
 };
 
@@ -132,11 +160,19 @@ const writtenPeriod = (source: string, start: DatedSpan, end: DatedSpan): string
     .map((part) => part.trim())
     .join(" ");
 
-/** 隣り合う二つの日付のうち、期間をなし、終わりが始まりより前のもの。期間の書き出しを指し、書いたままの期間を見せる。 */
-export const reversedRanges = (source: string, dates: readonly DatedSpan[], words: RangeWords): StructureIssue[] =>
+/**
+ * 隣り合う二つの日付のうち、期間をなし、終わりが始まりより前のもの。期間の書き出しを指し、書いたままの期間を見せる。
+ * isLabelled は、その位置の日付が期間の語で始まる行（Dates: …）の、語より後ろにあるか。
+ */
+export const reversedRanges = (
+  source: string,
+  dates: readonly DatedSpan[],
+  words: RangeWords,
+  isLabelled: (offset: number) => boolean = () => false,
+): StructureIssue[] =>
   dates.slice(1).flatMap((end, index) => {
     const start = dates[index];
     if (start === undefined || !comparable(start.value, end.value) || end.value >= start.value) return [];
-    if (!isRange(source, start, end, words)) return [];
+    if (!isRange(source, start, end, words, isLabelled)) return [];
     return [{ offset: start.offset, values: { start: start.value, end: end.value, period: writtenPeriod(source, start, end) } }];
   });

package/src/structure/leg-times.ts

@@ -196,3 +196,18 @@ export const arrivalsBeforeDeparture = (source: string, times: readonly TimeSpan
     .filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index)
     .toSorted((left, right) => left.offset - right.offset);
 };
+
+/** 表の着の列に書いた時刻の位置。見出しに着の列の無い表からは読まない。 */
+const columnArrivals = (inputs: Inputs): number[] =>
+  tablesOf(inputs.source).flatMap((table) => {
+    const arrives = columnOf(inputs.source, table.header, inputs.words.columns, ARRIVAL);
+    if (arrives === -1) return [];
+    return table.rows.flatMap((row) => cellTime(cellsOf(inputs.source, row.start, row.end)[arrives], inputs)?.offset ?? []);
+  });
+
+/** 着と読む時刻の位置。行の中の印（「09:50着」「arrives 9:05 AM」）と、表の着の列から。 */
+export const arrivalOffsets = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords): Set<number> => {
+  const inputs = { source, times, dates, words };
+  const inline = linesOf(source).flatMap((line) => legsInLine(line.start, line.end, inputs).flatMap((leg) => (leg.side === ARRIVAL ? [leg.offset] : [])));
+  return new Set([...inline, ...columnArrivals(inputs)]);
+};

package/src/structure/party-order.ts

@@ -0,0 +1,115 @@
+import type { BodyText } from "./definition-use.ts";
+
+/**
+ * 当事者の呼び名を並べた所（甲及び乙、甲又は乙、甲乙、甲、乙及び丙）と、文書がふだん書く順と逆に並べた所。
+ * 並べる語は言語パッケージの語彙表から取る。向きのある言い方（乙から甲へ、甲が乙に）は並べる語でつながないので読まない。
+ */
+export type ListingWords = {
+  /** 当事者の呼び名（甲、乙、文書が定めた委託者）。 */
+  readonly labels: readonly string[];
+  /** 間に語を置かずに並べてよい呼び名（甲乙）。 */
+  readonly bareLabels: readonly string[];
+  /** 並べる語（及び、又は、・）。 */
+  readonly joiners: readonly string[];
+  /** 同じ並びのあとに並べる語があるときだけつなぐ印（甲、乙及び丙の「、」）。 */
+  readonly seriesMarks: readonly string[];
+};
+
+export type PartyListing = { readonly start: number; readonly end: number; readonly labels: readonly string[] };
+
+export type OrderSlip = { readonly listing: PartyListing; readonly usual: PartyListing; readonly usualCount: number; readonly reverseCount: number };
+
+type Link = "joiner" | "series" | "bare";
+type Step = { readonly link: Link; readonly label: string; readonly end: number };
+
+/** 呼び名の前の一字がこれなら、呼び名は長い語の一部（乙種の前の語、1丁目）。 */
+const WORD_CHAR = /[\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}ー]/u;
+
+const longestAt = (text: string, at: number, words: readonly string[]): string | undefined =>
+  words
+    .filter((word) => word !== "" && text.startsWith(word, at))
+    .reduce<string | undefined>((best, word) => (best === undefined || word.length > best.length ? word : best), undefined);
+
+const stepAfter = (text: string, at: number, previous: string, words: ListingWords): Step | undefined => {
+  const linked = (link: Link, mark: string | undefined): Step | undefined => {
+    if (mark === undefined) return undefined;
+    const label = longestAt(text, at + mark.length, words.labels);
+    return label === undefined ? undefined : { link, label, end: at + mark.length + label.length };
+  };
+  const bare = words.bareLabels.includes(previous) ? longestAt(text, at, words.bareLabels) : undefined;
+  const side: Step | undefined = bare === undefined ? undefined : { link: "bare", label: bare, end: at + bare.length };
+  return linked("joiner", longestAt(text, at, words.joiners)) ?? linked("series", longestAt(text, at, words.seriesMarks)) ?? side;
+};
+
+/** 並べた語の数。「、」は、そのあとに並べる語が無ければ並びの終わり（「甲、乙は」は並べたと読まない）。 */
+const linksKept = (links: readonly Link[]): number => {
+  const lastJoiner = links.lastIndexOf("joiner");
+  const series = links.findIndex((link, index) => link === "series" && index > lastJoiner);
+  return series === -1 ? links.length : series;
+};
+
+/** 最後の呼び名が長い語の頭なら並びに入れない（乙及び甲種株式の甲）。間を置かずに並べた甲乙は、あとに語が続いてよい（甲乙間、甲乙双方）。 */
+const endsInWord = (text: string, steps: readonly Step[]): boolean => {
+  const last = steps.at(-1);
+  return last !== undefined && last.link !== "bare" && WORD_CHAR.test(text.charAt(last.end));
+};
+
+const listingAt = (text: BodyText, at: number, first: string, words: ListingWords): PartyListing => {
+  const steps: Step[] = [];
+  let end = at + first.length;
+  for (let step = stepAfter(text.text, end, first, words); step !== undefined; step = stepAfter(text.text, end, step.label, words)) {
+    steps.push(step);
+    end = step.end;
+  }
+  const whole = endsInWord(text.text, steps) ? steps.slice(0, -1) : steps;
+  const kept = whole.slice(0, linksKept(whole.map((step) => step.link)));
+  const last = kept.at(-1);
+  return { start: text.start + at, end: text.start + (last === undefined ? at + first.length : last.end), labels: [first, ...kept.map((step) => step.label)] };
+};
+
+/** 一つの文の中の並び。呼び名が二つ以上で、違う呼び名を並べたものだけ。 */
+const listingsIn = (text: BodyText, words: ListingWords): PartyListing[] => {
+  const found: PartyListing[] = [];
+  let at = 0;
+  while (at < text.text.length) {
+    const first = WORD_CHAR.test(text.text.charAt(at - 1)) ? undefined : longestAt(text.text, at, words.labels);
+    const listing = first === undefined ? undefined : listingAt(text, at, first, words);
+    if (listing !== undefined && new Set(listing.labels).size > 1) found.push(listing);
+    at = listing !== undefined && listing.labels.length > 1 ? listing.end - text.start : at + 1;
+  }
+  return found;
+};
+
+export const partyListings = (texts: readonly BodyText[], words: ListingWords): PartyListing[] => texts.flatMap((text) => listingsIn(text, words));
+
+const pairsOf = (labels: readonly string[]): [string, string][] =>
+  labels.flatMap((first, index) => labels.slice(index + 1).flatMap((second): [string, string][] => (second === first ? [] : [[first, second]])));
+
+const keyOf = (left: string, right: string): string => `${left}\u0000${right}`;
+
+const byPair = (listings: readonly PartyListing[]): Map<string, PartyListing[]> => {
+  const pairs = new Map<string, PartyListing[]>();
+  listings.forEach((listing) =>
+    new Set(pairsOf(listing.labels).map(([first, second]) => keyOf(first, second))).forEach((key) => pairs.set(key, [...(pairs.get(key) ?? []), listing])),
+  );
+  return pairs;
+};
+
+/**
+ * 文書がふだん書く順と逆に並べた所。ふだんの順は、同じ二つの呼び名を並べた所の多い方で、逆の順の minRatio 倍以上あるときだけ
+ * 決まる（同じ数なら、どちらとも言えないので指さない）。
+ */
+export const reversedListings = (listings: readonly PartyListing[], minRatio: number): OrderSlip[] => {
+  const pairs = byPair(listings);
+  return listings.flatMap((listing) => {
+    const slips = pairsOf(listing.labels).flatMap(([first, second]): OrderSlip[] => {
+      const reverse = pairs.get(keyOf(first, second)) ?? [];
+      const usual = pairs.get(keyOf(second, first)) ?? [];
+      const example = usual[0];
+      return example === undefined || usual.length < minRatio * reverse.length
+        ? []
+        : [{ listing, usual: example, usualCount: usual.length, reverseCount: reverse.length }];
+    });
+    return slips.slice(0, 1);
+  });
+};