chaffjs 0.34.0 → 0.36.0

package/src/detectors/date-year.ts

@@ -1,17 +1,42 @@
 // 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 type { Detector, DetectorOptions, Finding, LexiconEntry, ProseDocument, StructureNode } from "../plugin.ts";
+import { isIn } from "../lexicon-genres.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";
+import {
+  ANY_YEAR_MARKER_LEXICON,
+  MARKER_REACHES,
+  YEAR_SPAN_JOINER_LEXICON,
+  anyYearDate,
+  opensSpan,
+  type AnyYearMarker,
+  type MarkerReach,
+} from "./date-any-year.ts";
+import { datesUnderYearHeadings, yearLabelOf, type HeadingYearWords } from "./date-heading-year.ts";
+import { openingDateOf } from "./opening-date.ts";
+import { withNearestYear } from "../structure/weekday.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[] };
+/**
+ * The words that make a yearless date any year's (毎年, 例えば, "each"), that join a period's two ends (から, "to"), and
+ * that join the names of one list (及び, "and"), for a marker named in one list with the date.
+ */
+export type AnyYearWords = { readonly markers: readonly AnyYearMarker[]; readonly joiners: readonly string[]; readonly listJoiners?: 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 };
+/**
+ * A date as the tree reads it: "2026-10-14" with its year, "10-14" without. `yearHeaded`: the heading of its section
+ * names a year ("FY27-Q2 (May 1)", 「2026年度の予定」), which the date takes. `nearStamp`: the document's own date (minutes
+ * dated "January 17, 2024") lies within a few months of it in one year only, which the date takes.
+ */
+export type DatePoint = {
+  readonly offset: number;
+  readonly end: number;
+  readonly value: string;
+  readonly yearHeaded?: boolean;
+  readonly nearStamp?: boolean;
+};
 
 /** The first and the last year of the document's dated dates. */
 export type YearSpan = { readonly from: number; readonly to: number };
