chaffjs 0.31.0 → 0.33.0

package/src/company-names.ts

@@ -5,7 +5,16 @@ import { escapeRegExp } from "./orthography.ts";
 // 会社の形の語（株式会社、Inc）は語彙表 company-form が言う。group が同じ語は同じ形（Inc と Incorporated、株式会社 と (株)）、
 // position は名前のどちら側に立つか（無ければどちらにも立つ）。名前の部分は、形の語のすぐ隣の、名前に使う字の連なり。
 
-export type CompanyForm = { readonly pattern: string; readonly group: string; readonly position?: "before" | "after" | undefined };
+/**
+ * foreign は、カタカナか英字の名前のすぐ後ろにだけ立つ形の語（サウスベイ・インポート社 の 社）。漢字の語の中（会社、本社）では形の語でない。
+ * words はこの語で始まる語（社員、社長）で、そこでは形の語と読まない。
+ */
+export type CompanyForm = {
+  readonly pattern: string;
+  readonly group: string;
+  readonly position?: "before" | "after" | undefined;
+  readonly foreign?: { readonly words: readonly string[] } | undefined;
+};
 
 /** surface は形の語も含めた書いたまま。base は名前の部分、form は形の組、position は形の語が名前のどちら側にあるか。 */
 export type CompanyMention = {
@@ -14,6 +23,8 @@ export type CompanyMention = {
   readonly base: string;
   readonly form: string;
   readonly position: "before" | "after";
+  /** カタカナか英字の名前のすぐ後ろにだけ立つ形の語（社）で書いたもの。 */
+  readonly foreign?: boolean | undefined;
 };
 
 /** 二つの書き方の違い。spelling は記号・幅・大小だけ、form は会社の形、position は形の語の側、near は名前の一字違い。 */
@@ -26,7 +37,7 @@ export type IsProper = (start: number, end: number) => boolean;
 
 const LATIN = /\p{Script=Latin}/u;
 const LETTER = /\p{L}/u;
-/** 漢字・かなの名前に使う字。ひらがなは名前の外（の、は、まで）。 */
+/** 漢字・かなの名前に使う字。ひらがなは名前の頭にだけ立つ（kanaHeadOf）。 */
 const CJK_NAME = /[\p{Script=Katakana}\p{Script=Han}\p{Script=Latin}\p{N}ー・&＆]/u;
 const NOT_HAN_LETTER = /(?!\p{Script=Han})\p{L}/u;
 /** 英字の名前の一語。大文字か数字で始まる。 */
@@ -65,17 +76,69 @@ const CJK_BEFORE = new RegExp(`${CJK_NAME.source}+$`, "u");
 const CJK_AFTER = new RegExp(`^${CJK_NAME.source}+`, "u");
 const SPACES: ReadonlySet<string> = new Set([" ", "\u3000"]);
 
+/**
+ * 名前の頭のひらがなを切り分ける語（語彙表 company-name-kana）。particles は前の語に続けて書く語（は、と、における）、openers は
+ * 句読点や行の頭に立つ語（また、なお）、ends は名前の頭の終わりに来ない字（の、る、て）。
+ */
+export type KanaStops = { readonly particles: readonly string[]; readonly openers: readonly string[]; readonly ends: readonly string[] };
+
+/** ひらがなの前に何があるか。word は語や閉じ括弧（当社はこもれび、）により）、form は会社の形の語（株式会社こもれび）、boundary は句読点や行の頭。 */
+export type KanaLead = "word" | "form" | "boundary";
+
+const MIN_KANA_HEAD_LENGTH = 2;
+
+const longestPrefix = (text: string, words: readonly string[]): string | undefined =>
+  words.filter((word) => text.startsWith(word)).toSorted((left, right) => right.length - left.length)[0];
+
+/**
+ * 漢字やカタカナの名前のすぐ前のひらがなのうち、名前の頭と読む所（はこもれび の こもれび）。語のすぐ後ろなら助詞で始まるときだけ、
+ * その後ろを読む。形の語のすぐ後ろなら助詞で始まらないときだけ。二字以上で、句読点の後に立つ語で始まらず、助詞や動詞の終わりの字で終わらないもの。
+ * 語彙表が無ければ（英語の文書）ひらがなは名前に入れない。
+ */
+export const kanaHeadOf = (kana: string, lead: KanaLead, stops: KanaStops): string | undefined => {
+  if (stops.particles.length === 0) return undefined;
+  const particle = longestPrefix(kana, stops.particles);
+  if ((lead === "word" && particle === undefined) || (lead === "form" && particle !== undefined)) return undefined;
+  const head = lead === "word" ? kana.slice(particle?.length ?? 0) : kana;
+  if ([...head].length < MIN_KANA_HEAD_LENGTH || longestPrefix(head, stops.openers) !== undefined) return undefined;
+  return stops.ends.some((end) => head.endsWith(end)) ? undefined : head;
+};
+
+/** ひらがなをその前の語に続けて読む字。閉じ括弧や数字の後ろのひらがなも助詞（）により、第3条の）。 */
+const GLUED = /[\p{L}\p{N}\p{Pe}\p{Pf}]/u;
+const HIRAGANA = /\p{Script=Hiragana}/u;
+const KANA_AFTER = /^\p{Script=Hiragana}+/u;
+
+/** end の前に続くひらがなの始まり。 */
+const kanaRunStart = (source: string, end: number): number => {
+  let start = end;
+  while (start > 0 && HIRAGANA.test(source.charAt(start - 1))) start -= 1;
+  return start;
+};
+
+/** 名前の前に続くひらがなのうち、名前の頭と読む所を足した始まり。 */
+const withKanaHead = (source: string, start: number, stops: KanaStops): number => {
+  const kanaStart = kanaRunStart(source, start);
+  if (kanaStart === start) return start;
+  const lead = GLUED.test(source.charAt(kanaStart - 1)) ? "word" : "boundary";
+  return start - (kanaHeadOf(source.slice(kanaStart, start), lead, stops)?.length ?? 0);
+};
+
 /** 漢字・かなの名前: 形の語の隣の、名前に使う字の続き。形の語との間の空白一つは名前の外。 */
-const cjkBaseBefore = (source: string, end: number): Span | undefined => {
+const cjkBaseBefore = (source: string, end: number, stops: KanaStops): Span | undefined => {
   const stop = SPACES.has(source.charAt(end - 1)) ? end - 1 : end;
   const match = CJK_BEFORE.exec(source.slice(0, stop));
-  return match === null ? undefined : { start: match.index, end: stop };
+  return match === null ? undefined : { start: withKanaHead(source, match.index, stops), end: stop };
 };
 
-const cjkBaseAfter = (source: string, start: number): Span | undefined => {
+/** 形の語の後ろの名前。ひらがなで始まる名前（株式会社こもれび珈琲）は、ひらがなの後ろに名前に使う字が続くときだけ。 */
+const cjkBaseAfter = (source: string, start: number, stops: KanaStops): Span | undefined => {
   const from = SPACES.has(source.charAt(start)) ? start + 1 : start;
-  const match = CJK_AFTER.exec(source.slice(from));
-  return match === null ? undefined : { start: from, end: from + match[0].length };
+  const kana = KANA_AFTER.exec(source.slice(from))?.[0] ?? "";
+  const head = kana === "" ? "" : kanaHeadOf(kana, "form", stops);
+  if (head === undefined) return undefined;
+  const match = CJK_AFTER.exec(source.slice(from + head.length));
+  return match === null ? undefined : { start: from, end: from + head.length + match[0].length };
 };
 
 /** 名前の部分の字数。一字（法令の項目の印 イ、ロ）は名前と読まない。 */
@@ -94,22 +157,50 @@ const mentionOf = (source: string, base: Span, form: Span, group: string): Compa
   return { surface: source.slice(start, end), offset: start, base: source.slice(base.start, base.end), form: group, position };
 };
 
-const baseBefore = (source: string, at: number, latin: boolean, isProper: IsProper): Span | undefined =>
-  latin ? latinBaseBefore(source, at, isProper) : cjkBaseBefore(source, at);
+/** カタカナか英字の名前の字。英字の語の間の空白一つも名前の内。 */
+const FOREIGN_CHAR = /[\p{Script=Katakana}\p{Script=Latin}\p{N}ー・&＆'’.\- ]/u;
+/** 形の語のすぐ前の字。カタカナ・長音の印・英字のときだけ、形の語と読む（会社、本社、神社の 社 は読まない）。 */
+const FOREIGN_END = /(?:[\p{Script=Katakana}ー\p{Script=Latin}]|\p{Script=Latin}\.)$/u;
+/** 名前の頭に立たない字（空白、記号、数字だけの頭はそのまま残す）。 */
+const FOREIGN_LEAD = /^[\s・&＆'’.-]+/u;
+/** カタカナの語に一字の記号を付けた仮の名前（ベンダーA、メーカーB）。名前ではないので、A と B を一字違いと見ない。 */
+const PLACEHOLDER = /[\p{Script=Katakana}ー]\s?[\p{Lu}\p{N}]$/u;
+
+/** text の終わりに続く、カタカナか英字の名前の字の始まり。 */
+const foreignRunStart = (text: string): number => {
+  let start = text.length;
+  while (start > 0 && FOREIGN_CHAR.test(text.charAt(start - 1))) start -= 1;
+  return start;
+};
+
+/** カタカナか英字の名前のすぐ後ろの形の語（サウスベイ・インポート社、Marlow Bay社）。形の語で始まる漢字の語（社員、社長）は外す。 */
+const foreignMentionAt = (source: string, form: CompanyForm, at: number, words: readonly string[]): CompanyMention | undefined => {
+  const before = source.slice(0, at);
+  if (!FOREIGN_END.test(before) || words.some((word) => source.startsWith(word, at))) return undefined;
+  const run = before.slice(foreignRunStart(before));
+  const start = at - run.length + (FOREIGN_LEAD.exec(run)?.[0].length ?? 0);
+  const base = { start, end: at };
+  if (!isNameBase(source, base, () => false) || PLACEHOLDER.test(source.slice(start, at))) return undefined;
+  return { ...mentionOf(source, base, { start: at, end: at + form.pattern.length }, form.group), foreign: true };
+};
+
+const baseBefore = (source: string, at: number, latin: boolean, isProper: IsProper, stops: KanaStops): Span | undefined =>
+  latin ? latinBaseBefore(source, at, isProper) : cjkBaseBefore(source, at, stops);
 
 /** 形の語の一つの現れから、会社の名前の現れ。名前が前にあればそれを、無ければ後ろを取る。 */
-const mentionAt = (source: string, form: CompanyForm, at: number, isProper: IsProper): CompanyMention | undefined => {
+const mentionAt = (source: string, form: CompanyForm, at: number, isProper: IsProper, stops: KanaStops): CompanyMention | undefined => {
+  if (form.foreign !== undefined) return foreignMentionAt(source, form, at, form.foreign.words);
   const formSpan = { start: at, end: at + form.pattern.length };
   const latin = LATIN.test(form.pattern);
   if (latin && CONTINUED.test(source.slice(formSpan.end))) return undefined;
-  const before = form.position === "before" ? undefined : baseBefore(source, at, latin, isProper);
+  const before = form.position === "before" ? undefined : baseBefore(source, at, latin, isProper, stops);
   if (before !== undefined && isNameBase(source, before, isProper)) return mentionOf(source, before, formSpan, form.group);
-  const after = form.position === "after" || latin ? undefined : cjkBaseAfter(source, formSpan.end);
+  const after = form.position === "after" || latin ? undefined : cjkBaseAfter(source, formSpan.end, stops);
   return after !== undefined && isNameBase(source, after, isProper) ? mentionOf(source, after, formSpan, form.group) : undefined;
 };
 
 /** 文書の中の会社の名前の現れ。長い形の語（Co., Ltd）を先に取り、その中の短い語（Ltd）は数えない。 */
-export const companyMentionsIn = (source: string, forms: readonly CompanyForm[], isProper: IsProper): CompanyMention[] => {
+export const companyMentionsIn = (source: string, forms: readonly CompanyForm[], isProper: IsProper, stops: KanaStops): CompanyMention[] => {
   const taken: Span[] = [];
   return forms
     .toSorted((left, right) => right.pattern.length - left.pattern.length)
@@ -118,7 +209,7 @@ export const companyMentionsIn = (source: string, forms: readonly CompanyForm[],
         const end = at + form.pattern.length;
         if (!standsAsWord(source, form.pattern, at) || taken.some((span) => span.start < end && at < span.end)) return [];
         taken.push({ start: at, end });
-        const mention = mentionAt(source, form, at, isProper);
+        const mention = mentionAt(source, form, at, isProper, stops);
         return mention === undefined ? [] : [mention];
       }),
     )
@@ -130,23 +221,30 @@ const MIN_SLIP_LENGTH = 7;
 const spliced = (chars: readonly string[], at: number, count: number): string => chars.toSpliced(at, count).join("");
 const firstDifference = (left: readonly string[], right: readonly string[]): number => left.findIndex((char, index) => char !== right[index]);
 
+/** 一字違いの、違う字（changed）と、それが立つ名前の字（chars）の何字目か（at）。 */
+type Change = { readonly changed: readonly string[]; readonly chars: readonly string[]; readonly at: number };
+
 /** 一字の抜けなら、その字。 */
-const droppedChars = (longer: readonly string[], shorter: readonly string[]): string[] | undefined => {
+const droppedChars = (longer: readonly string[], shorter: readonly string[]): Change | undefined => {
   if (longer.length !== shorter.length + 1) return undefined;
   const at = firstDifference(longer, shorter);
-  return spliced(longer, at, 1) === shorter.join("") ? [longer[at] ?? ""] : undefined;
+  return spliced(longer, at, 1) === shorter.join("") ? { changed: [longer[at] ?? ""], chars: longer, at } : undefined;
 };
 
 /** 一字の置き換えか、隣どうしの入れ替えなら、その字。 */
-const replacedChars = (left: readonly string[], right: readonly string[]): string[] | undefined => {
+const replacedChars = (left: readonly string[], right: readonly string[]): Change | undefined => {
   const at = firstDifference(left, right);
-  const changed = [left[at] ?? "", right[at] ?? ""];
+  const change = { changed: [left[at] ?? "", right[at] ?? ""], chars: left, at };
   if (left.length !== right.length || at < 0) return undefined;
-  if (spliced(left, at, 1) === spliced(right, at, 1)) return changed;
+  if (spliced(left, at, 1) === spliced(right, at, 1)) return change;
   const swapped = left[at] === right[at + 1] && left[at + 1] === right[at] && spliced(left, at, 2) === spliced(right, at, 2);
-  return swapped ? changed : undefined;
+  return swapped ? change : undefined;
 };
 
+/** 名前の部分の一字違い（置き換え・抜け・隣どうしの入れ替え）。 */
+const changeBetween = (leftChars: readonly string[], rightChars: readonly string[]): Change | undefined =>
+  replacedChars(leftChars, rightChars) ?? droppedChars(leftChars, rightChars) ?? droppedChars(rightChars, leftChars);
+
 /**
  * 名前の部分が一字違いか（置き換え・抜け・隣どうしの入れ替え）。違う字が漢字なら見ない。漢字の一字違い（日本電気 と 日本電機）
  * は別の会社のことがある。短い名前（Alpha と Alpho）も別の会社のことが多い。
@@ -154,13 +252,40 @@ const replacedChars = (left: readonly string[], right: readonly string[]): strin
 const isSlip = (left: string, right: string): boolean => {
   const [leftChars, rightChars] = [[...left], [...right]];
   if (Math.min(leftChars.length, rightChars.length) < MIN_SLIP_LENGTH) return false;
-  const changed = replacedChars(leftChars, rightChars) ?? droppedChars(leftChars, rightChars) ?? droppedChars(rightChars, leftChars);
-  return changed !== undefined && changed.every((char) => NOT_HAN_LETTER.test(char));
+  const change = changeBetween(leftChars, rightChars);
+  return change !== undefined && change.changed.every((char) => NOT_HAN_LETTER.test(char));
+};
+
+const HAN = /\p{Script=Han}/u;
+const KANA = /^[\p{Script=Hiragana}\p{Script=Katakana}ー]$/u;
+/** 漢字を含む短い名前で、一字違いを見るかなの語の字数。三字のかなの語（サンワ と サンヨ）は別の会社のことがある。 */
+const MIN_KANA_WORD_LENGTH = 4;
+
+/** at の字を含む、かなの続きの字数。 */
+const kanaRunLength = (chars: readonly string[], at: number): number => {
+  const isKanaAt = (index: number): boolean => KANA.test(chars[index] ?? "");
+  if (!isKanaAt(at)) return 0;
+  const start = chars.findLastIndex((_char, index) => index < at && !isKanaAt(index)) + 1;
+  const end = chars.findIndex((_char, index) => index > at && !isKanaAt(index));
+  return (end < 0 ? chars.length : end) - start;
 };
 
-/** 名前の部分が同じ二つ。同じ形の短い書き方と長い書き方（株式会社 と (株)、Inc と Incorporated）は書き分けと見ない。 */
+/**
+ * 漢字を含む名前の、四字以上のかなの語の中の、かな一字違い（コモレビ電機 と コモレピ電機）。漢字の部分が同じなので、七字に
+ * 満たない名前でも見る。漢字の一字違い（日本電気 と 日本電機）は見ない。
+ */
+export const isKanaWordSlip = (left: string, right: string): boolean => {
+  if (!HAN.test(left) || !HAN.test(right)) return false;
+  const change = changeBetween([...left], [...right]);
+  return change !== undefined && change.changed.every((char) => KANA.test(char)) && kanaRunLength(change.chars, change.at) >= MIN_KANA_WORD_LENGTH;
+};
+
+/**
+ * 名前の部分が同じ二つ。同じ形の短い書き方と長い書き方（株式会社 と (株)、Inc と Incorporated）は書き分けと見ない。社で呼ぶ書き方
+ * （アップル社 と アップル株式会社）は正式の名前を略した呼び方なので、ほかの形の語と比べない。
+ */
 const sameNameRelation = (left: CompanyMention, right: CompanyMention): CompanyRelation | undefined => {
-  if (left.form !== right.form) return "form";
+  if (left.form !== right.form) return left.foreign === true || right.foreign === true ? undefined : "form";
   if (left.position !== right.position) return "position";
   return nameKey(left.surface) === nameKey(right.surface) ? "spelling" : undefined;
 };
@@ -191,12 +316,20 @@ const talliesOf = (mentions: readonly CompanyMention[]): Tally[] => {
 /** 多いほうが先。同数なら先に書いたほう。 */
 const byUsage = (left: Tally, right: Tally): number => right.count - left.count || left.first.offset - right.first.offset;
 
+/** 短い名前のかなの一字違いは、別の会社のこともあるので、相手が二度以上、こちらが一度だけのときに限る。 */
+const relationBetween = (tally: Tally, other: Tally): CompanyRelation | undefined => {
+  const relation = companyRelation(tally.first, other.first);
+  if (relation !== undefined || tally.count !== 1 || other.count < 2) return relation;
+  const [left, right] = [tally.first, other.first];
+  return left.form === right.form && left.position === right.position && isKanaWordSlip(nameKey(left.base), nameKey(right.base)) ? "near" : undefined;
+};
+
 /** 同じ会社の、少ないほうの書き方。同じ会社と言える相手のうち一番多いものと比べる。書き方ごとに最初の現れを一つ。 */
 export const companyVariants = (mentions: readonly CompanyMention[]): CompanyVariant[] => {
   const tallies = talliesOf(mentions);
   return tallies.flatMap((tally) => {
-    const [usual] = tallies.filter((other) => other === tally || companyRelation(tally.first, other.first) !== undefined).toSorted(byUsage);
-    const kind = usual === undefined || usual === tally ? undefined : companyRelation(tally.first, usual.first);
+    const [usual] = tallies.filter((other) => other === tally || relationBetween(tally, other) !== undefined).toSorted(byUsage);
+    const kind = usual === undefined || usual === tally ? undefined : relationBetween(tally, usual);
     return usual === undefined || kind === undefined ? [] : [{ mention: tally.first, usual: usual.first.surface, kind }];
   });
 };

package/src/contacts/table-rows.ts

@@ -0,0 +1,51 @@
+// A two-column table row named by an address label (| 物件所在地 | 東京都… |, | Address | 12 Elm Street … |) read as the
+// line `物件所在地 東京都…` the contact readers read: the prose masks tables, so the row's name is written back right before
+// its value, at the row's own offsets. Only a table of two columns: a wider table's rows name whose address it is in
+// another cell, and a list of shops or venues would compare neighbours. Pure.
+import type { LexiconEntry } from "../plugin.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf } from "../structure/lines.ts";
+
+const TWO_COLUMNS = 2;
+const LETTER = /\p{L}/u;
+const LATIN_START = /^[A-Za-z]/u;
+
+/** Whether a row's name ends with a label: 物件所在地 with 所在地, Property address with address (a Latin label as a whole word). */
+const endsWithLabel = (name: string, label: string): boolean => {
+  const lowered = name.toLowerCase();
+  const pattern = label.toLowerCase();
+  if (!lowered.endsWith(pattern)) return false;
+  return !LATIN_START.test(label) || !LETTER.test(lowered.charAt(lowered.length - pattern.length - 1));
+};
+
+type LabelledRow = { readonly name: string; readonly nameEnd: number; readonly value: Cell };
+
+const labelledRow = (cells: readonly Cell[], labels: readonly LexiconEntry[]): LabelledRow[] => {
+  const [first, value] = cells;
+  if (cells.length !== TWO_COLUMNS || first === undefined || value === undefined) return [];
+  const name = withoutEdgeMarks(first.text);
+  return labels.some((entry) => endsWithLabel(name, entry.pattern)) ? [{ name, nameEnd: first.end, value }] : [];
+};
+
+/** The two-column rows of a text's tables whose first cell names an address. */
+const labelledRows = (tables: string, labels: readonly LexiconEntry[]): LabelledRow[] =>
+  tablesOf(linesOf(tables))
+    .filter((table) => cellsOf(table.header).length === TWO_COLUMNS)
+    .flatMap((table) => table.rows.flatMap((row) => labelledRow(cellsOf(row), labels)));
+
+/**
+ * The prose with each labelled two-column row of `tables` (the same text with its tables shown) written back as its name
+ * then its value. The name ends where its cell ends, so it stays inside the row's span. Offsets are kept.
+ */
+export const proseWithLabelledRows = (prose: string, tables: string, labels: readonly LexiconEntry[]): string => {
+  const pieces: string[] = [];
+  const end = labelledRows(tables, labels).reduce((from, row) => {
+    const nameStart = row.nameEnd - row.name.length;
+    if (nameStart < from) return from;
+    pieces.push(prose.slice(from, nameStart), row.name, prose.slice(row.nameEnd, row.value.start), row.value.text);
+    return row.value.end;
+  }, 0);
+  pieces.push(prose.slice(end));
+  return pieces.join("");
+};

package/src/cross-run.ts

@@ -40,6 +40,7 @@ const optionsFor = (input: CrossInput, rule: RuleDefinition): DetectorOptions =>
   lexicon: rule.word_list === undefined ? undefined : input.doc.lexicons[rule.word_list],
   where: rule.where,
   ...(rule.options === undefined ? {} : { settings: optionValues(settleOptions(rule.id, rule.options, input.context.optionLayers ?? [])) }),
+  genre: input.context.genre,
 });
 
 /** What one rule did to the documents taking part (by path): its findings, or why it did not run after all. */

package/src/derived/age-on-date.ts

@@ -0,0 +1,161 @@
+import type { Span } from "../plugin.ts";
+import { calendarDateOf } from "./date-arithmetic.ts";
+
+/**
+ * 生年月日のラベルの付いた日付と同じ行の年齢（「生年月日：1978年4月12日（受診時 48歳）」）を、ラベルの付いた日（受診日、報告日、
+ * Examination date）の満年齢と比べる。年齢の印（受診時）があれば、その印と同じ group のラベルの日で数える。
+ * 数える日が決まらない（無い、同じ group に違う日が二つ、日によって満年齢が変わる）ときは何も言わない。
+ */
+export type LabelWord = { readonly pattern: string; readonly position?: "before" | "after" | undefined; readonly group?: string | undefined };
+
+export type Age = Span & { readonly amount: number; readonly approximate: boolean };
+
+/** The span is the date of birth; birth is its value (1978-04-12). */
+export type LabelledBirth = Span & { readonly birth: string; readonly age: Age; readonly group: string | undefined };
+
+export type LabelledReference = Span & { readonly date: string; readonly group: string };
+
+export type AgeVerdict = { readonly birth: LabelledBirth; readonly reference: LabelledReference; readonly expected: number };
+
+const FEBRUARY = 2;
+const LEAP_DAY = 29;
+const LEAP_DAY_EVE = 28;
+const LEAP_CYCLE = 4;
+const CENTURY = 100;
+const LEAP_CENTURY = 400;
+
+const isLeapYear = (year: number): boolean => (year % LEAP_CYCLE === 0 && year % CENTURY !== 0) || year % LEAP_CENTURY === 0;
+
+/**
+ * 満年齢。誕生日の前日までは一つ少ない。2月29日生まれの、うるう年でない年の2月28日は、法と慣習で数え方が分かれるので undefined。
+ * 年の無い日付、生まれる前の日も undefined。
+ */
+export const ageOn = (birthValue: string, onValue: string): number | undefined => {
+  const birth = calendarDateOf(birthValue);
+  const on = calendarDateOf(onValue);
+  if (birth?.year === undefined || on?.year === undefined) return undefined;
+  const leapDayEve = birth.month === FEBRUARY && birth.day === LEAP_DAY && on.month === FEBRUARY && on.day === LEAP_DAY_EVE && !isLeapYear(on.year);
+  if (leapDayEve) return undefined;
+  const reached = on.month > birth.month || (on.month === birth.month && on.day >= birth.day);
+  const age = on.year - birth.year - (reached ? 0 : 1);
+  return age < 0 ? undefined : age;
+};
+
+/** 年齢の印（受診時）が名指す group のラベルの日。その group の日が無ければ、ラベルの付いた日すべて。 */
+const candidatesFor = (birth: LabelledBirth, references: readonly LabelledReference[]): readonly LabelledReference[] => {
+  const named = references.filter((reference) => reference.group === birth.group);
+  return named.length > 0 ? named : references;
+};
+
+/** 同じ group に違う日が二つあれば（受診日が二つ）、どちらの日の年齢か決まらない。 */
+const hasConflictingGroup = (candidates: readonly LabelledReference[]): boolean =>
+  candidates.some((left) => candidates.some((right) => left.group === right.group && left.date !== right.date));
+
+const verdictOf = (birth: LabelledBirth, references: readonly LabelledReference[]): AgeVerdict[] => {
+  const candidates = candidatesFor(birth, references);
+  const [first] = candidates;
+  if (birth.age.approximate || first === undefined || hasConflictingGroup(candidates)) return [];
+  const ages = candidates.map((reference) => ageOn(birth.birth, reference.date));
+  const expected = ages[0];
+  if (expected === undefined || ages.some((age) => age !== expected)) return [];
+  return [{ birth, reference: first, expected }];
+};
+
+/** 数える日が一つに決まった年齢と、その日の満年齢。書いた年齢と合うものも含む。 */
+export const ageVerdicts = (births: readonly LabelledBirth[], references: readonly LabelledReference[]): AgeVerdict[] =>
+  births.flatMap((birth) => verdictOf(birth, references));
+
+export const ageMismatches = (births: readonly LabelledBirth[], references: readonly LabelledReference[]): AgeVerdict[] =>
+  ageVerdicts(births, references).filter((verdict) => verdict.birth.age.amount !== verdict.expected);
+
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+const SEPARATOR = /[\s:：|*＊]/u;
+
+const withoutTrailingSeparators = (text: string): string => {
+  let end = text.length;
+  while (end > 0 && SEPARATOR.test(text.charAt(end - 1))) end -= 1;
+  return text.slice(0, end);
+};
+
+const isWordAt = (text: string, at: number): boolean => WORD_CHAR.test(text.charAt(at));
+
+/** text の終わりに、語の切れ目から書いた word。 */
+const endsWithWord = (text: string, word: string): boolean => text.endsWith(word) && !isWordAt(text, text.length - word.length - 1);
+
+/** text の頭に書いた word。英字の語は、後ろが語の切れ目のときだけ。 */
+const startsWithWord = (text: string, word: string): boolean => text.startsWith(word) && (!/[a-z]$/u.test(word) || !isWordAt(text, word.length));
+
+const before = (word: LabelWord): boolean => (word.position ?? "before") === "before";
+
+/** ラベルの前に書いてよいもの: 行の頭、表の区切り、強調や箇条書きの印、括弧や読点。「前回受診日」「Previous examination date」は別の日。 */
+const FIELD_START = /(?:^|[|*＊#>\-・•(（)）、,;；。.])$/u;
+
+/** text の終わりに書いた年齢（「(age 23」の後ろの as of は、その年齢を数える日の印）。 */
+const endsWithAge = (text: string, words: AgeWords | undefined): boolean => words !== undefined && agesIn(text, words).some((age) => age.end === text.length);
+
+/** 日付の前（同じ行の、日付までの文字）の終わりに、区切り（：、|、**）を除いて書いたラベル。ラベルは欄の頭から、または words の年齢のすぐ後ろに書いたものだけ。 */
+export const labelBefore = (lineBefore: string, labels: readonly LabelWord[], words?: AgeWords): LabelWord | undefined => {
+  const head = withoutTrailingSeparators(lineBefore).toLowerCase();
+  return labels.filter(before).find((label) => {
+    const pattern = label.pattern.toLowerCase();
+    if (!head.endsWith(pattern)) return false;
+    const lead = head.slice(0, head.length - pattern.length).trimEnd();
+    return FIELD_START.test(lead) || endsWithAge(lead, words);
+  });
+};
+
+/** 日付のすぐ後ろに書いたラベル（2026年4月1日時点）。 */
+export const labelAfter = (lineAfter: string, labels: readonly LabelWord[]): LabelWord | undefined => {
+  const tail = lineAfter.trimStart().toLowerCase();
+  return labels.filter((label) => !before(label)).find((label) => startsWithWord(tail, label.pattern.toLowerCase()));
+};
+
+/** 年齢の書き方。before は数の前の語（age、aged）、after は数の後ろの語（歳、old）、skip は数と after のあいだに書いてよい語（years）。 */
+export type AgeWords = {
+  readonly before: readonly string[];
+  readonly after: readonly string[];
+  readonly skip: readonly string[];
+  readonly approximateBefore: readonly string[];
+  readonly approximateAfter: readonly string[];
+};
+
+/** 年齢の幅（59-60歳、59〜60 years old）の片方は、書いた年齢ではない。 */
+const RANGE_BEFORE = /[0-9０-９]\s*(?:[-–—~〜～]|\sto)$/iu;
+const RANGE_AFTER = /^\s*(?:[-–—~〜～]|to\s)\s*[0-9０-９]/iu;
+
+const AGE_NUMBER = /(?<![0-9０-９]|[0-9０-９][.,．，])[0-9０-９]{1,3}(?![0-9０-９]|[.,．，][0-9０-９])/gu;
+
+const longestStart = (text: string, words: readonly string[]): string | undefined =>
+  words
+    .filter((word) => startsWithWord(text, word.toLowerCase()))
+    .toSorted((left, right) => right.length - left.length)
+    .at(0);
+
+/** 数の後ろ: 書いてよい語（years）を飛ばしてから、年齢の語（歳、old）があれば、その語の後ろの文字。無ければ undefined。 */
+const restAfterMarker = (afterNumber: string, words: AgeWords): string | undefined => {
+  const trimmed = afterNumber.trimStart().toLowerCase();
+  const skipped = longestStart(trimmed, words.skip);
+  const rest = skipped === undefined ? trimmed : trimmed.slice(skipped.length).trimStart();
+  const marker = longestStart(rest, words.after);
+  return marker === undefined ? undefined : rest.slice(marker.length);
+};
+
+/** 一行の中の年齢と、後ろに書いた年齢の語まで（48歳、満48歳、age 57、aged 57、57 years old）。目安の年齢（約48歳、48歳前後）と年齢の幅（59-60歳）は approximate。 */
+export const agesIn = (text: string, words: AgeWords): Age[] =>
+  [...text.matchAll(AGE_NUMBER)].flatMap((match): Age[] => {
+    const start = match.index;
+    const end = start + match[0].length;
+    const head = text.slice(0, start).trimEnd().toLowerCase();
+    const afterNumber = text.slice(end);
+    const rest = restAfterMarker(afterNumber, words);
+    const marker = words.before.find((word) => endsWithWord(head, word.toLowerCase()));
+    if (rest === undefined && marker === undefined) return [];
+    const headBeforeMarker = marker === undefined ? head : head.slice(0, head.length - marker.length).trimEnd();
+    const approximate =
+      RANGE_BEFORE.test(headBeforeMarker) ||
+      RANGE_AFTER.test(afterNumber) ||
+      words.approximateBefore.some((word) => headBeforeMarker.endsWith(word.toLowerCase())) ||
+      (rest !== undefined && words.approximateAfter.some((word) => rest.trimStart().startsWith(word.toLowerCase())));
+    const markerEnd = rest === undefined ? end : end + afterNumber.length - rest.length;
+    return [{ start, end: markerEnd, amount: Number(match[0].normalize("NFKC")), approximate }];
+  });

package/src/derived/durations.ts

@@ -1,52 +1,123 @@
 import type { Span } from "../plugin.ts";
 import { bySentence } from "./sentence-buckets.ts";
 import { calendarDateOf, dateOf, shifted, valueOf, type DurationUnit } from "./date-arithmetic.ts";
+import { markedPair, type MarkText } from "./marked-dates.ts";
 
 /**
  * 始まりと期間と終わりを一つの文に書いたもの（「4月1日から3か月間（6月30日まで）」"for 3 months from April 1, 2026 (until
  * June 30, 2026)"）。始まりに期間を足した日が終わりと合わなければ言う。期間の数え方は三通りある。終わりの日を含めて数える
  * （4月1日から3か月間は6月30日まで）か、含めずに数える（7月1日まで）か、初日を数えずに期間が過ぎた日（「到達日から2週間が経過した日
  * （4月16日）」）。どれとも合わないときだけ言う。
- * 文に日付がちょうど二つ、期間がちょうど一つのときだけ読む。それより多い文は、どの日付とどの期間が組なのか決まらない。
+ * 文に期間がちょうど一つのときだけ読む。日付が三つ以上なら、始まりと終わりを語で印した組（「7月1日から」「（7月31日まで）」）だけを
+ * 読む。印が無ければ、どの日付とどの期間が組なのか決まらない。
+ * 範囲のすぐ後ろの括弧に書いた期間（「9月1日〜9月30日（30日間）」）は範囲そのものの長さで、期間が過ぎた日を終わりに書くことはない。
  */
 export type DatedValue = Span & { readonly value: string };
 
-export type Duration = Span & { readonly amount: number; readonly unit: DurationUnit };
+export type Duration = Span & {
+  readonly amount: number;
+  readonly unit: DurationUnit;
+  /** 名詞の前に書いた期間（a 7-day returns window）。決まりの長さのことが多く、二つの日付の間の長さとは限らない。 */
+  readonly attributive?: boolean;
+};
 
 export type DurationMismatch = { readonly start: DatedValue; readonly duration: Duration; readonly end: DatedValue; readonly expected: string };
 
-/** 期間を足した日と、その前の日（終わりを含めて数える）と、次の日（初日を数えずに期間が過ぎた日）。 */
-const expectedEnds = (start: Date, duration: Duration): Date[] => {
+/** 期間を足した日と、その前の日（終わりを含めて数える）と、次の日（初日を数えずに期間が過ぎた日。範囲の長さには無い）。 */
+const expectedEnds = (start: Date, duration: Duration, rangeLength: boolean): Date[] => {
   const exclusive = shifted(start, duration.amount, duration.unit);
-  return [shifted(exclusive, -1, "day"), exclusive, shifted(exclusive, 1, "day")];
+  const ends = [shifted(exclusive, -1, "day"), exclusive];
+  return rangeLength ? ends : [...ends, shifted(exclusive, 1, "day")];
+};
+
+/** 文書と、範囲の間の語（〜、–、to）と、日付の後ろの括弧に添える曜日（（火）、(Wed)）。 */
+export type RangeText = { readonly source: string; readonly joiners: readonly string[]; readonly weekdays: readonly string[] };
+
+const LEADING_BRACKET = /^\s*[(（]([^()（）\n]+)[)）]/u;
+const OPEN_BRACKET = /^\s*[(（]\s*$/u;
+const CLOSE_BRACKET = /^\s*[)）]/u;
+
+/** 先頭の曜日の括弧（（火）、(Wednesday)）を除いた残り。曜日の名の頭だけを書いたものも曜日。 */
+const withoutWeekday = (text: string, weekdays: readonly string[]): string => {
+  const inside = LEADING_BRACKET.exec(text);
+  if (inside === null) return text;
+  const word = (inside[1] ?? "").trim().toLowerCase();
+  return word !== "" && weekdays.some((weekday) => weekday.toLowerCase().startsWith(word)) ? text.slice(inside[0].length) : text;
+};
+
+/** 範囲（9月1日〜9月30日、July 1 – August 31）の終わりのすぐ後ろの括弧に、期間だけを書いた（（30日間）、(30 days)）。 */
+export const isRangeLength = (text: RangeText, range: readonly [Span, Span], duration: Span): boolean => {
+  const { source, ...words } = text;
+  const [first, end] = range;
+  if (first.end > end.start || end.end > duration.start) return false;
+  const joint = withoutWeekday(source.slice(first.end, end.start), words.weekdays).trim().toLowerCase();
+  return (
+    words.joiners.some((joiner) => joiner.toLowerCase() === joint) &&
+    OPEN_BRACKET.test(withoutWeekday(source.slice(end.end, duration.start), words.weekdays)) &&
+    CLOSE_BRACKET.test(source.slice(duration.end))
+  );
 };
 
 /** 年まで書いた二つの日付は、早いほうを始まりにする（「7月1日まで、4月1日から3か月」）。月日だけなら書いた順（年をまたぐことがある）。 */
 const ordered = (first: DatedValue, second: DatedValue, withYear: boolean): [DatedValue, DatedValue] =>
   withYear && second.value < first.value ? [second, first] : [first, second];
 
-const mismatchOf = (written: readonly [DatedValue, DatedValue], duration: Duration): DurationMismatch | undefined => {
+/** 名詞の前の期間は、日付の間がその二倍までのときだけ組にする。75日の間に書いた 7-day の窓は別の長さ。 */
+export const ATTRIBUTIVE_REACH = 2;
+
+/** 書いた終わりの日。年の無い月日で始まりより前なら、翌年。 */
+const endDateOf = (start: Date, end: DatedValue, withYear: boolean): Date | undefined => {
+  const written = calendarDateOf(end.value);
+  if (written === undefined) return undefined;
+  const date = dateOf(written);
+  return withYear || date >= start ? date : shifted(date, 1, "year");
+};
+
+const beyondReach = (start: Date, end: DatedValue, duration: Duration, withYear: boolean): boolean => {
+  if (duration.attributive !== true) return false;
+  const endDate = endDateOf(start, end, withYear);
+  return endDate === undefined || endDate > shifted(start, duration.amount * ATTRIBUTIVE_REACH, duration.unit);
+};
+
+const mismatchOf = (written: readonly [DatedValue, DatedValue], duration: Duration, rangeLength: boolean): DurationMismatch | undefined => {
   const [firstDate, secondDate] = [calendarDateOf(written[0].value), calendarDateOf(written[1].value)];
   if (firstDate === undefined || secondDate === undefined || (firstDate.year === undefined) !== (secondDate.year === undefined)) return undefined;
   const withYear = firstDate.year !== undefined;
   const [start, end] = ordered(written[0], written[1], withYear);
   const startDate = calendarDateOf(start.value);
   if (startDate === undefined) return undefined;
-  const ends = expectedEnds(dateOf(startDate), duration);
+  const ends = expectedEnds(dateOf(startDate), duration, rangeLength);
   const [inclusive] = ends;
   if (inclusive === undefined || ends.some((candidate) => valueOf(candidate, withYear) === end.value)) return undefined;
+  if (beyondReach(dateOf(startDate), end, duration, withYear)) return undefined;
   return { start, duration, end, expected: valueOf(inclusive, withYear) };
 };
 
+/** 年まで書いた組で、印した終わりが始まりより前なら、期間の向きが逆（date-range-reversed が言う）。 */
+const reversed = ([start, end]: readonly [DatedValue, DatedValue]): boolean =>
+  calendarDateOf(start.value)?.year !== undefined && calendarDateOf(end.value)?.year !== undefined && end.value < start.value;
+
+const pairOf = (sentence: Span, inDates: readonly DatedValue[], duration: Duration, text: MarkText): readonly [DatedValue, DatedValue] | undefined => {
+  const [first, second] = inDates;
+  if (inDates.length === 2 && first !== undefined && second !== undefined) return [first, second];
+  const marked = inDates.length > 2 ? markedPair(text, sentence, inDates, duration) : undefined;
+  return marked === undefined || reversed(marked) ? undefined : marked;
+};
+
 /** 一つの文の中の、始まり・期間・終わり。 */
-export const durationMismatches = (sentences: readonly Span[], dates: readonly DatedValue[], durations: readonly Duration[]): DurationMismatch[] => {
+export const durationMismatches = (
+  sentences: readonly Span[],
+  dates: readonly DatedValue[],
+  durations: readonly Duration[],
+  text: RangeText & MarkText,
+): DurationMismatch[] => {
   const datesIn = bySentence(sentences, dates);
   return [...bySentence(sentences, durations).entries()].flatMap(([index, inDurations]) => {
-    const inDates = datesIn.get(index) ?? [];
-    const [first, second] = inDates;
     const [duration] = inDurations;
-    if (inDates.length !== 2 || inDurations.length !== 1 || first === undefined || second === undefined || duration === undefined) return [];
-    const mismatch = mismatchOf([first, second], duration);
+    const sentence = sentences[index];
+    if (inDurations.length !== 1 || duration === undefined || sentence === undefined) return [];
+    const pair = pairOf(sentence, datesIn.get(index) ?? [], duration, text);
+    const mismatch = pair === undefined ? undefined : mismatchOf(pair, duration, isRangeLength(text, pair, duration));
     return mismatch === undefined ? [] : [mismatch];
   });
 };