chaffjs 0.29.0 → 0.31.0

package/src/derived/working-hours.ts

@@ -0,0 +1,97 @@
+import type { Span } from "../plugin.ts";
+import { dayShiftOf, SECONDS_PER_DAY, withoutDayShiftBefore, type Mark, type TimeSpan, type TimeWords } from "../structure/time-marks.ts";
+import { labelOf, mentionsIn, readScopes, within, type TimeLength } from "./time-lengths.ts";
+
+/**
+ * Working hours: the stated total (実働8時間, 8 hours a day) against the end minus the start minus the break
+ * (9:00〜17:30、休憩1時間 is 7.5 hours). Read in one line, or in a list whose items say it together, holding exactly one
+ * range of two times, one break with its length and one total, and no other length. A range across midnight is read
+ * only when the end carries a next-day mark (22:00〜翌7:00). Pure.
+ */
+export type WorkingHoursWords = {
+  /** What stands alone between the two times of a range (〜, to, から). */
+  readonly joiners: readonly string[];
+  readonly dayShifts: readonly Mark[];
+  readonly breaks: readonly Mark[];
+  readonly totals: readonly Mark[];
+  readonly approximate: readonly Mark[];
+};
+
+export type WorkingHoursMismatch = {
+  readonly start: Span;
+  readonly end: Span;
+  readonly break: Span;
+  readonly total: Span;
+  /** The total the times and the break give, in minutes. */
+  readonly expected: number;
+};
+
+type ClockRange = Span & { readonly from: Span; readonly to: Span; readonly minutes: number | undefined };
+
+const SECONDS_PER_MINUTE = 60;
+
+const keyOf = (text: string): string => text.normalize("NFKC").trim().toLowerCase().replace(/\s+/gu, " ");
+
+const timeWordsOf = (words: WorkingHoursWords): TimeWords => ({ legs: [], columns: [], dayShifts: words.dayShifts, zones: [] });
+
+/** The minutes from one time to the other, the end a day later when it carries a next-day mark. */
+const minutesOf = (text: string, from: TimeSpan, to: TimeSpan, words: TimeWords): number | undefined => {
+  const shift = dayShiftOf(text.slice(from.end, to.start), text, to.end, words);
+  const seconds = to.seconds + Math.max(0, shift) * SECONDS_PER_DAY - from.seconds;
+  return seconds > 0 ? seconds / SECONDS_PER_MINUTE : undefined;
+};
+
+/** Two times written one after the other with only a joiner between them (9:00〜17:30, 9 a.m. to 5:30 p.m.). */
+export const clockRanges = (text: string, times: readonly TimeSpan[], words: WorkingHoursWords): ClockRange[] => {
+  const joiners = new Set(words.joiners.map(keyOf));
+  const timeWords = timeWordsOf(words);
+  return times.flatMap((from, index): ClockRange[] => {
+    const to = times[index + 1];
+    if (to === undefined || !joiners.has(keyOf(withoutDayShiftBefore(text.slice(from.end, to.start), timeWords)))) return [];
+    return [{ start: from.start, end: to.end, from, to, minutes: minutesOf(text, from, to, timeWords) }];
+  });
+};
+
+const isApproximate = (text: string, length: Span, words: WorkingHoursWords): boolean => labelOf(text, length, words.approximate) !== undefined;
+
+type Labeled = { readonly length: TimeLength; readonly label: Span };
+
+const labeled = (text: string, lengths: readonly TimeLength[], marks: readonly Mark[]): Labeled[] =>
+  lengths.flatMap((length) => {
+    const label = labelOf(text, length, marks);
+    return label === undefined ? [] : [{ length, label }];
+  });
+
+/** The one statement in scope, or undefined when the scope does not hold exactly one. */
+const statementIn = (text: string, scope: Span, ranges: readonly ClockRange[], lengths: readonly TimeLength[], words: WorkingHoursWords) => {
+  const inRanges = ranges.filter((range) => within(range, scope));
+  const inLengths = lengths.filter((length) => within(length, scope));
+  const breaks = labeled(text, inLengths, words.breaks);
+  const totals = labeled(text, inLengths, words.totals);
+  const [range, breakLength, total] = [inRanges[0], breaks[0], totals[0]];
+  if (inRanges.length !== 1 || breaks.length !== 1 || totals.length !== 1 || inLengths.length !== 2) return undefined;
+  if (range?.minutes === undefined || breakLength === undefined || total === undefined || breakLength.length === total.length) return undefined;
+  const label = breakLength.label;
+  const unexplained = mentionsIn(text, scope, words.breaks).some((mention) => mention.end <= label.start || mention.start >= label.end);
+  if (unexplained || isApproximate(text, breakLength.length, words) || isApproximate(text, total.length, words)) return undefined;
+  return { range: { ...range, minutes: range.minutes }, breakLength: breakLength.length, total: total.length };
+};
+
+/** Working hours whose stated total is not the end minus the start minus the break. */
+export const workingHoursMismatches = (
+  text: string,
+  source: string,
+  sentences: readonly Span[],
+  times: readonly TimeSpan[],
+  lengths: readonly TimeLength[],
+  words: WorkingHoursWords,
+): WorkingHoursMismatch[] => {
+  const ranges = clockRanges(text, times, words);
+  return readScopes(text, source, { sentences, times }, (scope) => statementIn(text, scope, ranges, lengths, words)).flatMap(
+    ({ range, breakLength, total }) => {
+      const expected = range.minutes - breakLength.minutes;
+      if (expected <= 0 || expected === total.minutes) return [];
+      return [{ start: range.from, end: range.to, break: breakLength, total, expected }];
+    },
+  );
+};