@@ -106,9 +131,24 @@ const hasYearWord = (point: DatePoint, source: string, yearWords: readonly YearW
  */
 const yearGiven = (point: DatePoint, anchors: readonly DatePoint[], source: string, yearWords: readonly YearWord[]): boolean => {
   const start = lineStart(source, point.offset);
-  return hasYearWord(point, source, yearWords) || anchors.some((other) => other.offset >= start && other.offset < point.offset);
+  const placed = point.yearHeaded === true || point.nearStamp === true;
+  return placed || hasYearWord(point, source, yearWords) || anchors.some((other) => other.offset >= start && other.offset < point.offset);
 };
 
+const DAY_MS = 24 * 60 * 60 * 1000;
+const COMMON_YEAR_MS = 365 * DAY_MS;
+/** A year with no 29 February, so that "03-01" follows "02-28" as it does in most years. */
+const COMMON_YEAR = 2025;
+
+const dayOf = (value: string): number => Date.UTC(COMMON_YEAR, Number(value.slice(0, 2)) - 1, Number(value.slice(3, 5)));
+
+/**
+ * A period of one whole year: its end is the day before its start (January 1 to December 31, 4月1日から3月31日). Without
+ * a year it is every year's, like a calendar or a fiscal year.
+ */
+export const wholeYear = (start: string, end: string): boolean =>
+  MONTH_DAY.test(start) && MONTH_DAY.test(end) && (dayOf(end) + DAY_MS - dayOf(start)) % COMMON_YEAR_MS === 0;
+
 /**
  * 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
@@ -124,9 +164,17 @@ export const yearGaps = (
   const dated = points.filter((point) => FULL.test(point.value));
   const anchors = [...dated, ...points.filter((point) => hasYearWord(point, source, yearWords))];
   const nextOf = new Map(points.map((point, index) => [point, points[index + 1]]));
+  const previousOf = new Map(points.map((point, index) => [point, points[index - 1]]));
+  const yearlySpan = (start: DatePoint | undefined, end: DatePoint | undefined): boolean =>
+    start !== undefined && end !== undefined && wholeYear(start.value, end.value) && opensSpan(start, end, source, anyYear.joiners);
+  const markedAnyYear = (point: DatePoint | undefined): boolean => point !== undefined && anyYearDate(point, source, anyYear.markers, anyYear.listJoiners);
   const yearOfAny = (point: DatePoint): boolean => {
     const next = nextOf.get(point);
-    if (anyYearDate(point, source, anyYear.markers)) return true;
+    const previous = previousOf.get(point);
+    if (markedAnyYear(point)) return true;
+    if (yearlySpan(point, next) || yearlySpan(previous, point)) return true;
+    // The end of a period whose start is any year's is too: 「祝休日及び12月29日から1月3日まで」.
+    if (previous !== undefined && opensSpan(previous, point, source, anyYear.joiners) && markedAnyYear(previous)) 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.
@@ -134,30 +182,75 @@ export const yearGaps = (
   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 (unclear) return [{ point, kind: "years", span }];
     return crossesYear(point, previousOf.get(point), datedSides) ? [{ point, kind: "boundary", span }] : [];
   });
 };
 
-export const datePoints = (tree: StructureNode): DatePoint[] =>
-  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+const NO_HEADING_YEAR_WORDS: HeadingYearWords = { eras: [], labels: [] };
+
+/** A yearless date that the document's own date ("2024-01-17") places in one year: within a few months of it. */
+const nearStampOf = (value: string, stamp: string | undefined): boolean => stamp !== undefined && withNearestYear(value, stamp) !== undefined;
+
+export const datePoints = (tree: StructureNode, headingWords: HeadingYearWords = NO_HEADING_YEAR_WORDS, stamp?: string): DatePoint[] => {
+  const yearHeaded = new Set(datesUnderYearHeadings(tree, headingWords));
+  return inDocumentOrder(tree).flatMap((node) => {
+    if (node.kind !== "date") return [];
+    const value = String(node.attrs["value"]);
+    return [{ offset: node.span.start, end: node.span.end, value, yearHeaded: yearHeaded.has(node.span.start), nearStamp: nearStampOf(value, stamp) }];
+  });
+};
+
+/**
+ * The document's own date: a date alone, or labelled, on a line of its title block. A date-only paragraph further down
+ * (an agenda's "April 4, 2023") is a date the text talks about, not the document's.
+ */
+const stampOf = (doc: ProseDocument, tree: StructureNode): string | undefined => {
+  const dates = inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ ...node.span, value: String(node.attrs["value"]) }] : []));
+  const labels = (doc.lexicons["date-stamp-label"] ?? []).map((entry: LexiconEntry) => entry.pattern);
+  return openingDateOf(doc.source, dates, labels);
+};
+
+/**
+ * The genres whose date at the top is the occasion the text is about (minutes, a letter), from the rule's dated_genres.
+ * A web page's date at the top says when it was posted, and its days and months may be any year's.
+ */
+const datedByOccasion = (options: DetectorOptions): boolean => {
+  const genres = options.settings?.["dated_genres"];
+  const genre = options.genre;
+  return genre !== undefined && Array.isArray(genres) && genres.some((target: string) => isIn(genre, target));
+};
+
+const pointsOf = (doc: ProseDocument, tree: StructureNode, options: DetectorOptions): DatePoint[] =>
+  datePoints(tree, headingYearWordsOf(doc), datedByOccasion(options) ? stampOf(doc, tree) : undefined);
 
 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");
+/** The era names (calendar-era) and the fiscal-year names ("FY{y}" of reporting-period-frame) a heading may give a year with. */
+const headingYearWordsOf = (doc: ProseDocument): HeadingYearWords => ({
+  eras: (doc.lexicons["calendar-era"] ?? []).map((entry: LexiconEntry) => entry.pattern),
+  labels: (doc.lexicons["reporting-period-frame"] ?? []).flatMap((entry: LexiconEntry) =>
+    entry.group === "fiscal-year" ? (yearLabelOf(entry.pattern) ?? []) : [],
+  ),
+});
+
+/** The words that join the names of one list (及び, "and"): a `listed` marker stands before the date with these between. */
+const LIST_JOINER_LEXICON = "enumeration-joiner";
+
+const reachOf = (group: string | undefined): MarkerReach => MARKER_REACHES.find((reach) => reach === 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),
+  listJoiners: (doc.lexicons[LIST_JOINER_LEXICON] ?? []).map((entry: LexiconEntry) => entry.pattern),
 });
 
-export const dateWithoutYear: Detector = (doc: ProseDocument): Finding[] =>
+export const dateWithoutYear: Detector = (doc: ProseDocument, options: DetectorOptions): Finding[] =>
   doc.structure === undefined
     ? []
