chaffjs 0.30.0 → 0.32.0

package/src/detectors/capacity-runtime.ts

@@ -0,0 +1,128 @@
+// capacity-runtime-mismatch: a stated runtime longer than the battery capacity divided by the consumption (derived/battery-runtime.ts).
+// Values are read from table rows (item name, value) and from "item name: value" lines. One key-value table and the labelled
+// lines of one section are one device; a wider table is one device per column.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import {
+  capacityRuntimeMismatches,
+  isPeakHeading,
+  labelOf,
+  splitCondition,
+  valueOf,
+  type BatteryWords,
+  type ElectricUnit,
+  type Entry,
+  type Family,
+  type Marker,
+} from "../derived/battery-runtime.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const FAMILIES: readonly Family[] = ["charge", "current", "energy", "power"];
+const isFamily = (group: string | undefined): group is Family => FAMILIES.some((family) => family === group);
+
+type Lexicons = ProseDocument["lexicons"];
+
+const markersOf = (lexicons: Lexicons, id: string, group?: string): Marker[] =>
+  (lexicons[id] ?? [])
+    .filter((entry) => group === undefined || entry.group === group)
+    .map((entry) => ({ pattern: entry.pattern, position: entry.position ?? "before" }));
+
+export const batteryWordsOf = (lexicons: Lexicons): BatteryWords => {
+  const labels = (lexicons["battery-label"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? "" }));
+  const bounds = markersOf(lexicons, "battery-label", "bound");
+  return {
+    electric: (lexicons["battery-unit"] ?? []).flatMap((entry): ElectricUnit[] =>
+      isFamily(entry.group) ? [{ pattern: entry.pattern, weight: entry.weight ?? 1, family: entry.group }] : [],
+    ),
+    time: (lexicons["unit-time"] ?? []).map((entry) => ({ pattern: entry.pattern, weight: entry.weight ?? 1 })),
+    approximate: markersOf(lexicons, "approximate-marker").filter((marker) => !bounds.some((bound) => bound.pattern === marker.pattern)),
+    bounds,
+    connectors: (lexicons["range-connector"] ?? []).map((entry) => entry.pattern),
+    labels,
+  };
+};
+
+const EMPHASIS = /[*`]/gu;
+const plain = (text: string): string => text.replace(EMPHASIS, "");
+
+type Slot = { readonly key: string; readonly entry: Entry };
+
+const entryOf = (label: string, value: Cell, words: BatteryWords, columnPeak: boolean): Entry | undefined => {
+  const named = labelOf(plain(label), words);
+  const text = plain(value.text).trim();
+  const read = named === undefined ? undefined : valueOf(text, named.role, words);
+  if (named === undefined || read === undefined) return undefined;
+  const lead = value.text.length - value.text.trimStart().length;
+  return {
+    ...named,
+    peak: named.peak || read.peak || columnPeak,
+    condition: named.condition === "" ? splitCondition(text).condition : named.condition,
+    reading: read.reading,
+    start: value.start + lead,
+    text,
+  };
+};
+
+const sectionAt = (doc: ProseDocument, offset: number): number => doc.sections.findLastIndex((section) => section.span.start <= offset);
+
+const TWO_COLUMNS = 2;
+
+const tableSlots = (doc: ProseDocument, words: BatteryWords): Slot[] =>
+  tablesOf(linesOf(doc.source)).flatMap((table) => {
+    const headings = cellsOf(table.header);
+    const wide = headings.length > TWO_COLUMNS;
+    return table.rows.flatMap((row) => {
+      const [label, ...values] = cellsOf(row);
+      if (label === undefined) return [];
+      return values.flatMap((value, index): Slot[] => {
+        const column = index + 1;
+        const peak = wide && isPeakHeading(plain(headings[column]?.text ?? ""), words);
+        const entry = entryOf(label.text, value, words, peak);
+        const key = wide ? `table ${table.header.start} ${column}` : `section ${sectionAt(doc, row.start)}`;
+        return entry === undefined || (!wide && column > 1) ? [] : [{ key, entry }];
+      });
+    });
+  });
+
+const LIST_MARKER = /^\s*(?:[-*+]|\d+[.)])\s+/u;
+const COLON = /[:：]/u;
+const MAX_LABEL = 80;
+
+/** "Battery life: up to 10 hours", "- 消費電流：500 mA". */
+const lineSlot = (doc: ProseDocument, line: Line, words: BatteryWords): Slot[] => {
+  const body = line.text.slice(LIST_MARKER.exec(line.text)?.[0].length ?? 0);
+  const colon = COLON.exec(body)?.index;
+  if (colon === undefined) return [];
+  const label = body.slice(0, colon).trim();
+  const value = body.slice(colon + 1).trim();
+  if (label === "" || label.length > MAX_LABEL || value === "") return [];
+  const start = line.start + line.text.lastIndexOf(value);
+  const entry = entryOf(label, { start, end: start + value.length, text: value }, words, false);
+  return entry === undefined ? [] : [{ key: `section ${sectionAt(doc, line.start)}`, entry }];
+};
+
+const HOUR_DECIMALS = 100;
+
+export const capacityRuntime: Detector = (doc): Finding[] => {
+  const words = batteryWordsOf(doc.lexicons);
+  const lines = linesOf(doc.prose ?? doc.source).filter((line) => !line.text.includes("|"));
+  const slots = [...tableSlots(doc, words), ...lines.flatMap((line) => lineSlot(doc, line, words))];
+  const keys = [...new Set(slots.map((slot) => slot.key))];
+  return keys
+    .flatMap((key) => capacityRuntimeMismatches(slots.filter((slot) => slot.key === key).map((slot) => slot.entry)))
+    .map((mismatch) => ({
+      rule: "capacity-runtime-mismatch",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, mismatch.runtime.start),
+      values: {
+        capacity: mismatch.capacity.text,
+        consumption: mismatch.consumption.text,
+        runtime: mismatch.runtime.text,
+        expected: Math.round(mismatch.idealHours * HOUR_DECIMALS) / HOUR_DECIMALS,
+        offset: mismatch.runtime.start,
+      },
+    }));
+};

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

@@ -0,0 +1,30 @@
+// 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; 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";
+
+const findingOf = (source: string, { writing, other }: Variant<Writing>, variant?: string): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: quoteAt(source, writing.offset),
+  values: { written: writing.written, other: other.written, offset: writing.offset },
+  ...(variant === undefined ? {} : { 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(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/count-over-capacity.ts

@@ -0,0 +1,37 @@
+// A stated capacity smaller than a stated number registered, invited or attending (count-over-capacity). The words come
+// from the language package: capacity-label, headcount-label, headcount-unit and capacity-exception.
+import { countsOverCapacity, type CapacityWords, type CountMark } from "../structure/capacity-count.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const marksOf = (doc: ProseDocument, lexicon: string): CountMark[] =>
+  (doc.lexicons[lexicon] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position, group: entry.group }));
+
+const exceptionsOf = (doc: ProseDocument, group: string): string[] =>
+  (doc.lexicons["capacity-exception"] ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+const capacityWords = (doc: ProseDocument): CapacityWords => ({
+  capacities: marksOf(doc, "capacity-label"),
+  counts: marksOf(doc, "headcount-label"),
+  units: marksOf(doc, "headcount-unit"),
+  overflows: exceptionsOf(doc, "overflow"),
+  perSession: exceptionsOf(doc, "per-session"),
+  otherOccasions: exceptionsOf(doc, "other-occasion"),
+  negations: exceptionsOf(doc, "negation"),
+});
+
+/** The prose with its tables put back, so code is not read; offsets are the source's. */
+export const countOverCapacity: Detector = (doc): Finding[] =>
+  countsOverCapacity(
+    proseAndTablesOf(doc),
+    capacityWords(doc),
+    doc.sections.map((section) => section.span),
+  ).map((issue) => ({
+    rule: "count-over-capacity",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.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,25 +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"),
-  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"),
+  afterTerm: patternsOf(doc, "period-after-term"),
+  deadlineMarks: doc.lexicons["date-deadline-mark"] ?? [],
 });
 
 /** 書いた期間（旅行期間：…）の外の日付を持つ、その後ろの日程の項目、表の行、見出し。 */

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

@@ -0,0 +1,29 @@
+// date-stamp-order: an established date later than the last update, on the document's stamp lines (structure/stamp-order.ts).
+// The stamp words come from the language's stamp-order-label lexicon, grouped into established and updated.
+import type { Detector, Finding } from "../plugin.ts";
+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 [];
+  const labels = options.lexicon ?? [];
+  const wordsOf = (group: string): string[] => labels.filter((entry) => entry.group === group).map((entry) => entry.pattern);
+  const dates = inDocumentOrder(doc.structure).flatMap((node) =>
+    node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : [],
+  );
+  return stampOrderIssues(proseAndTablesOf(doc), dates, { established: wordsOf("established"), updated: wordsOf("updated") }).map(({ offset, values }) => {
+    const { side, ...dated } = values;
+    return {
+      rule: "",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, offset),
+      values: { ...withReadableDates(dated, ["established", "updated"], readableDates(doc)), offset },
+      ...(side === undefined ? {} : { variant: String(side) }),
+    };
+  });
+};