chaffjs 0.30.0 → 0.32.0

package/src/structure/deadline-after-event.ts

@@ -0,0 +1,184 @@
+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";
+import { cellsOf, tablesOf } from "../facts/table-facts.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[];
+  readonly tickets: readonly string[];
+  readonly payments: readonly string[];
+  readonly bills: readonly string[];
+  readonly trips: readonly string[];
+  readonly starts: readonly string[];
+  readonly paymentDeadlines: readonly string[];
+  readonly dues: 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 MONTH_DAY = /^\d{2}-\d{2}$/u;
+const YEAR_LENGTH = 4;
+
+/**
+ * 期間の始まりの日。年を書かない始まり（October 14 – Friday, October 16, 2026）は終わりの年を借り、始まりの月が終わりの月より後なら
+ * （December 30 – January 2, 2027）その前の年。同じ月で日が逆さまの期間は、逆さまのまま同じ年に置く。
+ */
+export const rangeStartOf = (values: readonly string[]): string | undefined => {
+  const [first, ...rest] = values;
+  if (first === undefined || FULL_DATE.test(first)) return first;
+  const end = rest.find((value) => FULL_DATE.test(value));
+  if (!MONTH_DAY.test(first) || end === undefined) return undefined;
+  const year = Number(end.slice(0, YEAR_LENGTH));
+  const crossesYear = first.slice(0, 2) > end.slice(YEAR_LENGTH + 1, YEAR_LENGTH + 3);
+  return `${String(crossesYear ? year - 1 : year)}-${first}`;
+};
+
+/** 旅行の始まりの日: 出発の語で始まる行の、最初の日付。期間（10月14日〜16日）なら始まりの日。 */
+const tripStartOf = (line: Line, dates: readonly DatedPoint[], words: EventDeadlineWords): string | undefined =>
+  isTotalLabel(line.text, words.starts) ? rangeStartOf(datesIn(dates, { start: line.start, end: endOf(line) }).map((date) => date.value)) : undefined;
+
+/** 日付を囲む文を、その行の中に切ったもの。文が見つからなければ行。 */
+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);
+
+/** 催しの後に来てよいものの語のうち、支払の語でないもの（アンケート、返金）。 */
+const asidesBesidesPayment = (words: EventDeadlineWords): readonly string[] =>
+  words.asides.filter((aside) => !words.payments.some((payment) => payment.toLowerCase() === aside.toLowerCase()));
+
+/** チケットの注文の支払期限を書いた文か: 支払の語と締め切りの語があり、支払の語のほかに催しの後に来てよいものの語が無い。 */
+export const isTicketPaymentDeadline = (text: string, words: EventDeadlineWords): boolean =>
+  mentions(text, words.payments) && mentions(text, words.deadlines) && !mentions(text, asidesBesidesPayment(words));
+
+/** チケットの注文か: 題名（最初の見出し）にチケットの語があり、文書のどこにも請求書の語が無い。 */
+export const isTicketOrder = (title: string | undefined, source: string, words: EventDeadlineWords): boolean =>
+  title !== undefined && mentions(title, words.tickets) && !mentions(title, words.bills) && !mentions(source, words.bills);
+
+/** 旅行の知らせか: 題名（最初の見出し）に旅行の語があり、文書のどこにも請求書の語が無い。 */
+export const isTripNotice = (title: string | undefined, source: string, words: EventDeadlineWords): boolean =>
+  title !== undefined && mentions(title, words.trips) && !mentions(title, words.bills) && !mentions(source, words.bills);
+
+/**
+ * 旅行の代金の期限を書いた文か: 納入期限の語があるか、支払の語と締め切りか期日の語がある（Second payment: $60, due …）。
+ * heading は日付のある表の升の列の見出しで、文と合わせて読む（見出しが Due by、行が 2nd payment）。
+ * 支払の語のほかに催しの後に来てよいものの語（返金、精算）があれば読まない。期日の語（due）は旅行の知らせでだけ読む。
+ */
+export const isTripPaymentDeadline = (text: string, heading: string | undefined, words: EventDeadlineWords): boolean => {
+  const read = heading === undefined ? text : `${heading} ${text}`;
+  if (mentions(read, asidesBesidesPayment(words))) return false;
+  return mentions(read, words.paymentDeadlines) || (mentions(read, words.payments) && mentions(read, [...words.deadlines, ...words.dues]));
+};
+
+type Reading = {
+  readonly title: string | undefined;
+  readonly source: string;
+  readonly lines: readonly Line[];
+  readonly dates: readonly DatedPoint[];
+  readonly sentences: readonly Span[];
+  /** 表の本体の行の番号から、その表の見出しの行。 */
+  readonly tableHeaders: ReadonlyMap<number, Line>;
+};
+
+/** 締め切りとして読んだ道。payment はチケットの注文か旅行の知らせの支払期限で、知らせの言い方を変える。 */
+export type DeadlineKind = "registration" | "payment";
+
+export type DeadlineIssue = StructureIssue & { readonly kind: DeadlineKind };
+
+/** heading は日付が表の升にあるときの、その列の見出し。 */
+type ReadDeadline = (text: string, heading: string | undefined) => DeadlineKind | undefined;
+
+const deadlineReaderOf = (reading: Reading, words: EventDeadlineWords): ReadDeadline => {
+  const ticketOrder = isTicketOrder(reading.title, reading.source, words);
+  const tripNotice = isTripNotice(reading.title, reading.source, words);
+  return (text, heading) => {
+    if (ticketOrder && isTicketPaymentDeadline(text, words)) return "payment";
+    if (tripNotice && isTripPaymentDeadline(text, heading, words)) return "payment";
+    return isRegistrationDeadline(text, words) ? "registration" : undefined;
+  };
+};
+
+const tableHeadersOf = (lines: readonly Line[]): Map<number, Line> =>
+  new Map(tablesOf(lines).flatMap(({ header, rows }) => rows.map((row): [number, Line] => [row.number, header])));
+
+/** offset が表の本体の升にあれば、その列の見出しの字。 */
+const columnHeadingAt = (reading: Reading, line: Line, offset: number): string | undefined => {
+  const header = reading.tableHeaders.get(line.number);
+  if (header === undefined) return undefined;
+  const column = cellsOf(line).findIndex((cell) => cell.start <= offset && offset < cell.end);
+  return column === -1 ? undefined : cellsOf(header)[column]?.text;
+};
+
+const lateDeadlines = (reading: Reading, readDeadline: ReadDeadline, event: string): DeadlineIssue[] =>
+  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) return [];
+    const kind = readDeadline(reading.source.slice(unit.start, unit.end), columnHeadingAt(reading, line, date.offset));
+    if (kind === undefined) return [];
+    return [{ offset: date.offset, kind, values: { deadline: date.value, event } }];
+  });
+
+/** 催しの日: 催しの日の行の日付と、旅行の知らせなら出発の行の日付の、いちばん後のもの。 */
+const eventOf = (reading: Reading, words: EventDeadlineWords): string | undefined => {
+  const trip = isTripNotice(reading.title, reading.source, words);
+  return latestOf(
+    reading.lines.flatMap((line) =>
+      [eventDayOf(line, reading.dates, words), trip ? tripStartOf(line, reading.dates, words) : undefined].flatMap((day) => day ?? []),
+    ),
+  );
+};
+
+/** title は文書の最初の見出しの言葉（無ければ undefined）。 */
+export const deadlinesAfterEvent = (
+  source: string,
+  dates: readonly DatedPoint[],
+  sentences: readonly Span[],
+  words: EventDeadlineWords,
+  title?: string,
+): DeadlineIssue[] => {
+  if (words.events.length === 0 || words.registrations.length === 0 || words.deadlines.length === 0) return [];
+  const lines = linesOf(source);
+  const reading = { title, source, lines, dates, sentences, tableHeaders: tableHeadersOf(lines) };
+  const event = eventOf(reading, words);
+  if (event === undefined) return [];
+  return lateDeadlines(reading, deadlineReaderOf(reading, words), event);
+};