-    : yearGaps(datePoints(doc.structure), doc.source, yearWordsOf(doc), anyYearWordsOf(doc)).map((gap) => ({
+    : yearGaps(pointsOf(doc, doc.structure, options), doc.source, yearWordsOf(doc), anyYearWordsOf(doc)).map((gap) => ({
         rule: "date-without-year",
         severity: "warning",
         line: 0,

package/src/detectors/deadline-unit.ts

@@ -0,0 +1,40 @@
+import type { Span } from "../plugin.ts";
+
+// The unit a duty is written in: its article, else its list, else its paragraph. A duty in a unit that names the dated
+// deadline of its own act is timed by it: 「乙は代金を支払う。」 beside 「支払期日までに支払うことができないときは…」. A date
+// for another act (a delivery date beside a duty to pay) times nothing. Pure.
+
+/** The spans a document is cut into, from the widest kind that counts as one unit to the narrowest. */
+export type Units = { readonly articles: readonly Span[]; readonly lists: readonly Span[]; readonly paragraphs: readonly Span[] };
+
+/** A dated deadline's name (支払期日, due date) and the act it times (支払, pay). */
+export type NamedDeadline = { readonly name: string; readonly act: string };
+
+const within = (span: Span, offset: number): boolean => offset >= span.start && offset < span.end;
+
+/** The innermost span holding the offset: an article nested in another is a unit of its own. */
+const innermost = (spans: readonly Span[], offset: number): Span | undefined =>
+  spans
+    .filter((span) => within(span, offset))
+    .reduce<Span | undefined>((inner, span) => (inner === undefined || span.start > inner.start ? span : inner), undefined);
+
+/** The unit that holds the offset: its article, else its list, else its paragraph; undefined when none does. */
+export const unitAt = (units: Units, offset: number): Span | undefined =>
+  [units.articles, units.lists, units.paragraphs].map((spans) => innermost(spans, offset)).find((span) => span !== undefined);
+
+/**
+ * The acts whose dated deadline the unit holding the offset names. holds: whether a text holds a name (as a phrase, so
+ * that a Latin name is read as whole words).
+ */
+export const actsTimedAt = (
+  source: string,
+  units: Units,
+  offset: number,
+  deadlines: readonly NamedDeadline[],
+  holds: (text: string, name: string) => boolean,
+): string[] => {
+  const unit = unitAt(units, offset);
+  if (unit === undefined) return [];
+  const text = source.slice(unit.start, unit.end);
+  return [...new Set(deadlines.filter((deadline) => holds(text, deadline.name)).map((deadline) => deadline.act))];
+};

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

@@ -1,12 +1,14 @@
 // A defined term used later in another form, and a long name used again after its short name was defined. Pure. The
 // definitions come from the document's structure tree (以下「甲」という, ("Seller")); which words may stand in a long
 // name is read from the tokens' parts of speech.
+import { inEntryOfTerm } from "./term-mention-sentence.ts";
 import { definedTerms, usesOf, type BodyText, type DefinedTerm } from "../structure/definition-use.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { prefixGroupsOf, prefixVariants, variantUses } from "../structure/term-prefix.ts";
 import { quoteAt } from "./structure-tree.ts";
 import { isPartOfAddress } from "./address-word.ts";
 import { exactOffsets, extendedAfter, extendedBefore } from "./term-extension.ts";
+import { headsKindPhrase, insideLongerTerm, isNamedAsTerm, isNarrowedUse } from "./ordinary-phrase.ts";
 import { CLOSES_SENTENCE, isNameField, isSignatureLine, opensClosingBlock, SLACK } from "./name-field.ts";
 import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
@@ -146,18 +148,36 @@ const prefixFindings = (doc: ProseDocument, texts: readonly BodyText[], term: De
         ),
   );
 
-/** The term set in quotes again, unless the document's profile says a quoted term is the term mentioned (「株主」とあるのは). */
-const quotedFindings = (doc: ProseDocument, term: DefinedTerm, uses: readonly number[], definingEnd: number): Finding[] =>
-  doc.profile?.quoteMentionsTerm === true
-    ? []
-    : quotedUses(doc.source, term.term, uses, definingEnd).map((offset) =>
-        finding(doc, "defined-term-form", offset, "quoted", { term: term.term, line: term.line }),
-      );
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/**
+ * The term set in quotes again, unless the document's profile says a quoted term is the term mentioned (「株主」とあるのは),
+ * or the words before the quote name it as a term (the definition of "Material Adverse Effect").
+ */
+const quotedFindings = (doc: ProseDocument, term: DefinedTerm, uses: readonly number[], definingEnd: number): Finding[] => {
+  if (doc.profile?.quoteMentionsTerm === true) return [];
+  const cues = patternsOf(doc, "term-mention-cue");
+  return quotedUses(doc.source, term.term, uses, definingEnd)
+    .filter((offset) => !isNamedAsTerm(doc.source, offset - 1, cues))
+    .map((offset) => finding(doc, "defined-term-form", offset, "quoted", { term: term.term, line: term.line }));
+};
+
+/**
+ * A lower-case use that is the ordinary word in a phrase of its own: inside another defined term (certificate of merger),
+ * narrowed by the word before it (the common parent), or heading a kind of thing (certificates of deposit).
+ */
+const isOrdinaryPhraseAt = (doc: ProseDocument, offset: number, term: string, defined: readonly string[]): boolean => {
+  if (insideLongerTerm(doc.source, offset, term, defined)) return true;
+  const { tokens, at } = tokensAt(doc, offset);
+  if (at === -1) return false;
+  const last = tokens.findLastIndex((token) => token.span.start < offset + term.length);
+  return isNarrowedUse(tokens, at, patternsOf(doc, "defined-term-pointer")) || headsKindPhrase(tokens, last);
+};
 
 /** The term written longer with a word of its definition (文書管理責任者, the Application), after the sentence that defines it. */
 const extendedFindings = (doc: ProseDocument, texts: readonly BodyText[], term: DefinedTerm, spans: readonly Span[], defined: readonly string[]): Finding[] => {
   const definition = definingSentence(doc, term.span)?.text ?? "";
-  const pointers = (doc.lexicons["defined-term-pointer"] ?? []).map((entry) => entry.pattern);
+  const pointers = patternsOf(doc, "defined-term-pointer");
   // Every sentence that defines the term (a second definition too) holds the long words it is defined from.
   const defining = spans.map((span) => definingSentence(doc, span)?.span ?? span);
   const definingEnd = definingSentenceEnd(doc, term.span);
@@ -182,11 +202,11 @@ export const definedTermForm: Detector = (doc, options): Finding[] => {
     const uses = usesOf(term.term, texts, spans, "loose");
     const definingEnd = definingSentenceEnd(doc, term.span);
     const quoted = quotedFindings(doc, term, uses, definingEnd);
-    const caseUses = withLoweredWords(doc, term.term, texts, spans, uses);
+    const caseUses = withLoweredWords(doc, term.term, texts, spans, uses).filter((offset) => !inEntryOfTerm(doc.sentences, term.term, offset));
     const nounUses = caseUses.filter((offset) => !isVerbAt(doc, offset));
-    const lower = lowerCaseUses(doc.source, term.term, nounUses, definingEnd, options.limit).map((offset) =>
-      finding(doc, "defined-term-form", offset, "case", { term: term.term, line: term.line }),
-    );
+    const lower = lowerCaseUses(doc.source, term.term, nounUses, definingEnd, options.limit)
+      .filter((offset) => !isOrdinaryPhraseAt(doc, offset, term.term, defined))
+      .map((offset) => finding(doc, "defined-term-form", offset, "case", { term: term.term, line: term.line }));
     return [...quoted, ...lower, ...prefixFindings(doc, texts, term, definingEnd, defined), ...extendedFindings(doc, texts, term, spans, defined)];
   });
 };
@@ -199,11 +219,31 @@ const MIN_NAME_CHARS = 4;
 /** In English a long name has two words or more (Acme Corporation); one capitalised word is the term's own kind of word. */
 const MIN_NAME_WORDS = 2;
 const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+const JAPANESE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u;
 
 const isNamePart = (token: Token): boolean => NAME_PARTS.has(token.pos) || NAME_MARKS.has(token.surface);
 
+/**
+ * A label for each of several things or for all of them together ((each, a "Certificate"), (collectively, the "Plans"))
+ * names the head of the clause before it (a certificate that represented any share of Common Stock), not its last words.
+ */
+const LABELS_THE_CLAUSE = /^[(（](?:each|collectively)\b/iu;
+
+/**
+ * Whether the words make a long name. In English, two words with letters, one of them capitalised: a figure is not a word
+ * of a name (as amended on January 26, 2015 (the "Indenture"), a par value of $1.00 (the "Preference Stock")), and lower-case
+ * words (with respect thereto) are used in their own sense. A name with Japanese in it (株式会社ABC), four characters or more.
+ */
+const isLongName = (name: string): boolean => {
+  const words = name.split(/\s+/u).filter((word) => LETTER.test(word));
+  if (words.length === 0 || [...name].length < MIN_NAME_CHARS) return false;
+  return !LATIN.test(name) || JAPANESE.test(name) || (words.length >= MIN_NAME_WORDS && words.some((word) => UPPER_START.test(word)));
+};
+
 /** The long name written right before an inline definition: the run of name words that ends at its opening bracket. */
 export const nameBefore = (sentence: Sentence, bracket: number): string | undefined => {
+  if (LABELS_THE_CLAUSE.test(sentence.text.slice(bracket - sentence.span.start))) return undefined;
   const tokens = (sentence.tokens ?? []).filter((token) => token.span.end <= bracket);
   const firstOfRun = tokens.findLastIndex((token) => !isNamePart(token)) + 1;
   if (isModifier(tokens[firstOfRun - 1])) return undefined;
@@ -212,16 +252,17 @@ export const nameBefore = (sentence: Sentence, bracket: number): string | undefi
   const end = run.at(-1);
   if (first === undefined || end === undefined || bracket - end.span.end > 1) return undefined;
   const name = withoutTrailingMarks(sentence.text.slice(first.span.start - sentence.span.start, end.span.end - sentence.span.start));
-  const words = name.split(/\s+/u).length;
-  return [...name].length < MIN_NAME_CHARS || (LATIN.test(name) && words < MIN_NAME_WORDS) ? undefined : name;
+  return isLongName(name) ? name : undefined;
 };
 
 /**
- * A word that narrows the name before it: an article, an adjective, a verb, or の (妊娠中の女性従業員, the Beta Preview, 本利用規約).
- * The words then name a kind of thing the definition picks out, not one party, and are used in their own sense again.
+ * A word that narrows the name before it: an article, an adjective, a verb, or a possessive (妊娠中の女性従業員, the Beta
+ * Preview, 本利用規約, users of Customer's Web site). The words then name a kind of thing the definition picks out, not one
+ * party, and are used in their own sense again.
  */
 const MODIFIERS = new Set(["DET", "ADJ", "VERB", "AUX"]);
-const isModifier = (token: Token | undefined): boolean => token !== undefined && (MODIFIERS.has(token.pos) || token.surface === "の");
+const POSSESSIVES = new Set(["の", "'s", "’s", "'", "’"]);
+const isModifier = (token: Token | undefined): boolean => token !== undefined && (MODIFIERS.has(token.pos) || POSSESSIVES.has(token.surface));
 
 const TRAILING_MARKS = new Set([",", ".", " "]);
 

package/src/detectors/definition-use.ts

@@ -1,6 +1,7 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText, type IsTitle, type Mentioned } from "../structure/definition-use.ts";
 import { titleLineNumbers } from "../structure/title-lines.ts";
+import { contentsLineNumbers } from "../structure/contents-lines.ts";
 import { expansionConflicts, expansionsIn } from "../acronym-expansions.ts";
 import { linesOf, lineNumberAt } from "../structure/lines.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
@@ -34,10 +35,13 @@ export const unusedDefinition: Detector = (doc): Finding[] =>
         findingAt(doc, defined.span.start, { term: defined.term }),
       );
 
-/** 題・見出し（Markdown の見出し、章・節の行、条の前の見出しの行）の上の位置か。 */
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/** 題・見出し（Markdown の見出し、章・節の行、条の前の見出しの行）と、目次・索引の行の上の位置か。 */
 const titleIn = (doc: ProseDocument): IsTitle => {
   const lines = linesOf(doc.source);
-  const numbers = titleLineNumbers(doc.structure, lines, doc.markup?.headings ?? []);
+  const headings = doc.markup?.headings ?? [];
+  const numbers = new Set([...titleLineNumbers(doc.structure, lines, headings), ...contentsLineNumbers(lines, headings, patternsOf(doc, "toc-heading"))]);
   return (offset) => numbers.has(lineNumberAt(lines, offset) ?? 0);
 };
 
@@ -45,7 +49,7 @@ const titleIn = (doc: ProseDocument): IsTitle => {
 export const useBeforeDefinition: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc), titleIn(doc)).map((use) =>
+    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc), titleIn(doc), patternsOf(doc, "self-prefix")).map((use) =>
         findingAt(doc, use.offset, { term: use.term.term, defined: use.term.line }),
       );
 

package/src/detectors/derived-numbers.ts

@@ -4,6 +4,8 @@ import { documentDateOf } from "./document-date.ts";
 import { overlapsAny, spanIndex } from "../compare/spans.ts";
 import { yearOf, type DurationUnit } from "../derived/date-arithmetic.ts";
 import { durationMismatches, type DatedValue, type Duration } from "../derived/durations.ts";
+import { isCountPerPeriod, type PeriodWord, type PerPeriodWords } from "../derived/count-per-period.ts";
+import { occurrences } from "../structure/stated-multiple.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";
@@ -91,12 +93,25 @@ 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));
 