package/src/detectors/acronym-expansion.ts

@@ -292,10 +292,65 @@ const proseLines = (lines: readonly string[]): string[] => {
   return withoutFences(lines.map((line, index) => (index < skipped || INDENTED.test(line) ? "" : line)));
 };
 
-/** 用語集の見出し語として、すぐ後ろに名前を書いた略語。 */
+/**
+ * 同じ書き方の見出し語が、名前で確かめられてこれだけある文書は、その書き方の用語集。用語集では、見出し語の後ろの段落はどれも定義なので、
+ * 名前の文字が揃わない項目（ADVIS: In hydrologic terms, a program…、AMVER: Automated Mutual Assistance Vessel Rescue System）も
+ * 説明済みと読む。書き方ごとに数えるので、名前を添えた箇条書きが並ぶ文書でも、略語だけの行（PDF、### MATLAB）は定義の見出しと読まない。
+ */
+const GLOSSARY_ENTRIES = 5;
+
+/**
+ * 見出し語の行。略語 1 つか、/ で並べた略語（AMVER/SEAS）。前に 1 文字の語（A AMS）を置いてもよい。空白で並べた大文字の語
+ * （SEE ALSO、XYZ QRS）は見出しや略語の並びで、見出し語ではない。
+ */
+const HEADWORD_WORD = String.raw`[A-Z][A-Z&-]*[A-Z]`;
+const HEADWORD_LINE = new RegExp(String.raw`^(?:#{1,6}\s+)?(?:[A-Z]\s)?(?<words>${HEADWORD_WORD}(?:/${HEADWORD_WORD})*)\s*(?<colon>[:：])?(?:\s+#+)?$`, "u");
+const HEADING_LINE = /^#{1,6}\s/u;
+
+/** 定義の段落。小文字の語を含み（次の見出し語ではなく）、見出しでもない行。 */
+const isDefinitionLine = (line: string): boolean => /\p{Ll}/u.test(line) && !HEADING_LINE.test(line);
+
+/** 用語集の、見出し語だけの行と、その次の空でない行が定義の段落のもの。 */
+const glossaryLineTerms = (lines: readonly string[], index: number): string[] => {
+  const line = (lines[index] ?? "").trim();
+  const groups = HEADWORD_LINE.exec(line.replaceAll(STRONG, ""))?.groups;
+  if (groups?.["words"] === undefined || (groups["colon"] !== undefined && !MARKED_LINE.test(line))) return [];
+  const next = lines.slice(index + 1, index + 1 + NEXT_LINE_REACH).find((candidate) => candidate.trim() !== "");
+  return next !== undefined && isDefinitionLine(next.trim()) ? groups["words"].split("/") : [];
+};
+
+/** 用語集の、印を付けた見出し語と区切りの後ろの定義（**ADVIS**: In hydrologic terms…、- ADVIS — a program…）。 */
+const glossaryLeadTerm = (line: string): string[] => {
+  const lead = TERM_LEAD.exec(line.trim());
+  const term = lead?.groups?.["strongTerm"] ?? lead?.groups?.["term"];
+  return term !== undefined && /\p{Ll}/u.test(lead?.groups?.["rest"] ?? "") ? [term] : [];
+};
+
+type EntryForm = {
+  readonly named: (lines: readonly string[], index: number) => string[];
+  readonly defined: (lines: readonly string[], index: number) => string[];
+};
+
+/** 見出し語の書き方。行だけの見出し語と、印を付けた見出し語の後ろの名前。表は隣のセルの名前だけで読む。 */
+const ENTRY_FORMS: readonly EntryForm[] = [
+  { named: (lines, index) => (TABLE_ROW.test(lines[index] ?? "") ? [] : lineTerm(lines, index)), defined: glossaryLineTerms },
+  {
+    named: (lines, index) => (TABLE_ROW.test(lines[index] ?? "") ? [] : leadTerm(lines[index] ?? "")),
+    defined: (lines, index) => glossaryLeadTerm(lines[index] ?? ""),
+  },
+  { named: (lines, index) => (TABLE_ROW.test(lines[index] ?? "") ? tableTerms(lines[index] ?? "") : []), defined: () => [] },
+];
+
+/** 一つの書き方で見出し語と読む略語。その書き方の用語集なら、名前でない定義を書いたものも。 */
+const formTerms = (lines: readonly string[], form: EntryForm): string[] => {
+  const named = lines.flatMap((_, index) => form.named(lines, index));
+  return new Set(named).size < GLOSSARY_ENTRIES ? named : [...named, ...lines.flatMap((_, index) => form.defined(lines, index))];
+};
+
+/** 用語集の見出し語として、すぐ後ろに名前を書いた略語。用語集と読める書き方では、名前でなくても定義を書いた略語。 */
 export const termEntryAcronyms = (source: string): ReadonlySet<string> => {
   const lines = proseLines(source.split(/\r?\n/u));
-  return new Set(lines.flatMap((line, index) => (TABLE_ROW.test(line) ? tableTerms(line) : [...lineTerm(lines, index), ...leadTerm(line)])));
+  return new Set(ENTRY_FORMS.flatMap((form) => formTerms(lines, form)));
 };
 
 export type ExpandedAt = (body: string, acronym: string, at: number) => boolean;

