chaffjs 0.29.0 → 0.31.0

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);
+};
+
+export const isRange = (source: string, start: DatedSpan, end: DatedSpan, words: RangeWords, isLabelled: (offset: number) => boolean): boolean => {
   const written = jointOf(source, start, end);
   if (written === undefined) return false;
   const joint = withoutTrailingWeekday(written, words.weekdays ?? []);
   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/deadline-after-event.ts

@@ -0,0 +1,67 @@
+import { mentions } from "./date-outside-period.ts";
+import type { DatedPoint } from "./due-date.ts";
+import type { StructureIssue } from "./issues.ts";
+import { lineNumberAt, linesOf, type Line } from "./lines.ts";
+import { isTotalLabel } from "./total.ts";
+
+/**
+ * 催しの後の申込締切。催しの日の語で始まり時刻のある一行（日時：2026年11月20日（金）14:00〜）が催しの日を書き、
+ * 申込の語（申込、RSVP）と締め切りの語（までに、by）のある文か行の、年のある日付がどの催しの日よりも後なら指す。
+ * 時刻を求めるのは、手紙の頭の「Date: …」を催しの日と読まないため。催しの後に来てよいもの（アンケート、支払）の語が同じ文にあれば比べない。
+ * 文か行に日付が二つ以上あれば、どれが締め切りか分からないので比べない。Pure.
+ */
+export type EventDeadlineWords = {
+  readonly events: readonly string[];
+  readonly registrations: readonly string[];
+  readonly deadlines: readonly string[];
+  readonly asides: readonly string[];
+};
+
+type Span = { readonly start: number; readonly end: number };
+
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
+const CLOCK_TIME = /(?<!\d)\d{1,2}[:：]\d{2}(?!\d)/u;
+
+/** 年月日（2026-11-20）の並びでいちばん後のもの。字の順が日付の順になる。 */
+const latestOf = (values: readonly string[]): string | undefined =>
+  values.reduce<string | undefined>((latest, value) => (latest === undefined || value > latest ? value : latest), undefined);
+
+const endOf = (line: Line): number => line.start + line.text.length;
+
+const datesIn = (dates: readonly DatedPoint[], span: Span): DatedPoint[] => dates.filter((date) => date.offset >= span.start && date.offset < span.end);
+
+/** 催しの日: 催しの日の語で始まり、時刻と年のある日付を書いた行の、いちばん後の日付。 */
+const eventDayOf = (line: Line, dates: readonly DatedPoint[], words: EventDeadlineWords): string | undefined => {
+  if (!isTotalLabel(line.text, words.events) || !CLOCK_TIME.test(line.text)) return undefined;
+  const values = datesIn(dates, { start: line.start, end: endOf(line) }).map((date) => date.value);
+  return latestOf(values.filter((value) => FULL_DATE.test(value)));
+};
+
+/** 日付を囲む文を、その行の中に切ったもの。文が見つからなければ行。 */
+const unitOf = (offset: number, line: Line, sentences: readonly Span[]): Span => {
+  const sentence = sentences.find((span) => span.start <= offset && offset < span.end);
+  return { start: Math.max(sentence?.start ?? line.start, line.start), end: Math.min(sentence?.end ?? endOf(line), endOf(line)) };
+};
+
+/** 申込の締め切りを書いた文か: 申込の語と締め切りの語があり、催しの後に来てよいものの語が無い。 */
+export const isRegistrationDeadline = (text: string, words: EventDeadlineWords): boolean =>
+  mentions(text, words.registrations) && mentions(text, words.deadlines) && !mentions(text, words.asides);
+
+type Reading = { readonly source: string; readonly lines: readonly Line[]; readonly dates: readonly DatedPoint[]; readonly sentences: readonly Span[] };
+
+const lateDeadlines = (reading: Reading, words: EventDeadlineWords, event: string): StructureIssue[] =>
+  reading.dates.flatMap((date) => {
+    if (!FULL_DATE.test(date.value) || date.value <= event) return [];
+    const line = reading.lines[(lineNumberAt(reading.lines, date.offset) ?? 0) - 1];
+    if (line === undefined) return [];
+    const unit = unitOf(date.offset, line, reading.sentences);
+    if (datesIn(reading.dates, unit).length > 1 || !isRegistrationDeadline(reading.source.slice(unit.start, unit.end), words)) return [];
+    return [{ offset: date.offset, values: { deadline: date.value, event } }];
+  });
+
+export const deadlinesAfterEvent = (source: string, dates: readonly DatedPoint[], sentences: readonly Span[], words: EventDeadlineWords): StructureIssue[] => {
+  if (words.events.length === 0 || words.registrations.length === 0 || words.deadlines.length === 0) return [];
+  const lines = linesOf(source);
+  const event = latestOf(lines.flatMap((line) => eventDayOf(line, dates, words) ?? []));
+  return event === undefined ? [] : lateDeadlines({ source, lines, dates, sentences }, words, event);
+};

package/src/structure/definition-use.ts

@@ -148,6 +148,58 @@ const continuesInHan = (texts: readonly BodyText[], term: string, offset: number
   return body !== undefined && HAN.test(term.at(-1) ?? "") && HAN.test(body.text.charAt(offset - body.start + term.length));
 };
 
+/** 半角の長音・濁点・中黒（ｰ ﾞ ﾟ ･）は Katakana の字ではないが、片仮名の名前の一部。 */
+const KATAKANA = /[\p{Script=Katakana}ーｰﾞﾟ]/u;
+const NAKAGURO = /[・･]/u;
+
+/** 語の外側の隣の字（next）とその向こうの字（beyond）が、片仮名か「・片仮名」か。 */
+const katakanaJoins = (next: string, beyond: string): boolean => KATAKANA.test(next) || (NAKAGURO.test(next) && KATAKANA.test(beyond));
+
+/**
+ * 片仮名の端に片仮名が続く現れ、または「・」で片仮名とつないだ現れは、もっと長い名前の一部
+ * （クリエイティブ・コモンズ・パブリック・ライセンスのパブリック・ライセンス、サブライセンスのライセンス）。
+ */
+const insideKatakanaName = (texts: readonly BodyText[], term: string, offset: number): boolean => {
+  const body = sentenceAt(texts, offset);
+  if (body === undefined) return false;
+  const at = offset - body.start;
+  const end = at + term.length;
+  const joinedBefore = at > 0 && katakanaJoins(body.text.charAt(at - 1), at > 1 ? body.text.charAt(at - 2) : "");
+  const joinedAfter = katakanaJoins(body.text.charAt(end), body.text.charAt(end + 1));
+  return (KATAKANA.test(term.charAt(0)) && joinedBefore) || (KATAKANA.test(term.at(-1) ?? "") && joinedAfter);
+};
+
+/** 長い名前の写しと読むのに、語の前で定義の名前と重ならなければならない字の数（手引き の前の「の」と「成」）。 */
+const MIN_ECHO = 2;
+const OPENING_BRACKET = /[\s（(]/u;
+
+/** 定義の括弧を開けた字（（、空白）を後ろから外した、括弧の前の名前。 */
+const nameBefore = (text: string): string => {
+  let end = text.length;
+  while (end > 0 && OPENING_BRACKET.test(text.charAt(end - 1))) end -= 1;
+  return text.slice(0, end);
+};
+
+/** 二つの文字列が後ろから何字重なるか。 */
+const sharedTail = (left: string, right: string): number => {
+  let shared = 0;
+  while (shared < left.length && shared < right.length && left.at(-1 - shared) === right.at(-1 - shared)) shared += 1;
+  return shared;
+};
+
+/**
+ * 定義の括弧の前に書いた長い名前（…ガイドライン作成の手引き（以下、「手引き」という。））を、定義より前でそのまま書いた所。
+ * 名前が語で終わり、語の前の字も名前と同じなら、それは長い名前で、定義した短い名前の使用ではない。
+ */
+const echoesLongName = (texts: readonly BodyText[], defined: DefinedTerm, offset: number): boolean => {
+  const defining = sentenceAt(texts, defined.span.start);
+  const using = sentenceAt(texts, offset);
+  if (defining === undefined || using === undefined) return false;
+  const name = nameBefore(defining.text.slice(0, defined.span.start - defining.start));
+  const written = using.text.slice(0, offset - using.start + defined.term.length);
+  return name.endsWith(defined.term) && sharedTail(name, written) >= defined.term.length + MIN_ECHO;
+};
+
 const CAPITAL_OR_NON_LATIN = /\p{Lu}|[^\p{Script=Latin}\p{N}\s\p{P}]/u;
 
 /**
@@ -159,7 +211,7 @@ const isDistinctive = (term: string): boolean => CAPITAL_OR_NON_LATIN.test(term)
 /**
  * 文の途中で括弧に入れて定義した語（(the "Seller")、以下「甲」という）を、その定義の文より前で使っている所。最初の一つだけ。
  * 定義の文の中の現れ（株式会社GovTech東京（以下「GovTech東京」という。））は、定義する名前そのものなので数えない。札の文も、
- * isTitle が言う題・見出しの行も、漢字で終わる語にさらに漢字が続く長い語の一部も数えない。
+ * isTitle が言う題・見出しの行も、漢字で終わる語にさらに漢字が続く長い語の一部も、定義の括弧の前の長い名前を写した所も数えない。
  * 定義の条（"Seller" means、「甲」とは）は条の並びの頭にも終わりにも置く書き方があるので、前で使っても言わない。
  * 定義の語の無い括弧の引用（("The key point is")）は例の引用と同じ形なので、その語を引用符で挙げただけの現れ
  * （Its sentences open with "The key point is"）は使用ではない。定義の語のある定義（(the "Seller")、以下「買主」という）は、
@@ -177,7 +229,12 @@ export const usesBeforeDefinition = (
       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) && !isTitle(offset) && !continuesInHan(texts, defined.term, offset),
+        (offset) =>
+          !isLabel(sentenceAt(texts, offset), defined.term) &&
+          !isTitle(offset) &&
+          !continuesInHan(texts, defined.term, offset) &&
+          !insideKatakanaName(texts, defined.term, offset) &&
+          !echoesLongName(texts, defined, offset),
       );
       return first !== undefined && first < defining ? [{ term: defined, offset: first }] : [];
     });

package/src/structure/due-date.ts

@@ -1,6 +1,5 @@
+import { datesOutOfOrder } from "./labelled-date-order.ts";
 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
@@ -10,37 +9,14 @@ import { isTotalLabel } from "./total.ts";
  */
 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 }];
