chaffjs 0.30.0 → 0.32.0

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 }));
@@ -23,8 +24,8 @@ const finding = (doc: ProseDocument, rule: string, offset: number, variant: stri
 
 const OPENING_QUOTES = new Set(["「", "『", '"', "“"]);
 const CLOSING_QUOTES = new Set(["」", "』", '"', "”"]);
-/** A quoted term right before these is defined again (「X」とは, "X" means), which duplicate-definition reads. */
-const DEFINING_AFTER = /^(?:とは|という|\s+(?:means|shall mean|refers to|has the meaning))/u;
+/** A quoted term right before these is defined again (「X」とは, 「X」といいます, "X" means), which duplicate-definition reads. */
+const DEFINING_AFTER = /^(?:とは|という|といい(?:ます)?(?=[。、，）)\s]|$)|\s+(?:means|shall mean|refers to|has the meaning))/u;
 /** The ending a use may carry past the term: a plural or a possessive (Services, Service's). */
 const WORD_ENDING = /^(?:e?s|['’]s?)/u;
 
@@ -238,14 +239,51 @@ const bracketBefore = (source: string, definition: Span): number => {
 
 export type RepeatedName = { readonly offset: number; readonly name: string; readonly term: string; readonly line: number };
 
-/** A line that holds the short name too (甲 株式会社みなと) or little else than the long name: a signature block names both. */
-const isNameLine = (source: string, offset: number, name: string, term: string): boolean => {
+/** 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;
+/** After the name in a contact field, the next part after a space or a comma (, Tokyo), or the bracket that holds it (お問い合わせ窓口（株式会社みなと）). */
+const NEXT_CONTACT_PART = /^\.?(?:$|[）)]|\s*,?\s+(?!\p{Ll}))/u;
+/** A comma that goes on in lower case or 、 may also start a clause (, which may; 株式会社みなと、平日に受け付ける): the address field's bound. */
+const COMMA_PART = /^\.?\s*[,、，]/u;
+
+const endsWithContactLabel = (label: string, contactLabels: readonly string[]): boolean => {
+  const bare = label.replaceAll(LABEL_MARKS, "").toLowerCase();
+  return contactLabels.some((contact) => contact !== "" && bare.endsWith(contact.toLowerCase()));
+};
+
+/**
+ * A field whose label ends with a contact label (窓口：, Attention:): the value names the party in full however long it is and
+ * wherever the name sits in it, unless the name goes on as a sentence (連絡先：株式会社みなとは、…).
+ */
+const isContactField = (line: string, name: string, contactLabels: readonly string[]): boolean => {
+  const label = CONTACT_LABEL.exec(line);
+  if (label === null || !endsWithContactLabel(label[1] ?? "", contactLabels)) return false;
+  const value = line.slice(label[0].length);
+  const at = value.indexOf(name);
+  if (at === -1) return false;
+  const rest = value.slice(at + name.length);
+  const continues = NEXT_CONTACT_PART.test(rest) || (COMMA_PART.test(rest) && [...rest].length <= SLACK * 2);
+  return continues && !CLOSES_SENTENCE.test(rest.slice(1));
+};
+
+/**
+ * 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: …, 宛先：…), 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 SLACK = 12;
+  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;
+  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)
+  );
 };
 
 /** A name inside a longer word (東京大学 in 東京大学大学院, Acme in Acmeware) is part of another name. */
@@ -267,6 +305,7 @@ export const standsAlone = (source: string, offset: number, name: string, joiner
 export const repeatedNames = (doc: ProseDocument, terms: readonly DefinedTerm[]): RepeatedName[] => {
   const defined = new Set(terms.map((term) => term.term));
   const joiners = (doc.lexicons["enumeration-joiner"] ?? []).map((entry) => entry.pattern);
+  const contactLabels = (doc.lexicons["contact-label"] ?? []).map((entry) => entry.pattern);
   return terms
     .filter((term) => term.inline)
     .flatMap((term) => {
@@ -278,7 +317,7 @@ export const repeatedNames = (doc: ProseDocument, terms: readonly DefinedTerm[])
       return doc.sentences
         .filter((later) => later.span.start > term.span.end)
         .flatMap((later) => [...later.text.matchAll(pattern)].map((match) => later.span.start + match.index))
-        .filter((offset) => standsAlone(doc.source, offset, name, joiners) && !isNameLine(doc.source, offset, name, term.term))
+        .filter((offset) => standsAlone(doc.source, offset, name, joiners) && !isNameLine(doc.source, offset, name, term.term, contactLabels))
         .map((offset) => ({ offset, name, term: term.term, line: term.line }));
     });
 };

package/src/detectors/definition-use.ts

@@ -22,11 +22,15 @@ const findingAt = (doc: ProseDocument, offset: number, values: Readonly<Record<s
   values: { ...values, offset },
 });
 
-/** 定義したのに、定義の外で一度も使っていない語。 */
+/** Markdown の見出し。文には入らないが、見出しで語を使っても、その語は文書で使われている。 */
+const headingsOf = (doc: ProseDocument): BodyText[] =>
+  (doc.markup?.headings ?? []).map((heading) => ({ start: heading.start, text: doc.source.slice(heading.start, heading.end) }));
+
+/** 定義したのに、定義の外（文と見出し）で一度も使っていない語。 */
 export const unusedDefinition: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : unusedDefinitions(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc)).map((defined) =>
+    : unusedDefinitions(definedTerms(doc.structure), [...bodyOf(doc), ...headingsOf(doc)], mentionedIn(doc)).map((defined) =>
         findingAt(doc, defined.span.start, { term: defined.term }),
       );
 

package/src/detectors/derived-numbers.ts

@@ -6,6 +6,7 @@ import { yearOf, type DurationUnit } from "../derived/date-arithmetic.ts";
 import { durationMismatches, type DatedValue, type Duration } from "../derived/durations.ts";
 import { elapsedMismatches, type Elapsed, type OriginWord, type Year } from "../derived/elapsed.ts";
 import { numberWordCounts } from "../derived/number-word-counts.ts";
+import { hyphenatedCounts, withoutArticle } from "../derived/hyphenated-counts.ts";
 import {
   nightsDaysMismatches,
   nightsDaysPairs,
@@ -16,25 +17,25 @@ import {
   type StayColumnWords,
 } from "../derived/stays.ts";
 import { numeralCounts } from "../derived/unit-counts.ts";
-import { timeLengths, type LengthWords, type TimeLength } from "../derived/time-lengths.ts";
-import { workingHoursMismatches, type WorkingHoursMismatch } from "../derived/working-hours.ts";
 import { sessionHoursMismatches } from "../derived/session-hours.ts";
-import { clockTimes } from "../compare/clock-time.ts";
-import { secondsOf, type Mark } from "../structure/time-marks.ts";
+import { computedLength } from "../derived/hours-and-minutes.ts";
+import { lengthsOf, workingHoursFindings } from "./working-hours-findings.ts";
+import type { Mark } from "../structure/time-marks.ts";
 import { proseAndTablesOf } from "../table-text.ts";
-import { quoteAt } from "./structure-tree.ts";
+import { quoteAt, rangeWordsOf } from "./structure-tree.ts";
+import { readableDates } from "./readable-dates.ts";
 
 /** 期間の単位の語彙表。木の数量の単位がどれかに入れば、その単位の期間。 */
-const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
+export const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
   ["duration-day", "day"],
   ["duration-week", "week"],
   ["duration-month", "month"],
   ["duration-year", "year"],
 ];
 
-type Quantity = Span & { readonly amount: number; readonly unit: string };
+export type Quantity = Span & { readonly amount: number; readonly unit: string; readonly attributive?: true };
 
-const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+const patternsOf = (doc: ProseDocument, ...ids: string[]): string[] => ids.flatMap((id) => (doc.lexicons[id] ?? []).map((entry) => entry.pattern));
 
 const positioned = (doc: ProseDocument, id: string, position: "before" | "after"): string[] =>
   (doc.lexicons[id] ?? []).filter((entry) => (entry.position ?? "before") === position).map((entry) => entry.pattern.toLowerCase());
@@ -62,7 +63,7 @@ const withWordsAround = (source: string, start: number, end: number, unit: strin
   return wordStart === undefined ? { start, end: endWithUnit(source, end, unit) } : { start: wordStart, end: endWithUnit(source, end + 1, unit) };
 };
 
-const quantitiesOf = (tree: StructureNode, source: string): Quantity[] =>
+export const quantitiesOf = (tree: StructureNode, source: string): Quantity[] =>
   inDocumentOrder(tree).flatMap((node): Quantity[] => {
     if (node.kind !== "quantity") return [];
     const unit = String(node.attrs["unit"] ?? "");
@@ -74,11 +75,11 @@ const datesOf = (tree: StructureNode): DatedValue[] =>
 
 const NEAR = 12;
 
-const textBefore = (doc: ProseDocument, span: Span): string =>
-  doc.source
-    .slice(Math.max(0, span.start - NEAR), span.start)
-    .toLowerCase()
-    .trimEnd();
+type Attributed = Span & { readonly attributive?: boolean };
+
+/** 名詞の前の期間は、冠詞の前まで見る（up to a 3-night stay の up to）。 */
+const textBefore = (doc: ProseDocument, span: Attributed): string =>
+  withoutArticle(doc.source.slice(Math.max(0, span.start - NEAR), span.start).toLowerCase(), span.attributive === true ? patternsOf(doc, "article") : []);
 const textAfter = (doc: ProseDocument, span: Span): string =>
   doc.source
     .slice(span.end, span.end + NEAR)
@@ -86,19 +87,19 @@ const textAfter = (doc: ProseDocument, span: Span): string =>
     .trimStart();
 
 /** 「約3か月」「3か月程度」"about 3 months": 目安の期間は足し算に使わない。 */
-const isApproximate = (doc: ProseDocument, span: Span): boolean =>
+const isApproximate = (doc: ProseDocument, span: Attributed): boolean =>
   positioned(doc, "approximate-marker", "before").some((word) => textBefore(doc, span).endsWith(word)) ||
   positioned(doc, "approximate-marker", "after").some((word) => textAfter(doc, span).startsWith(word));
 
-const durationsOf = (doc: ProseDocument, quantities: readonly Quantity[]): Duration[] =>
-  quantities.flatMap((quantity) => {
+/** 木の数量（3 months）と、名詞の前に書いた期間（a 3-month trial）。 */
+const durationsOf = (doc: ProseDocument, quantities: readonly Quantity[], text: string): Duration[] =>
+  [...quantities, ...hyphenatedCounts(text, patternsOf(doc, ...DURATION_LEXICONS.map(([id]) => id)))].flatMap((quantity) => {
     const unit = DURATION_LEXICONS.find(([id]) => patternsOf(doc, id).some((pattern) => pattern.normalize("NFKC") === quantity.unit))?.[1];
-    return unit === undefined || isApproximate(doc, quantity) ? [] : [{ start: quantity.start, end: quantity.end, amount: quantity.amount, unit }];
+    return unit === undefined || isApproximate(doc, quantity) ? [] : [{ ...quantity, unit }];
   });
 
 const sentencesOf = (doc: ProseDocument): Span[] => doc.sentences.map((sentence) => sentence.span);
 
-/** 泊数（3泊、3 nights、three nights）。text は地の文と表（リンク先や code は読まない）。目安の泊数（最大3泊）は除く。 */
 /** 数と単位（3泊、15 sessions、three nights）。 */
 const unitCountsOf = (doc: ProseDocument, text: string, units: readonly string[]): Count[] => {
   const numerals = numeralCounts(text, units);
@@ -107,8 +108,9 @@ const unitCountsOf = (doc: ProseDocument, text: string, units: readonly string[]
   return [...numerals, ...worded].toSorted((left, right) => left.start - right.start);
 };
 
-const nightsOf = (doc: ProseDocument, text: string): Count[] =>
-  unitCountsOf(doc, text, patternsOf(doc, "stay-night")).filter((count) => !isApproximate(doc, count));
+/** 泊数（3泊、3 nights、three nights、名詞の前の a 3-night stay）。text は地の文と表（リンク先や code は読まない）。目安の泊数（最大3泊）は除く。 */
+const nightsOf = (doc: ProseDocument, text: string, units = patternsOf(doc, "stay-night")): Count[] =>
+  [...unitCountsOf(doc, text, units), ...hyphenatedCounts(text, units)].filter((count) => !isApproximate(doc, count));
 
 const finding = (doc: ProseDocument, offset: number, values: Record<string, string | number>, variant?: string): Finding => ({
   rule: "duration-mismatch",
@@ -140,60 +142,12 @@ const stayColumnWords = (doc: ProseDocument): StayColumnWords => ({
 const marksOf = (doc: ProseDocument, id: string): Mark[] =>
   (doc.lexicons[id] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position, group: entry.group }));
 
-const SECONDS_PER_HOUR = 3600;
-const SECONDS_PER_MINUTE = 60;
-
-/** The hour and minute units of unit-time, told apart by their weight in seconds. */
-const unitsWeighing = (doc: ProseDocument, seconds: number): string[] =>
-  (doc.lexicons["unit-time"] ?? []).filter((entry) => entry.weight === seconds).map((entry) => entry.pattern);
-
-const lengthWords = (doc: ProseDocument): LengthWords => ({
-  hourUnits: unitsWeighing(doc, SECONDS_PER_HOUR),
-  minuteUnits: unitsWeighing(doc, SECONDS_PER_MINUTE),
-  halves: patternsOf(doc, "length-half"),
-  numberWords: patternsOf(doc, "count-number"),
-});
-
-const lengthsOf = (doc: ProseDocument, text: string): TimeLength[] => timeLengths(text, lengthWords(doc));
-
-const MINUTES_PER_HOUR = 60;
-const HOUR_DECIMALS = 100;
-
-const hoursOf = (minutes: number): number => Math.round((minutes / MINUTES_PER_HOUR) * HOUR_DECIMALS) / HOUR_DECIMALS;
-
-const workingHoursFinding = (doc: ProseDocument, mismatch: WorkingHoursMismatch): Finding =>
-  finding(
-    doc,
-    mismatch.total.start,
-    {
-      start: written(doc, mismatch.start),
-      end: written(doc, mismatch.end),
-      break: written(doc, mismatch.break),
-      total: written(doc, mismatch.total),
-      expected: hoursOf(mismatch.expected),
-    },
-    "working-hours",
-  );
-
-/** 始業から終業まで、休憩を除いた時間が、書いた実働と合わない。 */
-const workingHoursOf = (doc: ProseDocument, text: string): Finding[] => {
-  const times = clockTimes(text).map((time) => ({ start: time.start, end: time.end, seconds: secondsOf(time.key) }));
-  const words = {
-    joiners: patternsOf(doc, "clock-range-joiner"),
-    dayShifts: marksOf(doc, "day-shift-mark"),
-    breaks: marksOf(doc, "working-hours-break"),
-    totals: marksOf(doc, "working-hours-total"),
-    approximate: marksOf(doc, "approximate-marker"),
-  };
-  return workingHoursMismatches(text, doc.source, sentencesOf(doc), times, lengthsOf(doc, text), words).map((mismatch) => workingHoursFinding(doc, mismatch));
-};
-
 /** 始まり + 期間 ≠ 終わり。泊数が二つの日付の差と合わない。「2泊3日」の日数が泊数より一つ多くない。 */
 export const durationMismatch: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const dates = datesOf(doc.structure);
-  const durations = durationsOf(doc, quantitiesOf(doc.structure, doc.source));
   const proseAndTables = proseAndTablesOf(doc);
+  const durations = durationsOf(doc, quantitiesOf(doc.structure, doc.source), proseAndTables);
   const nights = nightsOf(doc, proseAndTables);
   const pairs = nightsDaysPairs(
     doc.source,
@@ -206,19 +160,20 @@ export const durationMismatch: Detector = (doc): Finding[] => {
     sentencesOf(doc),
     dates,
     durations.filter((duration) => !overlapsAny(pairedDays, duration)),
+    { source: doc.source, joiners: patternsOf(doc, "clock-range-joiner"), weekdays: patternsOf(doc, "weekday"), range: rangeWordsOf(doc) },
   ).map((mismatch) =>
     finding(doc, mismatch.end.start, {
       start: written(doc, mismatch.start),
       duration: written(doc, mismatch.duration),
       end: written(doc, mismatch.end),
-      expected: mismatch.expected,
+      expected: readableDates(doc)(mismatch.expected),
     }),
   );
   const stays = [...stayNightsMismatches(sentencesOf(doc), dates, nights), ...tableNightsMismatches(proseAndTables, dates, stayColumnWords(doc))];
   const nightsDays = nightsDaysMismatches(pairs).map((mismatch) =>
     finding(doc, mismatch.days.start, { nights: written(doc, mismatch.nights), days: written(doc, mismatch.days), expected: mismatch.expected }, "nights-days"),
   );
-  return [...lengths, ...stays.map((mismatch) => nightsFinding(doc, mismatch)), ...nightsDays, ...workingHoursOf(doc, proseAndTables)];
+  return [...lengths, ...stays.map((mismatch) => nightsFinding(doc, mismatch)), ...nightsDays, ...workingHoursFindings(doc, proseAndTables, finding)];
 };
 
 /** 番号の書き方（ordinal-frame）の頭の語のすぐ後ろの数。「第15回」は15番目の回で、15回ではない。 */
@@ -233,20 +188,27 @@ export const durationProductMismatch: Detector = (doc): Finding[] => {
   const text = proseAndTablesOf(doc);
   const counts = unitCountsOf(doc, text, patternsOf(doc, "session-count-unit")).filter((count) => !isOrdinal(doc, text, count));
   const words = { totals: marksOf(doc, "session-total"), approximate: marksOf(doc, "approximate-marker") };
-  return sessionHoursMismatches(text, doc.source, sentencesOf(doc), counts, lengthsOf(doc, text), words).map((mismatch) => ({
-    rule: "duration-product-mismatch",
-    severity: "warning",
-    line: 0,
-    column: 0,
-    quote: quoteAt(doc.source, mismatch.total.start),
-    values: {
-      count: written(doc, mismatch.count),
-      length: written(doc, mismatch.length),
-      total: written(doc, mismatch.total),
-      expected: hoursOf(mismatch.expected),
-      offset: mismatch.total.start,
-    },
-  }));
+  return sessionHoursMismatches(text, doc.source, sentencesOf(doc), counts, lengthsOf(doc, text), words).flatMap((mismatch): Finding[] => {
+    const length = computedLength(mismatch.expected, mismatch.total.minutes);
+    if (length === undefined) return [];
+    return [
+      {
+        rule: "duration-product-mismatch",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, mismatch.total.start),
+        ...(length.shape === "hours-minutes" ? {} : { variant: length.shape }),
+        values: {
+          count: written(doc, mismatch.count),
+          length: written(doc, mismatch.length),
+          total: written(doc, mismatch.total),
+          ...length.values,
+          offset: mismatch.total.start,
+        },
+      },
+    ];
+  });
 };
 
 /** 四桁の年。木が日付と読まなかった英語の年（founded in 2015、born 1980）もここで読む。 */
@@ -317,11 +279,10 @@ const referenceYear = (doc: ProseDocument, tree: StructureNode): number | undefi
   return date === undefined ? undefined : yearOf(date);
 };
 
-/** 起点の年から数えた年数が、文書の日付と合わない。 */
-export const elapsedYearsMismatch: Detector = (doc): Finding[] => {
-  const tree = doc.structure;
-  const reference = tree === undefined ? undefined : referenceYear(doc, tree);
-  if (tree === undefined || reference === undefined) return [];
+/** 起点の年から数えた年数が、文書の日付の年と合わない。 */
+export const documentYearFindings = (doc: ProseDocument, tree: StructureNode): Finding[] => {
+  const reference = referenceYear(doc, tree);
+  if (reference === undefined) return [];
   const quantities = quantitiesOf(tree, doc.source);
   const quantityAges = quantities.filter((quantity) => isAge(doc, quantity));
   const taken = spanIndex(quantityAges);

package/src/detectors/discount-rate.ts

@@ -0,0 +1,41 @@
+// discount-rate-mismatch: the reading half. Reads the document's Markdown tables, its lines outside tables with the amounts
+// of money in them (currency-notation), the lexicon discount-rate-label, and leaves the deciding to structure/discount-rate.ts.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { amountsIn, formsOf } from "./currency-notation.ts";
+import { cellsOf, tablesOf } from "../facts/table-facts.ts";
+import { linesOf } from "../structure/lines.ts";
+import { TABLE_ROW } from "../structure/runs.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { discountRateMismatches, type DiscountRole, type DiscountText, type DiscountWord } from "../structure/discount-rate.ts";
+
+const RULE = "discount-rate-mismatch";
+const ROLES: readonly string[] = ["rate", "price", "list", "not", "per"] satisfies readonly DiscountRole[];
+const isRole = (group: string | undefined): group is DiscountRole => group !== undefined && ROLES.includes(group);
+
+const discountWordsOf = (doc: ProseDocument): DiscountWord[] =>
+  (doc.lexicons["discount-rate-label"] ?? []).flatMap((entry) => (isRole(entry.group) ? [{ pattern: entry.pattern, role: entry.group }] : []));
+
+const discountTextOf = (doc: ProseDocument): DiscountText => {
+  const lines = linesOf(proseAndTablesOf(doc));
+  const forms = formsOf(doc);
+  return {
+    tables: tablesOf(lines).map((table) => ({ header: cellsOf(table.header), rows: table.rows.map(cellsOf) })),
+    lines: lines
+      .filter((line) => !TABLE_ROW.test(line.text) && line.text.trim() !== "")
+      .map((line) => ({ text: line.text, amounts: amountsIn(line.text, forms, []) })),
+  };
+};
+
+export const discountRate: Detector = (doc): Finding[] => {
+  const words = discountWordsOf(doc);
+  if (words.length === 0) return [];
+  return discountRateMismatches(discountTextOf(doc), 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/due-date.ts

@@ -1,13 +1,22 @@
 // due-before-issue: the reading half. The issue-date and due-date words come from the language's lexicons
 // (issue-date-label, due-date-label, deadline-passed-word), and so do the words of minutes (minutes-title-word, meeting-date-label,
-// action-section-heading, earlier-section-word, action-due-label, item-done-word); the dates are the structure tree's, and the
-// lines are read with code masked.
+// action-section-heading, earlier-section-word, action-due-label, item-done-word) and the other pairs of dates that must come in
+// order (dated-pair-label, date-now-word, and dated-span-label for the words whose line states a period, read up to its end;
+// a table whose header names both columns of a pair, from dated-pair-label and the header-only dated-column-label);
+// the dates are the structure tree's, and the lines are read with code masked.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { actionDueBeforeMeeting, type ActionWords } from "../structure/action-due.ts";
+import { columnDatesOutOfOrder } from "../structure/column-date-order.ts";
+import { pairedDatesOutOfOrder, type OrderDate } from "../structure/labelled-date-order.ts";
 import { dueBeforeIssue, type DueWords } from "../structure/due-date.ts";
-import type { StructureIssue } from "../structure/issues.ts";
+import { inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { proseAndTablesOf } from "../table-text.ts";
-import { datedPoints, quoteAt } from "./structure-tree.ts";
+import { periodWordsOf } from "./range-words.ts";
+import { quoteAt } from "./structure-tree.ts";
+import { readableDates, withReadableDates } from "./readable-dates.ts";
+
+/** A record's facts table can sit well below its header date (a listing date above the table holding the move-in date). */
+const MAX_RECORD_LINE_GAP = 40;
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
@@ -26,22 +35,35 @@ const actionWordsOf = (doc: ProseDocument): ActionWords => ({
   minutes: patternsOf(doc, "minutes-title-word"),
 });
 
+const orderAsidesOf = (doc: ProseDocument): string[] => [...patternsOf(doc, "deadline-passed-word"), ...patternsOf(doc, "date-now-word")];
+
+const treeDates = (tree: NonNullable<ProseDocument["structure"]>): OrderDate[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+
 const findingOf = (doc: ProseDocument, issue: StructureIssue, variant?: string): Finding => ({
   rule: "due-before-issue",
   severity: "error",
   line: 0,
   column: 0,
   quote: quoteAt(doc.source, issue.offset),
-  values: { ...issue.values, offset: issue.offset },
+  values: { ...withReadableDates(issue.values, ["due", "issued", "meeting", "later", "earlier"], readableDates(doc)), offset: issue.offset },
   ...(variant === undefined ? {} : { variant }),
 });
 
 export const dueDate: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const text = proseAndTablesOf(doc);
-  const dates = datedPoints(doc.structure);
+  const dates = treeDates(doc.structure);
+  const pairs = doc.lexicons["dated-pair-label"] ?? [];
+  const spans = periodWordsOf(doc, patternsOf(doc, "dated-span-label"));
   return [
     ...dueBeforeIssue(text, dates, wordsOf(doc)).map((issue) => findingOf(doc, issue)),
+    ...pairedDatesOutOfOrder(text, dates, pairs, orderAsidesOf(doc), MAX_RECORD_LINE_GAP, spans).map((issue) =>
+      findingOf(doc, issue, issue.period ? "period" : "order"),
+    ),
+    ...columnDatesOutOfOrder(text, dates, [...pairs, ...(doc.lexicons["dated-column-label"] ?? [])], orderAsidesOf(doc)).map((issue) =>
+      findingOf(doc, issue, "order"),
+    ),
     ...actionDueBeforeMeeting(text, dates, doc.markup?.headings ?? [], actionWordsOf(doc)).map((issue) => findingOf(doc, issue, "meeting")),
   ];
 };