-/** 木の数量（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 isDurationUnit = (group: string | undefined): group is DurationUnit => DURATION_LEXICONS.some(([, unit]) => unit === group);
+
+const perPeriodWordsOf = (doc: ProseDocument): PerPeriodWords => ({
+  periods: (doc.lexicons["duration-per-period"] ?? []).flatMap((entry): PeriodWord[] =>
+    isDurationUnit(entry.group) ? [{ word: entry.pattern.toLowerCase(), position: entry.position === "after" ? "after" : "before", unit: entry.group }] : [],
+  ),
+  schedules: spanIndex(occurrences(doc.source, patternsOf(doc, "weekly-days-off"))),
+});
+
+/** 木の数量（3 months）と、名詞の前に書いた期間（a 3-month trial）。期間あたりの数（週3日）は期間ではない。 */
+const durationsOf = (doc: ProseDocument, quantities: readonly Quantity[], text: string): Duration[] => {
+  const perPeriod = perPeriodWordsOf(doc);
+  return [...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) ? [] : [{ ...quantity, unit }];
+    if (unit === undefined || isApproximate(doc, quantity)) return [];
+    const duration = { ...quantity, unit };
+    return isCountPerPeriod(duration, textBefore(doc, quantity), textAfter(doc, quantity), perPeriod) ? [] : [duration];
   });