package/src/structure/deductible-limit.ts

@@ -0,0 +1,255 @@
+import { escapeRegExp } from "../orthography.ts";
+import { keyOf, proseValues, type AmountWords, type ProseFigure, type ProseQuantity } from "./ratio.ts";
+
+/**
+ * deductible-exceeds-limit: the deciding half. In one sentence naming one deductible (免責金額, excess) and one limit
+ * (支払限度額, the most we pay), each with one amount of money right after it, a deductible larger than the limit for a
+ * comparable basis (1回, a claim, 1品, a single item) means the benefit pays nothing. The words are lexicons; nothing here
+ * knows a word of insurance. Pure.
+ */
+
+/** A basis an amount is stated for (1回, a visit, 1品). rank orders the bases that nest: a claim holds one item or more. */
+export type BasisWord = { readonly pattern: string; readonly basis: string; readonly rank?: number | undefined };
+
+export type DeductibleWords = {
+  readonly deductibles: readonly string[];
+  readonly limits: readonly string[];
+  /** Phrases holding a deductible word without naming a deductible ("in excess of", 自己負担限度額). */
+  readonly notDeductibles: readonly string[];
+  /** Phrases holding a limit word without naming the most paid ("maximum excess"). */
+  readonly notLimits: readonly string[];
+  readonly bases: readonly BasisWord[];
+  readonly approximate: { readonly before: readonly string[]; readonly after: readonly string[] };
+  readonly rangeMarks: readonly string[];
+  /** Words of magnitude and what they multiply by (万 is 10000, million). */
+  readonly multipliers: readonly { readonly word: string; readonly value: number }[];
+  readonly amounts: AmountWords;
+  /** Which currency each mark names ($ and US$ are both USD; 円 and ¥ are both JPY). */
+  readonly currencies: readonly { readonly pattern: string; readonly currency: string }[];
+};
+
+export type Basis = { readonly basis: string; readonly rank?: number | undefined };
+
+/** An amount as stated: its value in the currency's own unit, the currency (with the magnitude word taken out), the basis. */
+export type StatedAmount = { readonly value: number; readonly currency: string; readonly basis?: Basis | undefined };
+
+export type DeductibleIssue = { readonly offset: number; readonly values: Readonly<Record<string, string>> };
+
+/**
+ * Whether a deductible on one basis can be held against a limit on another. A limit with no basis is the most ever paid, so
+ * every deductible is held against it. The same basis is. A deductible on a basis that holds the limit's (an excess per
+ * claim, a limit per item) is: a claim for one item meets the whole excess and at most one item's limit. A deductible with no
+ * basis is charged on one claim, so it is held against a limit on any basis that nests. Bases that do not nest (a day, a
+ * year) are compared only with themselves.
+ */
+export const basesComparable = (deductible: Basis | undefined, limit: Basis | undefined): boolean => {
+  if (limit === undefined) return true;
+  if (deductible === undefined) return limit.rank !== undefined;
+  if (deductible.basis === limit.basis) return true;
+  return deductible.rank !== undefined && limit.rank !== undefined && deductible.rank > limit.rank;
+};
+
+/** A deductible larger than the limit, in the same currency, on comparable bases. An equal one is not reported. */
+export const deductibleExceeds = (deductible: StatedAmount, limit: StatedAmount): boolean =>
+  deductible.currency === limit.currency && basesComparable(deductible.basis, limit.basis) && deductible.value > limit.value;
+
+/** How far after its word an amount may start (「免責金額は1回」, "the most we pay for a single item is"). */
+const MAX_GAP = 24;
+/** How far around a word and its amount the basis is looked for, in characters. */
+const BASIS_REACH = 16;
+/** Marks that end a clause: a basis is not read across them. */
+const CLAUSE_BREAK = /[、,;；，。.]/u;
+const LATIN = /^[A-Za-z]/u;
+const DIGIT_START = /^\d/u;
+const DIGIT_BEFORE = /[\d.,]$/u;
+const CJK_LETTER = /[\p{sc=Han}\p{sc=Katakana}ー]/u;
+const LETTER = /\p{L}/u;
+
+type Hit = { readonly start: number; readonly end: number; readonly kind: "deductible" | "limit"; readonly word: string };
+type Spot = { readonly start: number; readonly end: number };
+
+/** Where a word stands: a Latin word as a whole word in any case, any other word not inside a longer kanji or katakana word. */
+const spansOf = (text: string, word: string, cjkBounded: boolean): Spot[] => {
+  if (word === "") return [];
+  const latin = LATIN.test(word);
+  const pattern = new RegExp(latin ? `(?<![\\p{L}\\p{N}])${escapeRegExp(word)}(?![\\p{L}\\p{N}])` : escapeRegExp(word), latin ? "giu" : "gu");
+  return [...text.matchAll(pattern)]
+    .filter((match) => {
+      const [before, after] = [text.charAt(match.index - 1), text.charAt(match.index + match[0].length)];
+      if (DIGIT_START.test(word) && DIGIT_BEFORE.test(text.slice(0, match.index))) return false;
+      return latin || !cjkBounded || !(CJK_LETTER.test(before) || CJK_LETTER.test(after));
+    })
+    .map((match) => ({ start: match.index, end: match.index + match[0].length }));
+};
+
+const within = (outer: Spot) => (inner: Spot) => outer.start <= inner.start && inner.end <= outer.end;
+
+/** The deductible and limit words of a sentence, without those inside a not-phrase or inside a longer word found. */
+const hitsIn = (text: string, words: DeductibleWords): Hit[] => {
+  const nots = {
+    deductible: words.notDeductibles.flatMap((word) => spansOf(text, word, false)),
+    limit: words.notLimits.flatMap((word) => spansOf(text, word, false)),
+  };
+  const all = [
+    ...words.deductibles.flatMap((word) => spansOf(text, word, true).map((at): Hit => ({ ...at, kind: "deductible", word: text.slice(at.start, at.end) }))),
+    ...words.limits.flatMap((word) => spansOf(text, word, true).map((at): Hit => ({ ...at, kind: "limit", word: text.slice(at.start, at.end) }))),
+  ];
+  return all.filter(
+    (hit) =>
+      !nots[hit.kind].some((not) => within(not)(hit)) &&
+      !all.some((other) => other !== hit && within(other)(hit) && other.end - other.start > hit.end - hit.start),
+  );
+};
+
+/** The written text of an amount: its currency mark before, its number, its unit after (as long as the unit read). */
+type Written = Spot & { readonly figure: ProseFigure };
+
+const writtenOf = (figure: ProseFigure): Written => ({ start: figure.writtenStart, end: figure.writtenEnd, figure });
+
+const lower = (text: string): string => text.toLowerCase();
+
+/** A mark at the end of before (or the start of after) standing as a word of its own when it is Latin. */
+const endsWithMark = (before: string, mark: string): boolean => {
+  const at = lower(before).lastIndexOf(lower(mark));
+  return at >= 0 && at + mark.length === before.length && !(LATIN.test(mark) && LETTER.test(before.charAt(at - 1)));
+};
+const startsWithMark = (after: string, mark: string): boolean =>
+  lower(after).startsWith(lower(mark)) && !(LATIN.test(mark) && LETTER.test(after.charAt(mark.length)));
+
+/** A rough amount (約5,000円, about $80, 5,000円程度) or one end of a range (1,000〜5,000円, $50 - $80). A limit word is not rough. */
+const isRoughOrRange = (text: string, written: Written, words: DeductibleWords): boolean => {
+  const before = text.slice(0, written.start).trimEnd();
+  const after = text.slice(written.end).trimStart();
+  const limitWords = new Set(words.limits.map(lower));
+  const rough = [
+    ...words.approximate.before.filter((mark) => !limitWords.has(lower(mark)) && endsWithMark(before, mark)),
+    ...words.approximate.after.filter((mark) => startsWithMark(after, mark)),
+  ];
+  return rough.length > 0 || words.rangeMarks.some((mark) => before.endsWith(mark) || after.startsWith(mark));
+};
+
+/** The currency a mark names, or the mark itself when no lexicon entry names one. */
+const currencyOf = (mark: string, words: DeductibleWords): string => words.currencies.find((entry) => keyOf(entry.pattern) === mark)?.currency ?? mark;
+
+/** The value with its word of magnitude multiplied in, and the currency its marks name ("|万円" 30 is 300000 JPY, "us$|" is USD). */
+const scaled = (figure: ProseFigure, words: DeductibleWords): { value: number; currency: string } => {
+  const multiplier = words.multipliers.find((entry) => figure.suffix.startsWith(keyOf(entry.word)));
+  const bare = multiplier === undefined ? figure.suffix : figure.suffix.slice(keyOf(multiplier.word).length).trimStart();
+  const marks = [figure.mark, bare].filter((mark) => mark !== "").map((mark) => currencyOf(mark, words));
+  return { value: figure.value * (multiplier?.value ?? 1), currency: [...new Set(marks)].join("|") };
+};
+
+/** The only amount of money between a word and the next word (or the end), close to it. */
+const amountAfter = (hit: Hit, hits: readonly Hit[], figures: readonly ProseFigure[], text: string): Written | undefined => {
+  const until = Math.min(text.length, ...hits.filter((other) => other.start >= hit.end).map((other) => other.start));
+  const between = figures.filter((figure) => figure.start >= hit.end && figure.start < until);
+  const only = between.length === 1 ? between[0] : undefined;
+  if (only === undefined || only.start - hit.end > MAX_GAP) return undefined;
+  return writtenOf(only);
+};
+
+const lastBreakBefore = (text: string, at: number): number => {
+  const before = text.slice(0, at);
+  const breaks = [...before.matchAll(new RegExp(CLAUSE_BREAK.source, "gu"))].map((match) => match.index + 1);
+  return Math.max(0, ...breaks);
+};
+
+const firstBreakAfter = (text: string, at: number): number => {
+  const found = CLAUSE_BREAK.exec(text.slice(at));
+  return found === null ? text.length : at + found.index;
+};
+
+/** The bases written in the clause around a word and its amount, outside the amount itself. */
+const basesIn = (text: string, region: Spot, words: DeductibleWords, taken: Spot): BasisWord[] => {
+  const slice = text.slice(region.start, region.end);
+  return words.bases.flatMap((entry) =>
+    spansOf(slice, entry.pattern, false)
+      .map((at) => ({ start: region.start + at.start, end: region.start + at.end }))
+      .filter((at) => !(at.start < taken.end && taken.start < at.end))
+      .map(() => entry),
+  );
+};
+
+type Read = { readonly hit: Hit; readonly written: Written; readonly stated: StatedAmount };
+
+const SPACES = /^\s*/u;
+
+/** Where the bases written right after an amount end ("$80 a visit", "$80 a visit a day"), or the amount's end when none is. */
+const adjacentEnd = (text: string, end: number, words: DeductibleWords): number => {
+  const from = end + (SPACES.exec(text.slice(end))?.[0].length ?? 0);
+  const rest = text.slice(from);
+  const lengths = words.bases.flatMap((entry) =>
+    spansOf(rest, entry.pattern, false)
+      .filter((at) => at.start === 0)
+      .map((at) => at.end),
+  );
+  return lengths.length === 0 ? end : adjacentEnd(text, from + Math.max(...lengths), words);
+};
+
+/**
+ * The clause around a word and its amount where its basis is read. Between the first amount and the second word, only a basis
+ * right after the amount is the first's ("$80 a visit and the most we pay"); any other belongs to the second word
+ * (「300,000円で1品あたりの支払限度額」).
+ */
+const regionsOf = (text: string, first: Written, second: { hit: Hit; written: Written }, firstHit: Hit, words: DeductibleWords): [Spot, Spot] => {
+  const split = adjacentEnd(text, first.end, words);
+  const opening = { start: Math.max(firstHit.start - BASIS_REACH, lastBreakBefore(text, firstHit.start)), end: split };
+  const closing = {
+    start: Math.max(split, second.hit.start - BASIS_REACH, lastBreakBefore(text, second.hit.start)),
+    end: Math.min(second.written.end + BASIS_REACH, firstBreakAfter(text, second.written.end)),
+  };
+  return [opening, closing];
+};
+
+/** The amount as stated, with the one basis written around it; two different bases leave it unread. */
+const statedOf = (text: string, written: Written, region: Spot, words: DeductibleWords): StatedAmount | undefined => {
+  const found = basesIn(text, region, words, written);
+  if (new Set(found.map((entry) => entry.basis)).size > 1) return undefined;
+  const first = found[0];
+  return { ...scaled(written.figure, words), basis: first === undefined ? undefined : { basis: first.basis, rank: first.rank } };
+};
+
+/** Both words with their amounts and bases, in the order written; undefined when either amount is not read. */
+const readPair = (text: string, hits: readonly [Hit, Hit], figures: readonly ProseFigure[], words: DeductibleWords): Read[] | undefined => {
+  const [first, second] = hits.toSorted((left, right) => left.start - right.start);
+  if (first === undefined || second === undefined) return undefined;
+  const [firstWritten, secondWritten] = [amountAfter(first, hits, figures, text), amountAfter(second, hits, figures, text)];
+  if (firstWritten === undefined || secondWritten === undefined) return undefined;
+  if ([firstWritten, secondWritten].some((written) => isRoughOrRange(text, written, words))) return undefined;
+  const [opening, closing] = regionsOf(text, firstWritten, { hit: second, written: secondWritten }, first, words);
+  const [firstStated, secondStated] = [statedOf(text, firstWritten, opening, words), statedOf(text, secondWritten, closing, words)];
+  if (firstStated === undefined || secondStated === undefined) return undefined;
+  return [
+    { hit: first, written: firstWritten, stated: firstStated },
+    { hit: second, written: secondWritten, stated: secondStated },
+  ];
+};
+
+/**
+ * One sentence (text, starting at offset in the document; quantities are the tree's, in document offsets) with exactly one
+ * deductible word and one limit word, each with one amount of money right after it, read as stated and compared. Any other
+ * shape is not read.
+ */
+export const sentenceDeductibleOverLimit = (
+  text: string,
+  offset: number,
+  quantities: readonly ProseQuantity[],
+  words: DeductibleWords,
+): DeductibleIssue | undefined => {
+  const hits = hitsIn(text, words);
+  const deductibleHits = hits.filter((hit) => hit.kind === "deductible");
+  const limitHits = hits.filter((hit) => hit.kind === "limit");
+  const [deductibleHit, limitHit] = [deductibleHits[0], limitHits[0]];
+  if (deductibleHits.length !== 1 || limitHits.length !== 1 || deductibleHit === undefined || limitHit === undefined) return undefined;
+  const local = quantities.map((quantity) => ({ ...quantity, start: quantity.start - offset, end: quantity.end - offset }));
+  const { figures } = proseValues(text, 0, local, words.amounts);
+  const pair = readPair(text, [deductibleHit, limitHit], figures, words);
+  const deductible = pair?.find((read) => read.hit === deductibleHit);
+  const limit = pair?.find((read) => read.hit === limitHit);
+  if (deductible === undefined || limit === undefined || !deductibleExceeds(deductible.stated, limit.stated)) return undefined;
+  const shown = (read: Read): string => text.slice(read.written.start, read.written.end);
+  return {
+    offset: offset + deductible.written.start,
+    values: { deductibleWord: deductible.hit.word, deductible: shown(deductible), limitWord: limit.hit.word, limit: shown(limit) },
+  };
+};

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