package/src/detectors/announced-count.ts

@@ -10,6 +10,7 @@ const countWordsOf = (doc: ProseDocument): CountWords => ({
   anchors: patternsOf(doc, "count-anchor"),
   numbers: patternsOf(doc, "count-number"),
   counters: patternsOf(doc, "count-counter"),
+  frames: patternsOf(doc, "count-frame"),
   hedgesBefore: patternsOf(doc, "count-hedge", "before"),
   hedgesAfter: patternsOf(doc, "count-hedge", "after"),
 });

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/capitalised-term.ts

@@ -0,0 +1,147 @@
+// A term written like the document's defined terms, capitalised inside a sentence (its Affiliates, disclose Proprietary
+// Data), that the document defines nowhere. Read only where the document defines its terms with a defining word
+// (MIN_DEFINED of them: "X" means, (the "X")). A capitalised run is also the name of a law, a body, a place, a party or a
+// part of the document, so every name the language package lists is left, and so is every run set apart by markup (a
+// heading, a link, bold, an HTML element, a table row, a list item's label). Pure.
+import { escapeRegExp } from "../orthography.ts";
+import type { Span, Token } from "../plugin.ts";
+
+export type CapitalisedTerm = { readonly offset: number; readonly term: string };
+
+/** The word lists the decision reads, matched as written. */
+export type CapitalisedWords = {
+  /** A run holding one of these is a name (Act, Policy, Inc, California, Monday, Supplier), not a term. */
+  readonly names: readonly string[];
+  /** A run opening with one of these points at a part of the document (Section 4, Schedule A). */
+  readonly divisions: readonly string[];
+  /** Small words inside one name (Statement of Work, Trials and Betas). */
+  readonly joiners: readonly string[];
+};
+
+/** A term the document defines; bare is a definition with no defining word (("GPC")), which names more than it defines. */
+export type Defined = { readonly term: string; readonly bare?: boolean };
+
+export type CapitalisedInput = {
+  readonly source: string;
+  /** The text a reader sees (the source without link destinations): where a lower-case use counts. */
+  readonly readable: string;
+  readonly sentences: readonly (readonly Token[])[];
+  readonly defined: readonly Defined[];
+  /** Words set in quotes or bold anywhere ("Account" represents …, **Security Measures**): named on purpose. */
+  readonly named: readonly string[];
+  /** Spans set apart by markup: headings, links, bold, HTML elements, table rows, list items' labels. */
+  readonly marked: readonly Span[];
+  readonly words: CapitalisedWords;
+};
+
+/** Fewer definitions than this, and capitals are the document's style, not its way of naming terms. */
+const MIN_DEFINED = 2;
+const CAPITALISED = /^\p{Lu}\p{Ll}+(?:['’]\p{Ll}+)?$/u;
+const ACRONYM = /^\p{Lu}{2,}$/u;
+const DEFINED_FORM = /^\p{Lu}/u;
+const LOWER_WORD = /^\p{Ll}+$/u;
+const HYPHEN = "-";
+
+const isCapitalised = (token: Token | undefined): boolean => token !== undefined && CAPITALISED.test(token.surface);
+/** A word that carries a run on once it has started: a capitalised word or an acronym (Commercial AI System). */
+const continues = (token: Token | undefined): boolean => isCapitalised(token) || (token !== undefined && ACRONYM.test(token.surface));
+const adjacent = (left: Token, right: Token): boolean => right.span.start - left.span.end <= 1;
+const touching = (left: Token, right: Token): boolean => right.span.start === left.span.end;
+
+/** The forms one term is written in: lower case, its last word as written and singular (Policies, Policy; Viruses, Virus). */
+const formsOf = (term: string): string[] => {
+  const words = term.toLowerCase().split(/[\s-]+/u);
+  const head = words.slice(0, -1).join(" ");
+  const last = words.at(-1) ?? "";
+  const lasts = [last, last.replace(/ies$/u, "y"), last.replace(/es$/u, ""), last.replace(/(?<!s)s$/u, "")];
+  return lasts.map((form) => (head === "" ? form : `${head} ${form}`));
+};
+
+/** How many tokens the capitalised run starting at index takes: words that continue it, and a joiner or hyphen between two. */
+const runLength = (tokens: readonly Token[], index: number, joiners: ReadonlySet<string>): number => {
+  const word = tokens[index];
+  const next = tokens[index + 1];
+  const after = tokens[index + 2];
+  if (next === undefined || word === undefined || !adjacent(word, next)) return 1;
+  if (continues(next)) return 1 + runLength(tokens, index + 1, joiners);
+  const hyphened = next.surface === HYPHEN && touching(word, next) && after !== undefined && touching(next, after);
+  const joined = hyphened || (joiners.has(next.surface) && after !== undefined && adjacent(next, after));
+  return joined && continues(after) ? 2 + runLength(tokens, index + 2, joiners) : 1;
+};
+
+type Run = { readonly start: number; readonly end: number };
+
+/** The capitalised runs of one sentence, as [start, end) token indexes; a run never starts inside the one before. */
+const runsOf = (tokens: readonly Token[], joiners: ReadonlySet<string>): Run[] =>
+  tokens.reduce<Run[]>((runs, token, index) => {
+    if ((runs.at(-1)?.end ?? 0) > index || !isCapitalised(token)) return runs;
+    return [...runs, { start: index, end: index + runLength(tokens, index, joiners) }];
+  }, []);
+
+const inside = (offset: number, spans: readonly Span[]): boolean => spans.some((span) => span.start <= offset && offset < span.end);
+
+/** Used like a defined term: after a lower-case word, and not a modifier of a lower-case noun after it (the Premium plan). */
+const placedLikeATerm = (before: Token | undefined, after: Token | undefined): boolean =>
+  before !== undefined && LOWER_WORD.test(before.surface) && !(after !== undefined && after.pos === "NOUN" && LOWER_WORD.test(after.surface));
+
+/** Every run of whole words in a term (GitHub Service: GitHub, Service, GitHub Service). */
+const partsOf = (term: string): string[] => {
+  const words = term.split(/\s+/u);
+  return words.flatMap((_, start) => words.slice(start).map((__, length) => words.slice(start, start + length + 1).join(" ")));
+};
+
+/** The text also writes the term in lower case (your account, account settings): an ordinary word, or a screen's label. */
+const writtenInLowerCase = (text: string, term: string): boolean => {
+  const words = term
+    .toLowerCase()
+    .split(/[\s-]+/u)
+    .map(escapeRegExp)
+    .join(String.raw`[\s-]+`);
+  return new RegExp(String.raw`(?<!\p{L})${words}(?:e?s)?(?!\p{L})`, "u").test(text);
+};
+
+/**
+ * The first use of each capitalised run used inside a sentence like a defined term that names nothing the language
+ * package lists, is not set apart by markup, is never written in lower case, and neither is nor holds a defined or named
+ * term in any case.
+ */
+export const capitalisedTerms = (input: CapitalisedInput): CapitalisedTerm[] => {
+  const defining = input.defined.filter((definition) => definition.bare !== true && DEFINED_FORM.test(definition.term));
+  if (defining.length < MIN_DEFINED) return [];
+  const joiners = new Set(input.words.joiners);
+  const divisions = new Set(input.words.divisions.flatMap(formsOf));
+  const known = new Set([...input.defined.map((definition) => definition.term), ...input.named, ...input.words.names].flatMap(formsOf));
+  const isKnown = (term: string): boolean => partsOf(term).some((part) => formsOf(part).some((form) => known.has(form)));
+  const uses = input.sentences.flatMap((tokens) =>
+    runsOf(tokens, joiners).flatMap(({ start, end }): CapitalisedTerm[] => {
+      const first = tokens[start];
+      const last = tokens[end - 1];
+      if (first === undefined || last === undefined || !placedLikeATerm(tokens[start - 1], tokens[end])) return [];
+      if (inside(first.span.start, input.marked) || formsOf(first.surface).some((form) => divisions.has(form))) return [];
+      const term = input.source.slice(first.span.start, last.span.end);
+      return isKnown(term) || writtenInLowerCase(input.readable, term) ? [] : [{ offset: first.span.start, term }];
+    }),
+  );
+  return uses.filter((use, index) => uses.findIndex((other) => formsOf(other.term).some((form) => formsOf(use.term).includes(form))) === index);
+};
+
+const BOLD = /\*\*([^*\n]+)\*\*|__([^_\n]+)__/gu;
+const QUOTED = /["“]([^"“”\n]{1,80}?)[,.]?["”]/gu;
+const HTML_ELEMENT = /<([a-z][a-z0-9]*)\b[^>]*>[^<]*<\/\1>/giu;
+const TABLE_ROW = /^[ \t]*\|.*$/gmu;
+const ITEM_LABEL = /^[ \t]*(?:[*+-]|\d+[.)])[ \t]+[^:\n]{1,80}:/gmu;
+
+const spansOf = (source: string, pattern: RegExp): Span[] =>
+  [...source.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** Bold, HTML elements, table rows and list items' labels in a Markdown source: labels and cells, not running text. */
+export const setApartSpans = (source: string): Span[] => [BOLD, HTML_ELEMENT, TABLE_ROW, ITEM_LABEL].flatMap((pattern) => spansOf(source, pattern));
+
+const LINK_DESTINATION = /\]\([^)\n]*\)|<?https?:\/\/[^\s)>]+>?/gu;
+
+/** The source with link destinations and URLs blanked: the words a reader sees. */
+export const readableText = (source: string): string => source.replaceAll(LINK_DESTINATION, (destination) => " ".repeat(destination.length));
+
+/** The words set in quotes or bold anywhere in a source, without the emphasis marks. */
+export const namedWords = (source: string): string[] =>
+  [BOLD, QUOTED].flatMap((pattern) => [...source.matchAll(pattern)].map((match) => (match[1] ?? match[2] ?? "").replaceAll(/[*_]/gu, "").trim()));

package/src/detectors/contact-variant.ts

@@ -0,0 +1,24 @@
+// 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.
+import { addressVariants } from "../contacts/addresses.ts";
+import { emailVariants } from "../contacts/emails.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 text = doc.prose ?? doc.source;
+  const emails = emailVariants(text).map((found) => findingOf(doc.source, found));
+  const addresses = addressVariants(text, options.lexicon ?? []).map(({ variant, found }) => findingOf(doc.source, found, variant));
+  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/date-outside-period.ts

@@ -6,10 +6,14 @@ 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"),
+  terms: patternsOf(doc, "period-term-label"),
   asides: patternsOf(doc, "period-aside"),
+  deadlines: patternsOf(doc, "period-deadline"),
+  overviews: patternsOf(doc, "period-overview-heading"),
+  afterTerm: patternsOf(doc, "period-after-term"),
   connectors: [
     ...patternsOf(doc, "range-connector"),
     ...patternsOf(doc, "range-opener"),

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

@@ -0,0 +1,28 @@
+// 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";
+
+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: { ...dated, offset },
+      ...(side === undefined ? {} : { variant: String(side) }),
+    };
+  });
+};