+};
 
 const sentencesOf = (doc: ProseDocument): Span[] => doc.sentences.map((sentence) => sentence.span);
 

package/src/detectors/doubled-across-aside.ts

@@ -0,0 +1,36 @@
+import type { Token } from "../plugin.ts";
+
+// 同じ助詞のあいだに括弧の注だけがある（「本利用規約は(以下、本規約)は」）。注を書き足したときに、前の助詞を消し忘れた跡。
+// 「AはBは」の対比は、あいだに語があるので当たらない。
+
+const MAX_ASIDE = 80;
+/** 注の前後に置ける空白（行の中だけ）。 */
+const MAX_SPACES = 2;
+const SPACES = `[ \\t\\u3000]{0,${String(MAX_SPACES)}}`;
+/** 助詞の後ろの、括弧ひとつの注（入れ子でない）とその前後の空白。 */
+const ASIDE = new RegExp(`^${SPACES}[（(][^（()）\\n]{1,${String(MAX_ASIDE)}}[)）]${SPACES}`, "u");
+/** 括弧と注と前後の空白が収まる長さ。これより先は読まない。 */
+const LOOK_AHEAD = MAX_ASIDE + 2 + MAX_SPACES * 2;
+
+/** 「別表の（1）の欄」の「の」は、括弧の番号を挟んで名前を続ける書き方なので数えない。 */
+const JOINS_NAMES = "の";
+
+const isParticle = (token: Token): boolean => token.pos === "ADP" && token.surface !== JOINS_NAMES;
+
+/** 二つの同じ助詞と、そのあいだの括弧の注。 */
+export type AsidePair = { readonly first: Token; readonly second: Token };
+
+/** first の後ろが括弧の注だけで、その直後に同じ助詞があれば、その助詞。source は文書全体で、token の span もその座標。 */
+const particleAfterAside = (source: string, tokens: readonly Token[], first: Token): Token | undefined => {
+  const aside = ASIDE.exec(source.slice(first.span.end, first.span.end + LOOK_AHEAD))?.[0];
+  if (aside === undefined) return undefined;
+  const second = tokens.find((token) => token.span.start === first.span.end + aside.length);
+  return second !== undefined && isParticle(second) && second.surface === first.surface ? second : undefined;
+};
+
+/** 文の語のうち、括弧の注を挟んで同じ助詞が二度ある所。Pure. */
+export const doubledAcrossAside = (source: string, tokens: readonly Token[]): AsidePair[] =>
+  tokens.flatMap((first) => {
+    const second = isParticle(first) ? particleAfterAside(source, tokens, first) : undefined;
+    return second === undefined ? [] : [{ first, second }];
+  });

