chaffjs 0.30.0 → 0.31.0

package/src/structure/capacity-count.ts

@@ -0,0 +1,196 @@
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 書いた定員より多い申込・招待・参加の人数（定員：90名 と 95名の方にお申し込み、Capacity: 90 seats と 95 members have registered）。
+ * 定員の語（定員、先着、capacity、limited to）と人数の語（申込、招待者、have registered）を付けた数だけを読み、語の無い数は読まない。
+ * 比べるのは、文書に定員が一つ（一つの値）だけ書いてあるときだけ。二つ以上あれば、どの人数がどの定員のものか決められない。
+ * 数える物の組が違う数（30組と45名）は比べない。キャンセル待ちや抽選の語が文書にあれば、定員を超える申込は書いたとおりのことなので
+ * 言わない。一回あたりの数（各回定員20名、20 per session）は、定員でも人数でも比べない。全体の人数と一回の定員は比べられない。
+ * 去年や前回の人数（昨年は120名が参加）は、この催しの人数ではないので読まない。語は言語パッケージの語彙表から受け取る。
+ */
+
+/** 語彙表の一語。position は数のどちら側に書くか。group は語の種類（数える物の組、place の付いた定員の語）。 */
+export type CountMark = { readonly pattern: string; readonly position?: "before" | "after" | undefined; readonly group?: string | undefined };
+
+export type CapacityWords = {
+  /** 定員の語。group が place のものは、席の数（seats、places）にだけ付く（there are 25 places）。 */
+  readonly capacities: readonly CountMark[];
+  /** 申込・招待・参加の人数の語。 */
+  readonly counts: readonly CountMark[];
+  /** 数える物の語（名、人、席、people、seats）。group は組（head は人、place は席で人と比べる、party は組や家族）。 */
+  readonly units: readonly CountMark[];
+  /** 文書にあれば定員を超える申込を言わない語（キャンセル待ち、抽選、waitlist）。 */
+  readonly overflows: readonly string[];
+  /** 同じ行にあれば一回・一日あたりの数だと言う語（各回、per session）。 */
+  readonly perSession: readonly string[];
+  /** 人数と同じ行にあれば別の時の人数だと言う語（昨年、前回、last year）。 */
+  readonly otherOccasions: readonly string[];
+  /** 人数の後ろの句にあれば、申し込んでいない人の数だと言う語（していません、not）。 */
+  readonly negations: readonly string[];
+};
+
+/** 句の切れ目。人数の後ろの打ち消しは、ここまでで探す。 */
+const CLAUSE_BREAK = /[。．.!?！？;；、,，\n]/u;
+
+const clauseAfter = (source: string, end: number): string => {
+  const rest = source.slice(end);
+  const cut = CLAUSE_BREAK.exec(rest)?.index ?? rest.length;
+  return rest.slice(0, cut);
+};
+
+/** 語の付いた数。unit は数える物の組で、単位を書かない数（capacity 30）は undefined。line はその数の行。 */
+export type LabelledCount = {
+  readonly start: number;
+  readonly end: number;
+  readonly value: number;
+  readonly unit: string | undefined;
+  readonly line: string;
+};
+
+const DIGIT = "[0-9０-９]";
+/** 整数（1,200 は千二百）。小数と、桁区切りの続きの途中からは読まない。 */
+const NUMBER = new RegExp(`(?<!${DIGIT}|[.,，．])${DIGIT}+(?:[,，]${DIGIT}{3})*(?!${DIGIT}|[.,，．]${DIGIT})`, "gu");
+
+/** 記号と空白を除いて、語と数の間に挟んでよいもの（定員：90名、定員は25名、capacity of 30、registrations: 45）。 */
+const BEFORE_GAP_WORDS: ReadonlySet<string> = new Set(["", "は", "が", "of", "is", "was", "at"]);
+const isBeforeGap = (gap: string): boolean => BEFORE_GAP_WORDS.has(lower(gap.replaceAll(/[\s:：=]/gu, "")));
+/** 数（と単位）と後ろの和語の間に挟んでよいもの（95名の方にお申し込み、28名のお申し込み）。 */
+const AFTER_GAP_CJK = /^(?:の方|の皆様|の皆さま)?(?:[にがの]|から)?[おご]?$/u;
+/** 数（と単位）と後ろの英語の間の語は三つまで（95 members have registered、28 children had already booked）。 */
+const AFTER_GAP_LATIN = /^(?:\s+[A-Za-z]+){0,3}\s+$/u;
+/** 英語の単位は数との間に空白を一つ置ける（90 seats）。 */
+const LATIN_UNIT_GAP = /^\s?/u;
+const WORD_NEXT = /^\s?[A-Za-z]/u;
+
+const LETTER = /[A-Za-z]/u;
+
+const lower = (text: string): string => text.toLowerCase();
+
+const isLatin = (word: string): boolean => LETTER.test(word.charAt(0));
+
+const numberOf = (digits: string): number => Number(digits.normalize("NFKC").replaceAll(/[,，]/gu, ""));
+
+const startsWithWord = (text: string, word: string): boolean =>
+  lower(text).startsWith(lower(word)) && !(LETTER.test(word.slice(-1)) && LETTER.test(text.charAt(word.length)));
+
+const endsWithWord = (text: string, word: string): boolean =>
+  lower(text).endsWith(lower(word)) && !(LETTER.test(word.charAt(0)) && LETTER.test(text.charAt(text.length - word.length - 1)));
+
+/** 英字の語は語の切れ目で照らす（past が pastry に当たらない）。 */
+const contains = (text: string, words: readonly string[]): boolean =>
+  words.some((word) =>
+    [...lower(text).matchAll(new RegExp(escapeRegExp(lower(word)), "gu"))].some(
+      (match) => startsWithWord(text.slice(match.index), word) && endsWithWord(text.slice(0, match.index + word.length), word),
+    ),
+  );
+
+type Unit = { readonly mark: CountMark; readonly end: number };
+
+/** 数のすぐ後ろの単位と、単位の終わりの位置。長い語から照らす。 */
+const unitAfter = (line: string, end: number, units: readonly CountMark[]): Unit | undefined =>
+  units
+    .toSorted((left, right) => right.pattern.length - left.pattern.length)
+    .flatMap((mark) => {
+      const gap = isLatin(mark.pattern) ? (LATIN_UNIT_GAP.exec(line.slice(end))?.[0].length ?? 0) : 0;
+      return startsWithWord(line.slice(end + gap), mark.pattern) ? [{ mark, end: end + gap + mark.pattern.length }] : [];
+    })[0];
+
+const labelBefore = (head: string, marks: readonly CountMark[]): CountMark | undefined =>
+  marks
+    .filter((mark) => mark.position !== "after")
+    .find((mark) => {
+      const at = lower(head).lastIndexOf(lower(mark.pattern));
+      const end = at + mark.pattern.length;
+      return at !== -1 && endsWithWord(head.slice(0, end), mark.pattern) && isBeforeGap(head.slice(end));
+    });
+
+const labelAfter = (tail: string, marks: readonly CountMark[]): CountMark | undefined =>
+  marks
+    .filter((mark) => mark.position === "after")
+    .find((mark) => {
+      const at = lower(tail).indexOf(lower(mark.pattern));
+      if (at === -1 || !startsWithWord(tail.slice(at), mark.pattern)) return false;
+      return (isLatin(mark.pattern) ? AFTER_GAP_LATIN : AFTER_GAP_CJK).test(tail.slice(0, at));
+    });
+
+/**
+ * 語の付いた数か。和語の語には単位が要る（定員90 は読まない）。英語の数は単位を書かなくてよいが、後ろに単位でない語が続けば
+ * 別の物の数（capacity 30 cars）。place の付いた語は席の数にだけ付く。
+ */
+const isLabelled = (label: CountMark | undefined, unit: Unit | undefined, after: string, afterLabel: CountMark | undefined): label is CountMark => {
+  if (label === undefined || (label.group === "place" && unit?.mark.group !== "place")) return false;
+  if (unit !== undefined) return true;
+  return isLatin(label.pattern) && (afterLabel !== undefined || !WORD_NEXT.test(after));
+};
+
+/** 一行の中の、語の付いた数。 */
+const labelledIn = (line: string, lineStart: number, marks: readonly CountMark[], units: readonly CountMark[]): LabelledCount[] =>
+  [...line.matchAll(NUMBER)].flatMap((match) => {
+    const unit = unitAfter(line, match.index + match[0].length, units);
+    const end = unit?.end ?? match.index + match[0].length;
+    const after = line.slice(end);
+    const afterLabel = labelAfter(after, marks);
+    if (!isLabelled(labelBefore(line.slice(0, match.index), marks) ?? afterLabel, unit, after, afterLabel)) return [];
+    return [{ start: lineStart + match.index, end: lineStart + end, value: numberOf(match[0]), unit: unit?.mark.group, line }];
+  });
+
+const linesOf = (source: string): { readonly text: string; readonly start: number }[] => {
+  const starts = [0, ...[...source.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.map((start, index) => ({ text: source.slice(start, (starts[index + 1] ?? source.length + 1) - 1), start }));
+};
+
+const readAll = (source: string, marks: readonly CountMark[], units: readonly CountMark[]): LabelledCount[] =>
+  linesOf(source).flatMap((line) => labelledIn(line.text, line.start, marks, units));
+
+/** 席（place）は人（head）と同じ組として比べる。単位を書かない数は人の数。 */
+export const comparableGroup = (unit: string | undefined): string => (unit === undefined || unit === "place" ? "head" : unit);
+
+/** 文書の中の、定員の語の付いた数。一回あたりの定員は除く。 */
+export const capacityStatements = (source: string, words: CapacityWords): LabelledCount[] =>
+  readAll(source, words.capacities, words.units).filter((reading) => !contains(reading.line, words.perSession));
+
+/** 文書の中の、人数の語の付いた数。一回あたりの人数と、別の時の人数は除く。 */
+export const countStatements = (source: string, words: CapacityWords): LabelledCount[] =>
+  readAll(source, words.counts, words.units).filter(
+    (reading) =>
+      !contains(reading.line, words.perSession) &&
+      !contains(reading.line, words.otherOccasions) &&
+      !contains(clauseAfter(source, reading.end), words.negations),
+  );
+
+/** 定員を超える人数のうち一番多いもの。定員が一つの値でなければ、比べない。 */
+export const overCapacity = (
+  capacities: readonly LabelledCount[],
+  counts: readonly LabelledCount[],
+): { readonly capacity: LabelledCount; readonly over: LabelledCount } | undefined => {
+  const capacity = capacities[0];
+  if (capacity === undefined || capacities.some((other) => other.value !== capacity.value)) return undefined;
+  const over = counts
+    .filter((count) => comparableGroup(count.unit) === comparableGroup(capacity.unit) && count.value > capacity.value)
+    .toSorted((left, right) => right.value - left.value)[0];
+  return over === undefined ? undefined : { capacity, over };
+};
+
+/** その位置を含む一番小さい節の原文。節が無ければ文書の全体。 */
+export const sectionAround = (source: string, offset: number, sections: readonly Span[]): string => {
+  const around = sections
+    .filter((section) => section.start <= offset && offset < section.end)
+    .toSorted((left, right) => left.end - left.start - (right.end - right.start))[0];
+  return around === undefined ? source : source.slice(around.start, around.end);
+};
+
+/**
+ * 定員より多い人数。キャンセル待ちや抽選の語のある節の定員と人数は読まない（定員を超える申込が書いたとおりのこと）。
+ * 節に限るのは、別の節の「抽選会」（催しの一つ）で比べるのをやめないため。定員の位置を指す。sections は節の範囲。
+ */
+export const countsOverCapacity = (source: string, words: CapacityWords, sections: readonly Span[] = []): StructureIssue[] => {
+  const settled = (reading: LabelledCount): boolean => !contains(sectionAround(source, reading.start, sections), words.overflows);
+  const capacities = capacityStatements(source, words);
+  if (!capacities.every(settled)) return [];
+  const found = overCapacity(capacities, countStatements(source, words).filter(settled));
+  if (found === undefined) return [];
+  const { capacity, over } = found;
+  return [{ offset: capacity.start, values: { capacity: source.slice(capacity.start, capacity.end), count: source.slice(over.start, over.end) } }];
+};

package/src/structure/counted-amounts.ts

@@ -7,10 +7,10 @@ import type { Amount } from "./total.ts";
 export type SummedCounter = { readonly pattern: string; readonly unit: string };
 
 /** 前に英字や数や小数点が続く数（v2、A4、1.2.3 の 2）は読まない。日本語は数の前に空白を置かないので、仮名や漢字の後ろはよい。 */
-const NUMBER = /(?<![\p{Script=Latin}\p{N}.,．，])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
+export const NUMBER = /(?<![\p{Script=Latin}\p{N}.,．，])[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?/gu;
 
 /** 助数詞に文字や数、つなぎの - _ が詰めて続くもの（3単位目、4コマ漫画、3 unit-priced）は、別の語の一部。 */
-const CONTINUES_WORD = /^[\p{L}\p{N}_-]/u;
+export const CONTINUES_WORD = /^[\p{L}\p{N}_-]/u;
 
 /** 序数の印（第3回）。 */
 const ORDINAL_MARK = "第";
@@ -18,7 +18,7 @@ const ORDINAL_MARK = "第";
 /** 助数詞を探す長さ。どの助数詞よりも長い。 */
 const LOOKAHEAD = 32;
 
-const valueOf = (written: string): number => Number(written.normalize("NFKC").replace(/,/gu, ""));
+export const valueOf = (written: string): number => Number(written.normalize("NFKC").replace(/,/gu, ""));
 
 /** 数のすぐ後ろ（空白一つまで）の助数詞。長い語から試す。大文字小文字は区別しない（4 Credits）。 */
 const counterAfter = (source: string, end: number, counters: readonly SummedCounter[]): { unit: string; end: number } | undefined => {
@@ -28,7 +28,8 @@ const counterAfter = (source: string, end: number, counters: readonly SummedCoun
   return counter === undefined ? undefined : { unit: counter.unit, end: end + gap + counter.pattern.length };
 };
 
-const overlapsAny = (start: number, end: number, amounts: readonly Amount[]): boolean => amounts.some((amount) => start < amount.end && amount.offset < end);
+export const overlapsAny = (start: number, end: number, amounts: readonly Amount[]): boolean =>
+  amounts.some((amount) => start < amount.end && amount.offset < end);
 
 /** 文書の中の、足してよい助数詞の付いた数。木がすでに数量として読んだもの（known）とは重ねない。 */
 export const countedAmounts = (source: string, counters: readonly SummedCounter[], known: readonly Amount[]): Amount[] => {

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

@@ -1,6 +1,7 @@
 import { escapeRegExp } from "../orthography.ts";
 import type { StructureIssue } from "./issues.ts";
 import { TABLE_ROW } from "./runs.ts";
+import { deadlineVerdict } from "./term-deadline.ts";
 import { statedPeriod, type DateMention, type Period, type PeriodWords } from "./stated-period.ts";
 
 /**
@@ -9,7 +10,7 @@ import { statedPeriod, type DateMention, type Period, type PeriodWords } from ".
  * 期間の前後に置く予定（前泊、follow-up）、締め切りや予約の日、過去の回を言う語（period-aside）が、その行、文、節の見出しにあれば比べない。
  * 年の無い期間（12月28日〜1月4日）は年をまたいで読む。
  * 文書の仕事の期間（開講期間：…）を文書の頭か概要の節で書いたものは文書全体の期間で、後ろのどの節でも、締め切りの語（period-deadline）のある項目や文の、
- * 期間の終わりより後の年のある日付を指す（課題の提出が学期の後）。期間の前の締め切り（申込締切）と、旅行期間のように後に締め切りが来てよい期間は比べない。
+ * 期間の終わりより後の日付を指す（課題の提出が学期の後）。年の無い日付は、期間が一つの年に収まるときだけその年と読む。成績発表や再試験の語（period-after-term）のある日付は比べない。期間の前の締め切り（申込締切）と、旅行期間のように後に締め切りが来てよい期間は比べない。
  */
 export type HeadingSpan = { readonly start: number; readonly end: number; readonly depth: number };
 type Span = { readonly start: number; readonly end: number };
@@ -20,6 +21,8 @@ export type OutsideWords = PeriodWords & {
   readonly terms: readonly string[];
   readonly deadlines: readonly string[];
   readonly overviews: readonly string[];
+  /** 期間の後に来てよい仕事の語（成績発表、再試験）。この語のある締め切りは期間と比べない。 */
+  readonly afterTerm: readonly string[];
 };
 
 const LIST_ITEM = /^[ \t]{0,12}(?:[-*+]|\d{1,3}[.)])[ \t]/u;
@@ -143,15 +146,17 @@ const isDocumentTerm = (period: Stated, context: Context, overviews: readonly st
   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;
+  if (!DAY_VALUE.test(date.value)) 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 marks = {
+    deadline: mentions(texts[0] ?? "", words.deadlines),
+    aside: texts.some((text) => mentions(withoutWords(text, words.deadlines), words.asides)),
+    afterTerm: mentions(texts[0] ?? "", words.afterTerm),
+  };
+  return deadlineVerdict(date.value, period, marks) === "late";
 };
 
 const issueOf = (source: string, date: DateMention, period: Stated): StructureIssue => ({

package/src/structure/date-range.ts

@@ -140,7 +140,7 @@ const bareFramed = (source: string, start: DatedSpan, end: DatedSpan, written: s
   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 => {
+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 ?? []);

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