chaffjs 0.31.0 → 0.33.0

package/src/detectors/change-rate.ts

@@ -2,11 +2,15 @@
 // tree's quantities, the numbers counted with a word ("1,200 companies"), the calendar years, and the lexicons change-direction,
 // change-base, change-target, change-break, percent-unit and amount-multiplier.
 import type { Detector, Finding, LexiconEntry, ProseDocument, Span, StructureNode, Token } from "../plugin.ts";
-import { inDocumentOrder } from "../structure/issues.ts";
+import { inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { startsOtherSubject } from "../structure/subject-change.ts";
 import { changeRateMismatches, type BaseMark, type Break, type Direction, type Figure, type Period, type Rate } from "../structure/change-rate.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { tableRateMismatches, type ChangeTable, type ColumnRole, type ColumnWord } from "../structure/change-rate-table.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { proseAndTablesOf } from "../table-text.ts";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
@@ -137,7 +141,23 @@ const marksOf = (doc: ProseDocument, lexicon: string): BaseMark[] =>
     entry.position === undefined ? [] : spansOf(doc.source, entry.pattern).map((span) => ({ ...span, position: entry.position ?? "before" })),
   );
 
-export const changeRate: Detector = (doc): Finding[] => {
+const ROLES: readonly string[] = ["base", "current", "rate", "change"] satisfies readonly ColumnRole[];
+const isRole = (group: string | undefined): group is ColumnRole => group !== undefined && ROLES.includes(group);
+
+/** Lexicon change-column: the heading words that say which column holds the earlier value, the later one and the rate. */
+const columnWordsOf = (doc: ProseDocument): ColumnWord[] =>
+  (doc.lexicons["change-column"] ?? []).flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : []));
+
+/** The document's Markdown tables (outside code and quotes): the heading cells and the body rows' cells. */
+const changeTablesOf = (doc: ProseDocument): ChangeTable[] =>
+  tablesOf(linesOf(proseAndTablesOf(doc))).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) }));
+
+const tableIssues = (doc: ProseDocument): StructureIssue[] => {
+  const words = columnWordsOf(doc);
+  return words.length === 0 ? [] : tableRateMismatches(changeTablesOf(doc), words);
+};
+
+const sentenceIssues = (doc: ProseDocument): StructureIssue[] => {
   if (doc.structure === undefined) return [];
   const nodes = quantityNodes(doc.structure);
   const units = patternsOf(doc, "percent-unit");
@@ -155,7 +175,11 @@ export const changeRate: Detector = (doc): Finding[] => {
     breaks: breaksOf(doc),
     source: doc.source,
   };
-  return changeRateMismatches(text).map((issue) => ({
+  return changeRateMismatches(text);
+};
+
+export const changeRate: Detector = (doc): Finding[] =>
+  [...sentenceIssues(doc), ...tableIssues(doc)].map((issue) => ({
     rule: "change-rate-mismatch",
     severity: "warning",
     line: 0,
@@ -163,4 +187,3 @@ export const changeRate: Detector = (doc): Finding[] => {
     quote: quoteAt(doc.source, issue.offset),
     values: { ...issue.values, offset: issue.offset },
   }));
-};

package/src/detectors/closing-balance-mismatch.ts

@@ -0,0 +1,52 @@
+// closing-balance-mismatch: the reading half. Reads tables and each section's label-and-amount lines the way
+// net-amount-mismatch does, with the words of lexicon closing-balance-label, and leaves the deciding to
+// structure/closing-balance.ts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { tablesOf } from "../facts/table-facts.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { labelledLineOf, patternsOf, plainCellsOf, sectionsOf } from "./net-amount-mismatch.ts";
+import { BALANCE_ROLES, sectionClosingMismatch, tableClosingMismatches, type BalanceWords } from "../structure/closing-balance.ts";
+import type { NetIssue } from "../structure/net-amount.ts";
+
+const RULE = "closing-balance-mismatch";
+const LEXICON = "closing-balance-label";
+
+const wordsOf = (doc: ProseDocument): BalanceWords => ({
+  labels: {
+    opening: patternsOf(doc, LEXICON, "opening"),
+    inflow: patternsOf(doc, LEXICON, "inflow"),
+    outflow: patternsOf(doc, LEXICON, "outflow"),
+    closing: patternsOf(doc, LEXICON, "closing"),
+  },
+  magnitudes: patternsOf(doc, "amount-multiplier"),
+  percentUnits: patternsOf(doc, "percent-unit"),
+});
+
+const tableIssues = (lines: readonly Line[], words: BalanceWords): NetIssue[] =>
+  tablesOf(lines).flatMap((table) => tableClosingMismatches(plainCellsOf(table.header), table.rows.map(plainCellsOf), words));
+
+const sectionIssues = (lines: readonly Line[], source: string, words: BalanceWords): NetIssue[] =>
+  sectionsOf(lines, linesOf(source)).flatMap((section) => {
+    const issue = sectionClosingMismatch(section.filter((line) => !line.text.includes("|")).flatMap(labelledLineOf), words);
+    return issue === undefined ? [] : [issue];
+  });
+
+export const closingBalanceMismatch: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  if (BALANCE_ROLES.some((role) => words.labels[role].length === 0)) return [];
+  const lines = linesOf(proseAndTablesOf(doc));
+  const issues = [...tableIssues(lines, words), ...sectionIssues(lines, doc.source, words)];
+  return issues
+    .filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index)
+    .toSorted((left, right) => left.offset - right.offset)
+    .map((issue) => ({
+      rule: RULE,
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));
+};

package/src/detectors/contact-variant.ts

@@ -1,7 +1,10 @@
 // contact-variant: one email address or postal address written two ways in one document (contacts/emails.ts,
-// contacts/addresses.ts). The address labels come from the language's address-label lexicon.
+// contacts/addresses.ts). The address labels come from the language's address-label lexicon; a two-column table row named
+// by one is read as that label's line for addresses (contacts/table-rows.ts); emails in tables stay unread.
 import { addressVariants } from "../contacts/addresses.ts";
 import { emailVariants } from "../contacts/emails.ts";
+import { proseWithLabelledRows } from "../contacts/table-rows.ts";
+import { proseAndTablesOf } from "../table-text.ts";
 import type { Variant, Writing } from "../contacts/variants.ts";
 import { quoteAt } from "./structure-tree.ts";
 import type { Detector, Finding } from "../plugin.ts";
@@ -17,8 +20,11 @@ const findingOf = (source: string, { writing, other }: Variant<Writing>, variant
 });
 
 export const contactVariant: Detector = (doc, options): Finding[] => {
+  const labels = options.lexicon ?? [];
   const text = doc.prose ?? doc.source;
   const emails = emailVariants(text).map((found) => findingOf(doc.source, found));
-  const addresses = addressVariants(text, options.lexicon ?? []).map(({ variant, found }) => findingOf(doc.source, found, variant));
+  const addresses = addressVariants(proseWithLabelledRows(text, proseAndTablesOf(doc), labels), labels).map(({ variant, found }) =>
+    findingOf(doc.source, found, variant),
+  );
   return [...emails, ...addresses].toSorted((a, b) => Number(a.values?.["offset"]) - Number(b.values?.["offset"]));
 };

package/src/detectors/cumulative-below-current.ts

@@ -0,0 +1,30 @@
+// cumulative-below-current: the reading half. Reads the document's Markdown tables and the lexicon cumulative-table, and
+// leaves the deciding to structure/cumulative-below-current.ts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { cumulativeBelowCurrent, type CumulativeRole, type CumulativeWord } from "../structure/cumulative-below-current.ts";
+
+const RULE = "cumulative-below-current";
+const ROLES: readonly string[] = ["current", "cumulative", "prior", "level"] satisfies readonly CumulativeRole[];
+const isRole = (group: string | undefined): group is CumulativeRole => group !== undefined && ROLES.includes(group);
+
+/** Lexicon cumulative-table: the heading words of the this-period and cumulative columns, and the row labels of levels. */
+const wordsOf = (doc: ProseDocument): CumulativeWord[] =>
+  (doc.lexicons["cumulative-table"] ?? []).flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : []));
+
+export const cumulativeBelow: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  if (words.length === 0) return [];
+  const tables = tablesOf(linesOf(proseAndTablesOf(doc))).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) }));
+  return cumulativeBelowCurrent(tables, words).map((issue) => ({
+    rule: RULE,
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/currency-column.ts

@@ -0,0 +1,37 @@
+// currency-column-mix: the reading half. The amounts and their currencies are currency-notation's, read with
+// amount-multiplier's words of scale; the heading words of a column of currencies or exchange rates are currency-column's.
+// The deciding is structure/currency-column.ts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { currencyColumnMix, type CurrencyColumnWords } from "../structure/currency-column.ts";
+import { amountsIn, formsOf } from "./currency-notation.ts";
+
+const RULE = "currency-column-mix";
+
+const wordsOf = (doc: ProseDocument): CurrencyColumnWords => {
+  const forms = formsOf(doc);
+  const multipliers = (doc.lexicons["amount-multiplier"] ?? []).map((entry) => entry.pattern);
+  return {
+    currencies: forms.map((form) => ({ pattern: form.pattern, currency: form.currency })),
+    columns: (doc.lexicons["currency-column"] ?? []).map((entry) => entry.pattern),
+    amountCurrencies: (text) => amountsIn(text, forms, multipliers).map((amount) => amount.currency),
+  };
+};
+
+export const currencyColumnMixDetector: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  if (words.currencies.length === 0) return [];
+  const text = proseAndTablesOf(doc);
+  const tables = tablesOf(linesOf(text)).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) }));
+  return currencyColumnMix(tables, words).map((issue) => ({
+    rule: RULE,
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(text, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/date-any-year.ts

@@ -0,0 +1,130 @@
+// A yearless date that is no date of one year: a day that comes round every year (毎年4月1日, 年末年始（12月29日～1月3日）,
+// "each December 31") or a date in a worked example (例えば…4月1日, "e.g. March 31"). There is no year to write. Pure.
+
+/** The words that make a yearless date any year's: a recurring day or a worked example. Their `group` says where they reach. */
+export const ANY_YEAR_MARKER_LEXICON = "any-year-marker";
+
+/** The words that join the two ends of a period (から, ～, "to"): 「4月1日から翌年3月31日まで」 is every year's. */
+export const YEAR_SPAN_JOINER_LEXICON = "year-span-joiner";
+
+/**
+ * Where a marker reaches. `sentence`: earlier in the date's sentence, not closed off by a bracket (例えば…4月1日), or the
+ * line a list of dates hangs from ("for example:"). `adjacent`: just before the date ("each December 31"). `label`: before
+ * the bracket the date is in (年末年始閉庁日（12月29日～1月3日）).
+ */
+export type MarkerReach = "sentence" | "adjacent" | "label";
+
+export type AnyYearMarker = { readonly word: string; readonly reach: MarkerReach };
+
+/** The span of a yearless date in the source. */
+export type DateSpan = { readonly offset: number; readonly end: number };
+
+/** How far apart the two ends of a period may stand: the joiner and a year word (「から翌年」, " to "). */
+const SPAN_GAP_REACH = 12;
+
+/** How many lines above a list item its introducing line is looked for: a longer list is read as no example. */
+const LIST_REACH = 64;
+
+/** The end of a sentence: 。, a line break, or a full stop before a capital or a digit ("Mar 3. The", "so. 10 November"). */
+const SENTENCE_END = /[。！？\n]|[.!?]["'”’)\]]*\s+(?=[A-Z0-9])/u;
+const OPENERS = "(（「『[【〔";
+const CLOSERS = ")）」』]】〕";
+/** What ends a bracket's label, going back from the bracket: a comma, a full stop, another bracket. */
+const LABEL_END = /[、，,。．\n(（「『[【〔)）」』\]】〕]/u;
+const LIST_ITEM = /^\s*(?:[-*+・]|\d+[.)．])\s/u;
+const LETTER = /\p{L}/u;
+const LATIN_START = /^[A-Za-z]/u;
+const LATIN_END = /[A-Za-z]$/u;
+const COLON_END = /[:：]$/u;
+
+/** Lower case for Latin letters only, so every offset in the text stays where it was ("For example" finds "for example"). */
+const latinLower = (text: string): string => text.replace(/[A-Z]/gu, (char) => char.toLowerCase());
+
+const lineStart = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
+
+/** A word of letters ("each") starts a word; 「例えば」 may follow anything. */
+const startsWord = (text: string, index: number, word: string): boolean => !LATIN_START.test(word) || index === 0 || !LETTER.test(text.charAt(index - 1));
+
+/** "to" in "today": a word of letters that runs on past its end. */
+const runsOn = (text: string, word: string): boolean => LATIN_END.test(word) && LETTER.test(text.charAt(word.length));
+
+const lastWordAt = (text: string, word: string): number => {
+  const found = text.lastIndexOf(word);
+  if (found === -1 || (startsWord(text, found, word) && !runsOn(text.slice(found), word))) return found;
+  return lastWordAt(text.slice(0, found), word);
+};
+
+const depthStep = (char: string): number => (OPENERS.includes(char) ? 1 : 0) - (CLOSERS.includes(char) ? 1 : 0);
+
+/** A bracket closes in the text without opening in it: what came before it is cut off from what comes after. */
+const closesBracket = (text: string): boolean => [...text].reduce((depth, char) => (depth < 0 ? depth : depth + depthStep(char)), 0) < 0;
+
+/** `dateStart` is the date's first character: a full stop just before "10 November" ends a sentence only by what follows it. */
+const inSentence = (before: string, dateStart: string, word: string): boolean => {
+  const found = lastWordAt(latinLower(before), word);
+  if (found === -1) return false;
+  const between = before.slice(found + word.length);
+  return !SENTENCE_END.test(`${between}${dateStart}`) && !closesBracket(between);
+};
+
+const isAdjacent = (before: string, word: string): boolean => {
+  const trimmed = before.trimEnd();
+  return trimmed.endsWith(word) && startsWord(trimmed, trimmed.length - word.length, word);
+};
+
+/** Where the bracket still open at the end of the text opens. */
+const openBracketAt = (text: string): number | undefined =>
+  [...text]
+    .reduce<number[]>((open, char, index) => {
+      const step = depthStep(char);
+      if (step > 0) return [...open, index];
+      return step < 0 ? open.slice(0, -1) : open;
+    }, [])
+    .at(-1);
+
+/** The text from the bracket the date is in back to the end of the clause before it: 「年末年始閉庁日」 of 「年末年始閉庁日（12月29日」. */
+const labelOf = (before: string): string | undefined => {
+  const opener = openBracketAt(before);
+  if (opener === undefined) return undefined;
+  const head = [...before].slice(0, opener);
+  return head.slice(head.findLastIndex((char) => LABEL_END.test(char)) + 1).join("");
+};
+
+/** The line a list's run of items hangs from: back over the run and the blank lines before it. */
+const introducingLine = (lines: readonly string[]): string | undefined => {
+  const above = lines.slice(0, lines.findLastIndex((line) => !LIST_ITEM.test(line)) + 1);
+  return above.findLast((line) => line.trim() !== "");
+};
+
+/** Where the line `lines` lines above the one at `offset` starts (or the text, if it starts sooner). */
+const startLinesBack = (source: string, offset: number, lines: number): number => {
+  const previous = source.lastIndexOf("\n", offset - 1);
+  return previous === -1 || lines === 0 ? previous + 1 : startLinesBack(source, previous, lines - 1);
+};
+
+/** The line a list item's list hangs from ("we use 'to' in date ranges – for example:"), looked for within LIST_REACH lines. */
+const introOf = (source: string, before: string, offset: number): string | undefined =>
+  LIST_ITEM.test(before) ? introducingLine(source.slice(startLinesBack(source, offset, LIST_REACH), offset).split("\n"))?.trimEnd() : undefined;
+
+/** The line ends with the marker, before or after its colon: 「例：」 and "for example:" alike. */
+const introEndsWith = (intro: string, word: string): boolean => isAdjacent(intro, word) || isAdjacent(intro.replace(COLON_END, ""), word);
+
+/** The date is a recurring day or a worked example: a marker stands where its reach covers the date. */
+export const anyYearDate = (date: DateSpan, source: string, markers: readonly AnyYearMarker[]): boolean => {
+  const before = source.slice(lineStart(source, date.offset), date.offset);
+  const intro = introOf(source, before, date.offset);
+  return markers.some(({ word: written, reach }) => {
+    const word = latinLower(written);
+    if (word === "") return false;
+    if (reach === "adjacent") return isAdjacent(latinLower(before), word);
+    if (reach === "label") return latinLower(labelOf(before) ?? "").includes(word);
+    return inSentence(before, source.charAt(date.offset), word) || (intro !== undefined && introEndsWith(latinLower(intro), word));
+  });
+};
+
+/** The date opens a period whose other end, just after it, follows a joiner (「4月1日から翌年3月31日」). */
+export const opensSpan = (date: DateSpan, next: DateSpan | undefined, source: string, joiners: readonly string[]): boolean => {
+  if (next === undefined || next.offset - date.end > SPAN_GAP_REACH) return false;
+  const gap = source.slice(date.end, next.offset).trimStart();
+  return !SENTENCE_END.test(gap) && joiners.some((joiner) => joiner !== "" && gap.startsWith(joiner) && !runsOn(gap, joiner));
+};

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

@@ -1,26 +1,20 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { datesOutsidePeriod, type OutsideWords } from "../structure/date-outside-period.ts";
-import { rangeFrameOf } from "../structure/date-range.ts";
+import { periodWordsOf } from "./range-words.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
-/** 期間の語、期間の外に置く語、文書の仕事の期間の語、締め切りの語、期間の後に来てよい仕事の語、概要の節の見出しの語、範囲の記号（range-connector、range-opener、range-frame の間の語）、月と曜日の名は語彙表から取る。 */
+/** 期間の語、期間の外に置く語、文書の仕事の期間の語、締め切りの語、期間の後に来てよい仕事の語、日付を締め切りにする語、概要の節の見出しの語、範囲の記号（range-connector、range-opener、range-frame の間の語）、月と曜日の名は語彙表から取る。 */
 const wordsOf = (doc: ProseDocument): OutsideWords => ({
-  labels: patternsOf(doc, "period-label"),
+  ...periodWordsOf(doc, patternsOf(doc, "period-label")),
   terms: patternsOf(doc, "period-term-label"),
   asides: patternsOf(doc, "period-aside"),
   deadlines: patternsOf(doc, "period-deadline"),
   overviews: patternsOf(doc, "period-overview-heading"),
   afterTerm: patternsOf(doc, "period-after-term"),
-  connectors: [
-    ...patternsOf(doc, "range-connector"),
-    ...patternsOf(doc, "range-opener"),
-    ...patternsOf(doc, "range-frame").flatMap((pattern) => rangeFrameOf(pattern)?.joint ?? []),
-  ],
-  months: patternsOf(doc, "month-name"),
-  weekdays: patternsOf(doc, "weekday"),
+  deadlineMarks: doc.lexicons["date-deadline-mark"] ?? [],
 });
 
 /** 書いた期間（旅行期間：…）の外の日付を持つ、その後ろの日程の項目、表の行、見出し。 */

package/src/detectors/date-stamp-order.ts

@@ -5,6 +5,7 @@ import { inDocumentOrder } from "../structure/issues.ts";
 import { stampOrderIssues } from "../structure/stamp-order.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { readableDates, withReadableDates } from "./readable-dates.ts";
 
 export const dateStampOrder: Detector = (doc, options): Finding[] => {
   if (doc.structure === undefined) return [];
@@ -21,7 +22,7 @@ export const dateStampOrder: Detector = (doc, options): Finding[] => {
       line: 0,
       column: 0,
       quote: quoteAt(doc.source, offset),
-      values: { ...dated, offset },
+      values: { ...withReadableDates(dated, ["established", "updated"], readableDates(doc)), offset },
       ...(side === undefined ? {} : { variant: String(side) }),
     };
   });

package/src/detectors/date-year.ts

@@ -1,13 +1,22 @@
-// A date written without its year where the document's other dates carry one, or where the year cannot be read off
-// because the document's dates cross the turn of a year. Pure; reads the date nodes of the structure tree.
+// A date written without its year where the reader cannot tell which year it is: the document's dated dates span more
+// than one year, or its dates cross the turn of a year. Pure; reads the date nodes of the structure tree.
 import type { Detector, Finding, LexiconEntry, ProseDocument, StructureNode } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { ANY_YEAR_MARKER_LEXICON, YEAR_SPAN_JOINER_LEXICON, anyYearDate, opensSpan, type AnyYearMarker, type MarkerReach } from "./date-any-year.ts";
+
+/** The words that make a yearless date any year's (毎年, 例えば, "each") and that join a period's two ends (から, "to"). */
+export type AnyYearWords = { readonly markers: readonly AnyYearMarker[]; readonly joiners: readonly string[] };
+
+const NO_ANY_YEAR_WORDS: AnyYearWords = { markers: [], joiners: [] };
 
 /** A date as the tree reads it: "2026-10-14" with its year, "10-14" without. */
 export type DatePoint = { readonly offset: number; readonly end: number; readonly value: string };
 
-export type YearGap = { readonly point: DatePoint; readonly kind: "minority" | "boundary"; readonly dated: number };
+/** The first and the last year of the document's dated dates. */
+export type YearSpan = { readonly from: number; readonly to: number };
+
+export type YearGap = { readonly point: DatePoint; readonly kind: "years" | "boundary"; readonly span: YearSpan | undefined };
 
 /**
  * The words beside a date that give its year in words (その年の, 同年, 毎年; "of each year"): the date has a year, or means
@@ -30,6 +39,14 @@ const YEAR_WORD_REACH = 6;
 const YEAR_END = new Set([11, 12]);
 const YEAR_START = new Set([1, 2]);
 
+const yearOf = (value: string): number => Number(value.slice(0, 4));
+
+const spanOf = (dated: readonly DatePoint[]): YearSpan | undefined => {
+  if (dated.length === 0) return undefined;
+  const years = dated.map((point) => yearOf(point.value));
+  return { from: Math.min(...years), to: Math.max(...years) };
+};
+
 const monthOf = (pattern: RegExp, value: string): number | undefined => {
   const month = pattern.exec(value)?.[1];
   return month === undefined ? undefined : Number(month);
@@ -93,20 +110,34 @@ const yearGiven = (point: DatePoint, anchors: readonly DatePoint[], source: stri
 };
 
 /**
- * The yearless dates to report. Where most dates carry a year (at least two, and more than the yearless ones), every yearless
- * one is the odd one out. Otherwise writing the year once is the document's style, and only a date across the turn of a
- * year is reported. A date whose year the text gives in words or earlier on its line is never reported, nor counted.
+ * The yearless dates whose year the reader cannot tell. Where most dates carry a year (at least two, and more than the
+ * yearless ones) and those years differ, every yearless one is reported: in a one-year document the year is plain. Where
+ * the year is written once and the rest are month and day, that is the document's style, and only a date across the turn
+ * of a year is reported. A date whose year the text gives in words or earlier on its line is never reported, nor counted.
  */
-export const yearGaps = (points: readonly DatePoint[], source = "", yearWords: readonly YearWord[] = []): YearGap[] => {
+export const yearGaps = (
+  points: readonly DatePoint[],
+  source = "",
+  yearWords: readonly YearWord[] = [],
+  anyYear: AnyYearWords = NO_ANY_YEAR_WORDS,
+): YearGap[] => {
   const dated = points.filter((point) => FULL.test(point.value));
   const anchors = [...dated, ...points.filter((point) => hasYearWord(point, source, yearWords))];
-  const yearless = points.filter((point) => MONTH_DAY.test(point.value) && !yearGiven(point, anchors, source, yearWords));
-  const minority = dated.length >= 2 && yearless.length < dated.length;
+  const nextOf = new Map(points.map((point, index) => [point, points[index + 1]]));
+  const yearOfAny = (point: DatePoint): boolean => {
+    const next = nextOf.get(point);
+    if (anyYearDate(point, source, anyYear.markers)) return true;
+    return next !== undefined && opensSpan(point, next, source, anyYear.joiners) && hasYearWord(next, source, yearWords);
+  };
+  // A recurring day or an example's date has no year to write, and is not the document's way of writing dates either.
+  const yearless = points.filter((point) => MONTH_DAY.test(point.value) && !yearGiven(point, anchors, source, yearWords) && !yearOfAny(point));
+  const span = spanOf(dated);
+  const unclear = dated.length >= 2 && yearless.length < dated.length && span !== undefined && span.to > span.from;
   const datedSides = new Set(dated.flatMap((point) => sideOf(monthOf(FULL, point.value)) ?? []));
   const previousOf = new Map(points.map((point, index) => [point, points[index - 1]]));
   return yearless.flatMap((point): YearGap[] => {
-    if (minority) return [{ point, kind: "minority", dated: dated.length }];
-    return crossesYear(point, previousOf.get(point), datedSides) ? [{ point, kind: "boundary", dated: dated.length }] : [];
+    if (unclear) return [{ point, kind: "years", span }];
+    return crossesYear(point, previousOf.get(point), datedSides) ? [{ point, kind: "boundary", span }] : [];
   });
 };
 
@@ -116,15 +147,26 @@ export const datePoints = (tree: StructureNode): DatePoint[] =>
 const yearWordsOf = (doc: ProseDocument): YearWord[] =>
   (doc.lexicons[YEAR_REFERENCE_LEXICON] ?? []).map((entry: LexiconEntry) => ({ word: entry.pattern, position: entry.position }));
 
+const reachOf = (group: string | undefined): MarkerReach => (group === "adjacent" || group === "label" ? group : "sentence");
+
+const anyYearWordsOf = (doc: ProseDocument): AnyYearWords => ({
+  markers: (doc.lexicons[ANY_YEAR_MARKER_LEXICON] ?? []).map((entry: LexiconEntry) => ({ word: entry.pattern, reach: reachOf(entry.group) })),
+  joiners: (doc.lexicons[YEAR_SPAN_JOINER_LEXICON] ?? []).map((entry: LexiconEntry) => entry.pattern),
+});
+
 export const dateWithoutYear: Detector = (doc: ProseDocument): Finding[] =>
   doc.structure === undefined
     ? []
-    : yearGaps(datePoints(doc.structure), doc.source, yearWordsOf(doc)).map((gap) => ({
+    : yearGaps(datePoints(doc.structure), doc.source, yearWordsOf(doc), anyYearWordsOf(doc)).map((gap) => ({
         rule: "date-without-year",
         severity: "warning",
         line: 0,
         column: 0,
         quote: quoteAt(doc.source, gap.point.offset),
         ...(gap.kind === "boundary" ? { variant: "boundary" } : {}),
-        values: { date: doc.source.slice(gap.point.offset, gap.point.end), count: gap.dated, offset: gap.point.offset },
+        values: {
+          date: doc.source.slice(gap.point.offset, gap.point.end),
+          ...(gap.span === undefined ? {} : { from: gap.span.from, to: gap.span.to }),
+          offset: gap.point.offset,
+        },
       }));

package/src/detectors/deductible-exceeds-limit.ts

@@ -0,0 +1,55 @@
+// deductible-exceeds-limit: the reading half. Takes the words from the lexicons deductible-word, benefit-limit-word,
+// deductible-basis, approximate-marker, range-connector, currency-notation and amount-multiplier, and leaves the deciding to
+// structure/deductible-limit.ts, one sentence at a time, with the structure tree's quantities as the amounts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { sentenceDeductibleOverLimit, type DeductibleWords } from "../structure/deductible-limit.ts";
+import { proseQuantitiesOf } from "../structure/ratio.ts";
+
+const RULE = "deductible-exceeds-limit";
+const NOT = "not";
+
+const entriesOf = (doc: ProseDocument, id: string) => doc.lexicons[id] ?? [];
+const patternsOf = (doc: ProseDocument, id: string, keep: (group: string | undefined) => boolean = () => true): string[] =>
+  entriesOf(doc, id)
+    .filter((entry) => keep(entry.group))
+    .map((entry) => entry.pattern);
+const atSide = (doc: ProseDocument, id: string, position: "before" | "after"): string[] =>
+  entriesOf(doc, id)
+    .filter((entry) => entry.position === position)
+    .map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): DeductibleWords => ({
+  deductibles: patternsOf(doc, "deductible-word", (group) => group !== NOT),
+  limits: patternsOf(doc, "benefit-limit-word", (group) => group !== NOT),
+  notDeductibles: patternsOf(doc, "deductible-word", (group) => group === NOT),
+  notLimits: patternsOf(doc, "benefit-limit-word", (group) => group === NOT),
+  bases: entriesOf(doc, "deductible-basis").flatMap((entry) =>
+    entry.group === undefined ? [] : [{ pattern: entry.pattern, basis: entry.group, rank: entry.weight }],
+  ),
+  approximate: { before: atSide(doc, "approximate-marker", "before"), after: atSide(doc, "approximate-marker", "after") },
+  rangeMarks: patternsOf(doc, "range-connector"),
+  multipliers: entriesOf(doc, "amount-multiplier").flatMap((entry) => (entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }])),
+  amounts: {
+    before: atSide(doc, "currency-notation", "before"),
+    after: atSide(doc, "currency-notation", "after"),
+    multipliers: patternsOf(doc, "amount-multiplier"),
+    percentUnits: patternsOf(doc, "percent-unit"),
+  },
+  currencies: entriesOf(doc, "currency-notation").flatMap((entry) => (entry.group === undefined ? [] : [{ pattern: entry.pattern, currency: entry.group }])),
+});
+
+/** A deductible larger than the most paid for the same benefit, read in one sentence. */
+export const deductibleExceedsLimit: Detector = (doc): Finding[] => {
+  const words = wordsOf(doc);
+  if (words.deductibles.length === 0 || words.limits.length === 0) return [];
+  const quantities = proseQuantitiesOf(doc.structure);
+  return doc.sentences.flatMap((sentence): Finding[] => {
+    const text = doc.source.slice(sentence.span.start, sentence.span.end);
+    const issue = sentenceDeductibleOverLimit(text, sentence.span.start, quantities, words);
+    if (issue === undefined) return [];
+    return [
+      { rule: RULE, severity: "warning", line: 0, column: 0, quote: quoteAt(doc.source, issue.offset), values: { ...issue.values, offset: issue.offset } },
+    ];
+  });
+};

package/src/detectors/defined-term-form.ts

@@ -7,6 +7,7 @@ import { prefixGroupsOf, prefixVariants, variantUses } from "../structure/term-p
 import { quoteAt } from "./structure-tree.ts";
 import { isPartOfAddress } from "./address-word.ts";
 import { exactOffsets, extendedAfter, extendedBefore } from "./term-extension.ts";
+import { CLOSES_SENTENCE, isNameField, isSignatureLine, opensClosingBlock, SLACK } from "./name-field.ts";
 import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
 const bodyOf = (doc: ProseDocument): BodyText[] => doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
@@ -238,26 +239,6 @@ const bracketBefore = (source: string, definition: Span): number => {
 
 export type RepeatedName = { readonly offset: number; readonly name: string; readonly term: string; readonly line: number };
 
-/** How many characters a line may add to the long name and still be a line that only names the party. */
-const SLACK = 12;
-
-/** A field label on its own line, after a list marker (Attention:, 宛先：): short, and not a sentence. */
-const FIELD_LABEL = /^(?:[-*+]\s+)?[^:：。.]{1,20}[:：]\s*/u;
-/**
- * What may follow the name in an address field: nothing, a comma and the next part (, Member Support), or a space and a part
- * that does not go on in lower case (株式会社みなと 総務部). A particle or a verb (は支払う, shall pay) makes the line a sentence.
- */
-const NEXT_PART = /^\.?(?:$|\s*[,、，]|\s+(?!\p{Ll}))/u;
-const CLOSES_SENTENCE = /[.。!?！？]$/u;
-
-/** A field whose value is the name and a little more, not a sentence (Attention: Hibari Lab Inc., Member Support). */
-const isNameField = (line: string, name: string): boolean => {
-  const label = FIELD_LABEL.exec(line);
-  const value = label === null ? "" : line.slice(label[0].length);
-  const rest = value.slice(name.length);
-  return value.startsWith(name) && NEXT_PART.test(rest) && [...rest].length <= SLACK * 2 && !CLOSES_SENTENCE.test(rest.slice(1));
-};
-
 /** A contact field's label: after a bullet or a number (1. 連絡先：), and as long as a label in English runs (Privacy Contact:). */
 const CONTACT_LABEL = /^(?:(?:[-*+]|\d+[.)])\s+)?([^:：。.]{1,40})[:：]\s*/u;
 const LABEL_MARKS = /[*_\s]+/gu;
@@ -288,17 +269,19 @@ const isContactField = (line: string, name: string, contactLabels: readonly stri
 
 /**
  * A line that holds the short name too (甲 株式会社みなと), little else than the long name (a signature block names both),
- * or a field whose value is the name (Attention: …, 宛先：…): an address gives the name in full.
+ * or a field whose value is the name (Attention: …, 宛先：…), or a signature opening the closing block: an address gives the name in full.
  */
 const isNameLine = (source: string, offset: number, name: string, term: string, contactLabels: readonly string[]): boolean => {
   const start = source.lastIndexOf("\n", offset - 1) + 1;
-  const end = source.indexOf("\n", offset);
-  const line = source.slice(start, end === -1 ? source.length : end).trim();
+  const newline = source.indexOf("\n", offset);
+  const end = newline === -1 ? source.length : newline;
+  const line = source.slice(start, end).trim();
   // The short name inside the long one ("Pinecone" in "Pinecone Software Ltd") is not the short name written beside it.
   return (
     line.replaceAll(name, "").includes(term) ||
     [...line].length <= [...name].length + SLACK ||
     isNameField(line, name) ||
+    (isSignatureLine(line, name) && opensClosingBlock(source, start, end)) ||
     isContactField(line, name, contactLabels)
   );
 };