package/src/detectors/doubled-punctuation.ts

@@ -1,4 +1,6 @@
-import type { Detector, Finding } from "../plugin.ts";
+import type { Detector, Finding, Span } from "../plugin.ts";
+import { latinCompanyFormRegExp, latinCompanyFormSpans } from "../latin-company-form.ts";
+import { firstEndingAfter } from "../soft-break.ts";
 import { quoteAround } from "./quote-around.ts";
 
 /**
@@ -32,16 +34,35 @@ const withoutWordDot = (text: string, found: DoubledMarks): DoubledMarks =>
     ? { start: found.start, run: found.run.slice(0, -1) }
     : found;
 
-const isSlip = (text: string, { start, run }: DoubledMarks): boolean =>
-  run.length >= 2 && !isDrawnOut(run) && !isDrawnOutThenClosed(run) && !AFTER_ABBREVIATION.test(run) && !isJoinedDots(text, start, run);
+/**
+ * 並びのうち、英字の会社の形（CO.，LTD.、INC.）の中の印の数。形の点や「，」は名前の一部で、並びの印ではない。
+ * names は昇順で重ならない（正規表現の順の一致）。並びに掛かりうるのは、並びの終わる前に始まる高々 run.length 個の形。
+ */
+const marksInNames = ({ start, run }: DoubledMarks, names: readonly Span[]): number => {
+  const first = firstEndingAfter(names, start);
+  const near = names.slice(first, first + run.length);
+  return [...run].filter((_, at) => near.some((name) => start + at >= name.start && start + at < name.end)).length;
+};
+
+const isSlip = (text: string, found: DoubledMarks, names: readonly Span[]): boolean => {
+  const { start, run } = found;
+  return (
+    run.length - marksInNames(found, names) >= 2 &&
+    !isDrawnOut(run) &&
+    !isDrawnOutThenClosed(run) &&
+    !AFTER_ABBREVIATION.test(run) &&
+    !isJoinedDots(text, start, run)
+  );
+};
 
