chaffjs 0.31.0 → 0.33.0

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,13 +17,13 @@ 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";
 
 /** 期間の単位の語彙表。木の数量の単位がどれかに入れば、その単位の期間。 */
 export const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
@@ -32,9 +33,9 @@ export const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
   ["duration-year", "year"],
 ];
 
-export 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());
@@ -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,14 +1,19 @@
 // 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) and the other pairs of dates that must come in
-// order (dated-pair-label, date-now-word); the dates are the structure tree's, and the lines are read with code masked.
+// 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 { pairedDatesOutOfOrder } from "../structure/labelled-date-order.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;
@@ -32,24 +37,33 @@ const actionWordsOf = (doc: ProseDocument): ActionWords => ({
 
 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).map((issue) => findingOf(doc, issue, "order")),
+    ...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")),
   ];
 };

package/src/detectors/email-letter.ts

@@ -1,6 +1,6 @@
 // A work email or letter's own parts: a greeting and a closing, a subject line, and an attachment the text mentions.
 // Pure. The words (お世話になっております, Dear, Best regards, 件名, attached) come from the language's email-greeting,
-// email-closing, email-subject-field, attachment-mention, attachment-not-mention and attachment-line lexicons. The
+// email-closing, email-sentence-end, email-subject-field, attachment-mention, attachment-not-mention and attachment-line lexicons. The
 // header and the signature are masked in doc.prose; a quoted reply is someone else's words and is left out.
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAt } from "./structure-tree.ts";
@@ -8,6 +8,8 @@ import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
 
 /** A greeting comes before the body: past the subject, the addressee (株式会社… / 総務部 山田様) and the writer's name. */
 const GREETING_LINES = 5;
+/** A letter's header before the greeting: the date, the sender's and the addressee's names and addresses, a title. */
+const HEADER_LINES = 12;
 /** A closing comes at the end, before the writer's name, title, company, address and contact lines, or an acceptance block. */
 const CLOSING_LINES = 10;
 