-  });
+/** 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;
 
-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 } }));
-};
+export const dueBeforeIssue = (source: string, dates: readonly DatedPoint[], words: DueWords): StructureIssue[] =>
+  datesOutOfOrder(source, dates, { earlier: words.issue, later: words.due, passed: words.passed, maxLineGap: MAX_LINE_GAP }).map(({ earlier, later }) => ({
+    offset: later.date.offset,
+    values: { due: later.date.value, issued: earlier.date.value },
+  }));

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

@@ -0,0 +1,84 @@
+import type { DatedPoint } from "./due-date.ts";
+import type { StructureIssue } from "./issues.ts";
+import { linesOf } from "./lines.ts";
+import { isTotalLabel } from "./total.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.
+ */
+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;
+};
+
+/** 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 };
+
+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 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 };
+};
+
+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 }));
+};
+
+/** 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 groupsOf = (labels: readonly OrderLabel[]): string[] => [...new Set(labels.flatMap((label) => (label.group === undefined ? [] : [label.group])))];
+
+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 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.
+ */
+export const pairedDatesOutOfOrder = (
+  source: string,
+  dates: readonly DatedPoint[],
+  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 },
+      }),
+    ),
+  );

package/src/structure/layout-codes.ts

@@ -0,0 +1,210 @@
+// layout-code-mismatch: a layout code (2LDK, "2 bedrooms") against the rooms a listing names. Pure: the words come in as
+// LayoutWords (the layout-code and layout-room lexicons), the text as strings.
+
+export type LayoutPart = "living" | "dining" | "kitchen";
+export type LetterGroup = LayoutPart | "storage" | "one-room";
+export type RoomGroup = LayoutPart | "room" | "storage" | "unclear";
+
+export type LayoutWords = {
+  /** One-letter marks written right after the number (L, D, K, S, R). */
+  readonly letters: ReadonlyMap<string, LetterGroup>;
+  /** Marks that add a room not counted (2LDK+S). */
+  readonly joiners: readonly string[];
+  /** Words after the number that say what it counts ("bedrooms", "BR"). */
+  readonly counted: readonly string[];
+  readonly rooms: readonly { readonly pattern: string; readonly group: RoomGroup }[];
+  /** Words after a number that make it a count of rooms (洋室2室): an entry with one is not read as one room. */
+  readonly counters: readonly string[];
+};
+
+export type LayoutCode = {
+  readonly text: string;
+  /** Where the code starts and ends in the text it was read from. */
+  readonly start: number;
+  readonly end: number;
+  readonly rooms: number;
+  /** The L, D and K a lettered code has. Undefined for a code that says nothing about them ("2 bedrooms", 1R). */
+  readonly parts: ReadonlySet<LayoutPart> | undefined;
+};
+
+export type Breakdown = {
+  readonly rooms: number;
+  /** Each L, D or K part the breakdown names, with the entry that names it. */
+  readonly parts: ReadonlyMap<LayoutPart, string>;
+  /** An entry that is a room in some listings and not in others, or names two kinds at once. */
+  readonly unclear: boolean;
+};
+
+export type LayoutSlip =
+  { readonly kind: "count"; readonly code: LayoutCode; readonly listed: number } | { readonly kind: "part"; readonly code: LayoutCode; readonly entry: string };
+
+const FULLWIDTH_OFFSET = 0xfee0;
+const FULLWIDTH_FIRST = 0xff01;
+const FULLWIDTH_LAST = 0xff5e;
+
+/** Full-width ASCII (２ＬＤＫ) as ASCII, one character for one, so offsets stay those of the source. */
+export const foldWidth = (text: string): string =>
+  text.replace(/[！-～]/gu, (char) => {
+    const code = char.charCodeAt(0);
+    return code >= FULLWIDTH_FIRST && code <= FULLWIDTH_LAST ? String.fromCharCode(code - FULLWIDTH_OFFSET) : char;
+  });
+
+const DIGITS = /\d+/uy;
+const LATIN = /[a-z]/iu;
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+
+/** Whether text has pattern at index, and does not run on into a longer word when the pattern is Latin (2BR is a word after a number). */
+const wordAt = (text: string, index: number, pattern: string): boolean => {
+  if (text.slice(index, index + pattern.length).toLowerCase() !== pattern.toLowerCase()) return false;
+  if (!LATIN.test(pattern)) return true;
+  return !WORD_CHAR.test(text.charAt(index + pattern.length)) && !/\p{L}/u.test(text.charAt(index - 1));
+};
+
+/** The longest code letters run (3SLDK). A longer run is a word, not a code. */
+const MAX_CODE_LETTERS = 5;
+/** The most "+S" a code adds (2LDK+S+納戸). */
+const MAX_JOINS = 3;
+
+/** The run of code letters at index (LDK, SLDK), with what they say; empty when the run is longer than a code. */
+const lettersAt = (text: string, index: number, words: LayoutWords): LetterGroup[] => {
+  const head = Array.from(text.slice(index, index + MAX_CODE_LETTERS + 1));
+  const stop = head.findIndex((char) => !words.letters.has(char));
+  const length = stop === -1 ? head.length : stop;
+  if (length > MAX_CODE_LETTERS) return [];
+  return head.slice(0, length).flatMap((char) => words.letters.get(char) ?? []);
+};
+
+/** After a lettered code, each "+S" or "+納戸" that adds a room not counted: the index where they end. */
+const joinedEnd = (text: string, index: number, words: LayoutWords, joins = 0): number => {
+  const joiner = words.joiners.find((mark) => text.startsWith(mark, index));
+  if (joiner === undefined || joins === MAX_JOINS) return index;
+  const after = index + joiner.length;
+  const letter = words.letters.get(text.charAt(after)) === "storage" ? 1 : 0;
+  const word = words.rooms.find((room) => room.group === "storage" && wordAt(text, after, room.pattern))?.pattern.length ?? letter;
+  return word === 0 ? index : joinedEnd(text, after + word, words, joins + 1);
+};
+
+const letteredCode = (text: string, start: number, digitsEnd: number, words: LayoutWords): LayoutCode | undefined => {
+  const groups = lettersAt(text, digitsEnd, words);
+  const lettersEnd = digitsEnd + groups.length;
+  if (!groups.includes("kitchen") && !groups.includes("one-room")) return undefined;
+  if (LATIN.test(text.charAt(lettersEnd))) return undefined;
+  const end = joinedEnd(text, lettersEnd, words);
+  const parts = groups.includes("one-room") ? undefined : new Set(groups.filter((group): group is LayoutPart => group !== "storage"));
+  return { text: text.slice(start, end), start, end, rooms: Number(text.slice(start, digitsEnd)), parts };
+};
+
+const SPACER = /[ \-‐–]?/uy;
+
+const countedCode = (text: string, start: number, digitsEnd: number, words: LayoutWords): LayoutCode | undefined => {
+  SPACER.lastIndex = digitsEnd;
+  const after = digitsEnd + (SPACER.exec(text)?.[0].length ?? 0);
+  const word = words.counted.find((pattern) => wordAt(text, after, pattern));
+  if (word === undefined) return undefined;
+  const end = after + word.length;
+  return { text: text.slice(start, end), start, end, rooms: Number(text.slice(start, digitsEnd)), parts: undefined };
+};
+
+const codeAt = (text: string, start: number, words: LayoutWords): LayoutCode | undefined => {
+  if (/[\p{L}\p{N}.,]/u.test(text.charAt(start - 1))) return undefined;
+  DIGITS.lastIndex = start;
+  const digits = DIGITS.exec(text)?.[0];
+  if (digits === undefined) return undefined;
+  const digitsEnd = start + digits.length;
+  return letteredCode(text, start, digitsEnd, words) ?? countedCode(text, start, digitsEnd, words);
+};
+
+/**
+ * The one layout code a field value gives (2LDK, 3SLDK, 2LDK+S, "2 bedrooms", 2-bed, 2BR). A value with two codes of
+ * different counts ("2LDK or 3DK") gives none: which one the breakdown is for cannot be told.
+ */
+export const parseLayoutCode = (value: string, words: LayoutWords): LayoutCode | undefined => {
+  const text = foldWidth(value);
+  const codes = [...text.matchAll(/\d+/gu)].flatMap((match) => codeAt(text, match.index, words) ?? []);
+  const first = codes[0];
+  if (first === undefined || codes.some((code) => code.rooms !== first.rooms)) return undefined;
+  return { ...first, text: value.slice(first.start, first.end) };
+};
+
+const ENTRY_SEPARATOR = /[、，,・/／+＋;；\n]/u;
+const MULTIPLIER = /(?:[×✕]|(?<=[\s\d])[xX])\s*(\d+)\s*$/u;
+
+/** The kinds of room an entry names, by the room words in it; a lone run of code letters (LDK 12帖, S 4帖) by its letters. */
+const groupsOfEntry = (entry: string, words: LayoutWords): RoomGroup[] => {
+  const named = words.rooms.filter((room) => positions(entry).some((index) => wordAt(entry, index, room.pattern))).map((room) => room.group);
+  if (named.length > 0) return [...new Set(named)];
+  const letters = /^[A-Z]+(?![A-Za-z])/u.exec(entry)?.[0] ?? "";
+  const groups = [...letters].map((letter) => words.letters.get(letter));
+  if (letters === "" || groups.some((group) => group === undefined || group === "one-room")) return [];
+  return [...new Set(groups.flatMap((group): RoomGroup[] => (group === undefined || group === "one-room" ? [] : [group])))];
+};
+
+const positions = (entry: string): number[] => Array.from({ length: entry.length }, (_, index) => index);
+
+/** How many rooms an entry names in words (Bedroom 1 and Bedroom 2 names two). */
+const roomMentions = (entry: string, words: LayoutWords): number => {
+  const rooms = words.rooms.filter((room) => room.group === "room");
+  return positions(entry).filter((index) => rooms.some((room) => wordAt(entry, index, room.pattern))).length;
+};
+
+/** Whether the entry counts rooms with a number (洋室2室, 和室 2間). */
+const countsRooms = (entry: string, words: LayoutWords): boolean =>
+  [...entry.matchAll(/\d+\s*/gu)].some((match) => words.counters.some((counter) => entry.startsWith(counter, match.index + match[0].length)));
+
+const isPart = (group: RoomGroup): group is LayoutPart => group === "living" || group === "dining" || group === "kitchen";
+
+type Tally = { rooms: number; parts: Map<LayoutPart, string>; unclear: boolean };
+
+const tallyEntry = (tally: Tally, entry: string, words: LayoutWords): Tally => {
+  const groups = groupsOfEntry(entry, words);
+  const rooms = groups.includes("room");
+  const several = rooms && (groups.length > 1 || roomMentions(entry, words) > 1 || countsRooms(entry, words));
+  if (groups.includes("unclear") || several) return { ...tally, unclear: true };
+  const times = Number(MULTIPLIER.exec(entry)?.[1] ?? 1);
+  const parts = new Map(tally.parts);
+  groups.filter(isPart).forEach((part) => parts.set(part, parts.get(part) ?? entry));
+  return { rooms: tally.rooms + (rooms ? times : 0), parts, unclear: tally.unclear };
+};
+
+/** The rooms a breakdown names ("LDK 11.5帖、洋室 6帖、洋室 5帖", "Bedroom 1, Bedroom 2, Bathroom"). Entries it cannot name are left out. */
+export const parseBreakdown = (entries: readonly string[], words: LayoutWords): Breakdown =>
+  entries
+    .flatMap((entry) => foldWidth(entry).split(ENTRY_SEPARATOR))
+    .map((entry) => entry.trim())
+    .filter((entry) => entry !== "")
+    .reduce<Tally>((tally, entry) => tallyEntry(tally, entry, words), { rooms: 0, parts: new Map(), unclear: false });
+
+/**
+ * Where a code and the breakdown of the same listing disagree. Silent when the breakdown names no room (it may list only
+ * the LDK), or names one that is counted in some listings and not in others. A lettered code is also checked for an L, D or
+ * K part the breakdown names and the code lacks; a one-room code (1R) and a counted code ("2 bedrooms") are not.
+ */
+export const layoutSlip = (code: LayoutCode, breakdown: Breakdown): LayoutSlip | undefined => {
+  if (breakdown.unclear || breakdown.rooms === 0) return undefined;
+  if (breakdown.rooms !== code.rooms) return { kind: "count", code, listed: breakdown.rooms };
+  const parts = code.parts;
+  if (parts === undefined) return undefined;
+  const extra = [...breakdown.parts].find(([part]) => !parts.has(part));
+  return extra === undefined ? undefined : { kind: "part", code, entry: extra[1] };
+};
+
+/**
+ * The codes and breakdowns of one page, paired listing by listing: within one scope (a section), the first code with the
+ * first breakdown and so on, but only when the scope has as many of each. Any other count is several listings that cannot
+ * be told apart, and none is paired.
+ */
+export const pairByScope = <C extends { readonly scope: number }, B extends { readonly scope: number }>(
+  codes: readonly C[],
+  breakdowns: readonly B[],
+): [C, B][] => {
+  const scopes = [...new Set(codes.map((code) => code.scope))];
+  return scopes.flatMap((scope) => {
+    const inCodes = codes.filter((code) => code.scope === scope);
+    const inBreakdowns = breakdowns.filter((breakdown) => breakdown.scope === scope);
+    if (inCodes.length !== inBreakdowns.length) return [];
+    return inCodes.flatMap((code, index): [C, B][] => {
+      const breakdown = inBreakdowns[index];
+      return breakdown === undefined ? [] : [[code, breakdown]];
+    });
+  });
+};

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)]);
+};