-/** text の中の、句読点が重なった並び（位置と並び）。 */
-export const doubledMarks = (text: string): DoubledMarks[] =>
-  [...text.matchAll(PUNCTUATION_RUN)].map((match) => withoutWordDot(text, { start: match.index, run: match[0] })).filter((found) => isSlip(text, found));
+/** text の中の、句読点が重なった並び（位置と並び）。names は数えない名前（英字の会社の形）の範囲。 */
+export const doubledMarks = (text: string, names: readonly Span[] = []): DoubledMarks[] =>
+  [...text.matchAll(PUNCTUATION_RUN)].map((match) => withoutWordDot(text, { start: match.index, run: match[0] })).filter((found) => isSlip(text, found, names));
 
 export const doubledPunctuation: Detector = (doc): Finding[] => {
   const text = doc.prose ?? doc.source;
-  return doubledMarks(text).map(({ start, run }) => ({
+  const forms = latinCompanyFormRegExp((doc.lexicons["company-form-latin"] ?? []).map((entry) => entry.pattern));
+  return doubledMarks(text, latinCompanyFormSpans(text, forms)).map(({ start, run }) => ({
     rule: "",
     severity: "warning",
     line: 0,

package/src/detectors/doubled-word.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, Lexicon, Sentence, Token } from "../plugin.ts";
 import { citedNamesOf, endsCitedName } from "./cited-name.ts";
+import { doubledAcrossAside } from "./doubled-across-aside.ts";
 
 /**
  * 語を書き損じて二度書いた（the the / 資料をを）。消し忘れと、書き換えの途中で残った語（our the platform）の二つ。
@@ -159,7 +160,7 @@ export const doubledWord: Detector = (doc, options): Finding[] => {
   const kinds = new Set((doc.lexicons[DOCUMENT_KIND] ?? []).map((entry) => entry.pattern));
   const phrases = doc.lexicons[FIXED_PHRASE] ?? [];
   return doc.sentences.flatMap((sentence) =>
-    doubledIn(doc.source, sentence.tokens ?? [], spaced, allowed, phrases)
+    [...doubledIn(doc.source, sentence.tokens ?? [], spaced, allowed, phrases), ...(spaced ? [] : doubledAcrossAside(doc.source, sentence.tokens ?? []))]
       .filter((doubled) => !endsCitedName(doubled.first, doubled.second, cited, kinds))
       .map((doubled) => findingOf(sentence, doubled, spaced)),
   );

package/src/detectors/due-date.ts

@@ -4,7 +4,8 @@
 // order (dated-pair-label, date-now-word, and dated-span-label for the words whose line states a period, read up to its end,
 // or from its start in the group a dated-span-label entry names;
 // a table whose header names both columns of a pair, from dated-pair-label and the header-only dated-column-label;
-// a signature line giving a pair's later date, from the role words of dated-signer-label);
+// a signature line giving a pair's later date, from the role words of dated-signer-label;
+// a pair's label naming a version, End of support for 5.0.0 or 3.0.0 のサポート終了日, from dated-pair-version-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 { actionDueBeforeMeeting, type ActionWords } from "../structure/action-due.ts";
@@ -15,6 +16,7 @@ import { inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { periodWordsOf } from "./range-words.ts";
 import { quoteAt } from "./structure-tree.ts";
+import type { VersionWords } from "../structure/versioned-label.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). */
@@ -37,6 +39,12 @@ const actionWordsOf = (doc: ProseDocument): ActionWords => ({
   minutes: patternsOf(doc, "minutes-title-word"),
 });
 
+const versionWordsOf = (doc: ProseDocument): VersionWords => {
+  const entries = doc.lexicons["dated-pair-version-word"] ?? [];
+  const at = (position: "before" | "after"): string[] => entries.filter((entry) => entry.position === position).map((entry) => entry.pattern);
+  return { after: at("after"), before: at("before") };
+};
+
 const orderAsidesOf = (doc: ProseDocument): string[] => [...patternsOf(doc, "deadline-passed-word"), ...patternsOf(doc, "date-now-word")];
 
 const treeDates = (tree: NonNullable<ProseDocument["structure"]>): OrderDate[] =>
@@ -70,6 +78,7 @@ export const dueDate: Detector = (doc): Finding[] => {
       spans,
       whole: doc.source,
       signers: doc.lexicons["dated-signer-label"] ?? [],
+      versions: versionWordsOf(doc),
     }).map((issue) => findingOf(doc, issue, variantOf(issue))),
     ...columnDatesOutOfOrder(text, dates, [...pairs, ...(doc.lexicons["dated-column-label"] ?? [])], orderAsidesOf(doc)).map((issue) =>
       findingOf(doc, issue, "order"),

package/src/detectors/ellipsis.ts

@@ -35,6 +35,19 @@ const wordAround = (text: string, start: number, end: number): string => {
   return text.slice(from, after === -1 ? text.length : end + after);
 };
 
+/**
+ * A leader pads a label out to a column: the label opens a line or follows a sentence end, holds no space or punctuation,
+ * and two spaces or more follow the dots (化学品事業…… then two full-width spaces, then the description). One such place
+ * may be an ellipsis followed by spaces; MIN_LEADERS of them are a list of labels.
+ */
+const LEADER_LABEL = /(?:^|[\n。．！？!?])[^\S\n]*[^\s\p{P}]{1,20}$/u;
+const LEADER_PADDING = /^[^\S\n]{2}/u;
+const LABEL_REACH = 24;
+const MIN_LEADERS = 2;
+
+const isLeaderShaped = (text: string, start: number, end: number): boolean =>
+  LEADER_PADDING.test(text.slice(end)) && LEADER_LABEL.test(text.slice(Math.max(0, start - LABEL_REACH), start));
+
 /** Dots that are not an ellipsis in running text: a range, a path or address, a table of contents leader. */
 const isNotProse = (text: string, start: number, end: number): boolean =>
   NOT_PROSE_BESIDE.test(text.charAt(start - 1)) ||
@@ -50,9 +63,11 @@ export const ellipsesIn = (text: string, forms: readonly string[]): WrittenEllip
     .map(escapeRegExp)
     .join("|");
   const pattern = new RegExp(`(?<!${ELLIPSIS_PART})(?:${alternatives})(?!${ELLIPSIS_PART})`, "gu");
-  return [...text.matchAll(pattern)].flatMap((match) =>
+  const found = [...text.matchAll(pattern)].flatMap((match) =>
     isNotProse(text, match.index, match.index + match[0].length) ? [] : [{ offset: match.index, form: match[0] }],
   );
+  const leaders = found.filter((ellipsis) => isLeaderShaped(text, ellipsis.offset, ellipsis.offset + ellipsis.form.length));
+  return leaders.length < MIN_LEADERS ? found : found.filter((ellipsis) => !leaders.includes(ellipsis));
 };
 
 export const ellipsisConsistency: Detector = (doc, options): Finding[] => {