@@ -101,12 +103,37 @@ const partsOf = (lines: readonly BodyLine[]): BodyLine[][] => {
 
 export type FrameSlip = { readonly variant: "greeting" | "closing"; readonly offset: number };
 
-/** A missing greeting (none in the first lines) and a missing closing (none in the last lines of any part). */
-export const frameSlips = (lines: readonly BodyLine[], greetings: readonly string[], closings: readonly string[]): FrameSlip[] => {
+/** The brackets and quotes that may close a line after its sentence's end mark (…ます。」, …trip.”). */
+const CLOSERS = new Set(")）」』］]\"'”’");
+
+/** Whether a line ends a sentence: one of the marks at its end, past any closing bracket or quote. */
+export const endsSentence = (line: string, marks: readonly string[]): boolean => {
+  const chars = [...line.trimEnd()];
+  const body = chars.slice(0, chars.findLastIndex((char) => !CLOSERS.has(char)) + 1).join("");
+  return body !== "" && marks.some((mark) => body.endsWith(mark));
+};
+
+/**
+ * How many of the first lines the greeting may be in. A letter's header (the date, the addressee 保護者各位 or the
+ * address block, the sender, a title) is lines that end no sentence, and the greeting is the line after it at the latest.
+ * Without a sentence in the first lines there is no header to tell apart, and the first lines are read.
+ */
+export const greetingLineCount = (lines: readonly BodyLine[], sentenceEnds: readonly string[]): number => {
+  const firstSentence = lines.slice(0, HEADER_LINES).findIndex((line) => endsSentence(line.text, sentenceEnds));
+  return Math.max(GREETING_LINES, firstSentence + 1);
+};
+
+/** A missing greeting (none in the first lines, or past the letter's header) and a missing closing (none in the last lines of any part). */
+export const frameSlips = (
+  lines: readonly BodyLine[],
+  greetings: readonly string[],
+  closings: readonly string[],
+  sentenceEnds: readonly string[],
+): FrameSlip[] => {
   const first = lines[0];
   const last = lines.at(-1);
   if (first === undefined || last === undefined) return [];
-  const greeted = lines.slice(0, GREETING_LINES).some((line) => lineHas(line.text, greetings));
+  const greeted = lines.slice(0, greetingLineCount(lines, sentenceEnds)).some((line) => lineHas(line.text, greetings));
   const closed = partsOf(lines).some((part) => part.slice(-CLOSING_LINES).some((line) => lineHas(line.text, closings)));
   return [
     ...(greeted ? [] : [{ variant: "greeting" as const, offset: first.start }]),
@@ -115,17 +142,20 @@ export const frameSlips = (lines: readonly BodyLine[], greetings: readonly strin
 };
 
 export const emailFrame: Detector = (doc): Finding[] =>
-  frameSlips(bodyLines(doc.source, doc.prose ?? doc.source, doc.replyQuotes ?? []), patternsOf(doc, "email-greeting"), patternsOf(doc, "email-closing")).map(
-    (slip) => ({
-      rule: "email-greeting-closing",
-      severity: "info",
-      line: 0,
-      column: 0,
-      quote: quoteAt(doc.source, slip.offset),
-      values: { offset: slip.offset },
-      variant: slip.variant,
-    }),
-  );
+  frameSlips(
+    bodyLines(doc.source, doc.prose ?? doc.source, doc.replyQuotes ?? []),
+    patternsOf(doc, "email-greeting"),
+    patternsOf(doc, "email-closing"),
+    patternsOf(doc, "email-sentence-end"),
+  ).map((slip) => ({
+    rule: "email-greeting-closing",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.offset),
+    values: { offset: slip.offset },
+    variant: slip.variant,
+  }));
 
 export type SubjectLine = { readonly start: number; readonly subject: string };
 

package/src/detectors/event-deadline.ts

@@ -1,10 +1,12 @@
 // deadline-after-event: the reading half. The event-date, registration, deadline and follow-up words come from the language's
-// lexicons (event-date-label, event-registration-word, event-deadline-word, event-aside); the dates are the structure tree's,
+// lexicons (event-date-label, event-registration-word, event-deadline-word, event-aside,
+// event-ticket-word, event-payment-word, event-bill-word, event-trip-word, event-start-label, event-payment-deadline-word, event-due-word); the dates are the structure tree's,
 // and the lines are read with code masked.
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { deadlinesAfterEvent, type EventDeadlineWords } from "../structure/deadline-after-event.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { datedPoints, quoteAt } from "./structure-tree.ts";
+import { readableDates, withReadableDates } from "./readable-dates.ts";
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
@@ -13,17 +15,25 @@ const wordsOf = (doc: ProseDocument): EventDeadlineWords => ({
   registrations: patternsOf(doc, "event-registration-word"),
   deadlines: patternsOf(doc, "event-deadline-word"),
   asides: patternsOf(doc, "event-aside"),
+  tickets: patternsOf(doc, "event-ticket-word"),
+  payments: patternsOf(doc, "event-payment-word"),
+  bills: patternsOf(doc, "event-bill-word"),
+  trips: patternsOf(doc, "event-trip-word"),
+  starts: patternsOf(doc, "event-start-label"),
+  paymentDeadlines: patternsOf(doc, "event-payment-deadline-word"),
+  dues: patternsOf(doc, "event-due-word"),
 });
 
 export const eventDeadline: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const sentences = doc.sentences.map((sentence) => sentence.span);
-  return deadlinesAfterEvent(proseAndTablesOf(doc), datedPoints(doc.structure), sentences, wordsOf(doc)).map((issue) => ({
+  return deadlinesAfterEvent(proseAndTablesOf(doc), datedPoints(doc.structure), sentences, wordsOf(doc), doc.markup?.headings[0]?.text).map((issue) => ({
     rule: "deadline-after-event",
     severity: "error",
     line: 0,
     column: 0,
     quote: quoteAt(doc.source, issue.offset),
-    values: { ...issue.values, offset: issue.offset },
+    ...(issue.kind === "payment" ? { variant: "payment" } : {}),
+    values: { ...withReadableDates(issue.values, ["deadline", "event"], readableDates(doc)), offset: issue.offset },
   }));
 };