chaffjs 0.35.0 → 0.37.0

package/src/detectors/date-year.ts

@@ -1,6 +1,7 @@
 // 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 {
@@ -13,17 +14,29 @@ import {
   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. `yearHeaded`: the heading of its section
- * names a year ("FY27-Q2 (May 1)", 「2026年度の予定」), which the date takes.
+ * 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 };
+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 };
@@ -118,7 +131,8 @@ 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 point.yearHeaded === true || 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;
@@ -153,10 +167,14 @@ export const yearGaps = (
   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;
-    if (yearlySpan(point, next) || yearlySpan(previousOf.get(point), point)) 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.
@@ -172,15 +190,41 @@ export const yearGaps = (
 
 const NO_HEADING_YEAR_WORDS: HeadingYearWords = { eras: [], labels: [] };
 
-export const datePoints = (tree: StructureNode, headingWords: HeadingYearWords = NO_HEADING_YEAR_WORDS): DatePoint[] => {
+/** 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) =>
-    node.kind === "date"
-      ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]), yearHeaded: yearHeaded.has(node.span.start) }]
-      : [],
-  );
+  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 }));
 
@@ -192,17 +236,21 @@ const headingYearWordsOf = (doc: ProseDocument): HeadingYearWords => ({
   ),
 });
 
+/** 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, headingYearWordsOf(doc)), 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)];
   });
 };

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";
@@ -26,18 +27,25 @@ const findingAt = (doc: ProseDocument, offset: number, values: Readonly<Record<s
 const headingsOf = (doc: ProseDocument): BodyText[] =>
   (doc.markup?.headings ?? []).map((heading) => ({ start: heading.start, text: doc.source.slice(heading.start, heading.end) }));
 
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/** 動名詞の後ろに来て、それが目的語を取る動詞だと分かる語（冠詞と所有の語）。 */
+const DETERMINER_LISTS = ["article", "dependent-possessive"] as const;
+
 /** 定義したのに、定義の外（文と見出し）で一度も使っていない語。 */
-export const unusedDefinition: Detector = (doc): Finding[] =>
-  doc.structure === undefined
-    ? []
-    : unusedDefinitions(definedTerms(doc.structure), [...bodyOf(doc), ...headingsOf(doc)], mentionedIn(doc)).map((defined) =>
-        findingAt(doc, defined.span.start, { term: defined.term }),
-      );
+export const unusedDefinition: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const determiners = new Set(DETERMINER_LISTS.flatMap((list) => patternsOf(doc, list)));
+  return unusedDefinitions(definedTerms(doc.structure), [...bodyOf(doc), ...headingsOf(doc)], mentionedIn(doc), determiners).map((defined) =>
+    findingAt(doc, defined.span.start, { term: defined.term }),
+  );
+};
 
-/** 題・見出し（Markdown の見出し、章・節の行、条の前の見出しの行）の上の位置か。 */
+/** 題・見出し（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 +53,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/document-shape.ts

@@ -99,6 +99,24 @@ const QUESTION_END = /[?？]["'”’)）」』]*$/u;
 
 export const isQuestionHeading = (heading: string): boolean => QUESTION_END.test(heading.trim());
 
+/** A series label in brackets at a heading's end, a number and a colon opening it ("(490: Employee travel)"): the manual's reference. */
+const SERIES_LABEL_END = /[(（]\p{N}+[:：][^()（）]*[)）]$/u;
+const QUOTED = /「[^「」]*」/gu;
+const QUOTED_NAME = "「」";
+
+/**
+ * The words the heading's writer chose: without a series label at its end, and with another document's title, quoted
+ * right before what is done to it (「…の取扱いについて」等の一部改正, the cited-title-action word list), as one name.
+ */
+export const ownWordsOf = (heading: string, citedTitleActions: readonly string[]): string =>
+  heading
+    .trimEnd()
+    .replace(SERIES_LABEL_END, "")
+    .trimEnd()
+    .replaceAll(QUOTED, (quote, offset: number) =>
+      citedTitleActions.some((action) => action !== "" && heading.startsWith(action, offset + quote.length)) ? QUOTED_NAME : quote,
+    );
+
 /** The heading's words without a number label at its head (Chapter 2, 1.), from the section the heading opens. */
 const unlabeledOf = (doc: ProseDocument, heading: MarkupHeading): string =>
   doc.sections.find((section) => section.span.start === heading.end)?.unlabeledHeading ?? heading.text;
@@ -107,10 +125,11 @@ const unlabeledOf = (doc: ProseDocument, heading: MarkupHeading): string =>
 export const titleLength: Detector = (doc, options): Finding[] => {
   const headings = writtenHeadings(doc);
   const title = headings.find((heading) => heading.depth === 1);
+  const citedTitleActions = (doc.lexicons["cited-title-action"] ?? []).map((entry) => entry.pattern);
   return headings
     .map((heading) => ({ heading, words: unlabeledOf(doc, heading) }))
     .filter(({ words }) => !isParagraphHeading(words) && !isQuestionHeading(words))
-    .map(({ heading, words }) => ({ heading, count: headingLength(words, doc.lengthUnit) }))
+    .map(({ heading, words }) => ({ heading, count: headingLength(ownWordsOf(words, citedTitleActions), doc.lengthUnit) }))
     .filter(({ count }) => count > options.limit)
     .map(({ heading, count }) => ({
       ...findingAt(doc, heading, { heading: heading.text.trim(), count, limit: options.limit }, heading === title ? "title" : undefined),

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/duplicate-heading.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, MarkupHeading } from "../plugin.ts";
 import { lineNumberAt, linesOf } from "../structure/lines.ts";
+import { recordLabelOf, recordRhythmMask } from "./heading-record-rhythm.ts";
 import { findingAt, writtenHeadings } from "./markup-finding.ts";
 
 /** 見出しの言葉を比べる形。全角と半角、大文字と小文字、空白の数は同じ見出しの違いにしない。 */
@@ -21,22 +22,44 @@ export type RepeatedHeading = { readonly heading: MarkupHeading; readonly first:
 
 type Seen = Map<number, Map<string, MarkupHeading>>;
 
+/** 見出しごとに、同じ親の下の兄弟の型の並びで、決まった見出しの組をくり返す所にあるか（recordRhythmMask）。 */
+const inRecordRhythm = (parents: readonly number[], keys: readonly string[]): boolean[] => {
+  const byParent = new Map<number, number[]>();
+  parents.forEach((parent, index) => {
+    const siblings = byParent.get(parent) ?? [];
+    siblings.push(index);
+    byParent.set(parent, siblings);
+  });
+  const inRhythm = keys.map(() => false);
+  byParent.forEach((indexes) => {
+    const mask = recordRhythmMask(indexes.map((index) => recordLabelOf(keys[index] ?? "")));
+    indexes.forEach((index, at) => {
+      inRhythm[index] = mask[at] === true;
+    });
+  });
+  return inRhythm;
+};
+
 /**
  * 同じ親の下で、前の見出しと同じ言葉の見出し（markdownlint の MD024 siblings_only）。変更履歴の版ごとの「Added」「Fixed」のように、
  * 親が違えば同じ言葉でもよい。深さが違っても親が同じなら兄弟として比べる（飛んだ深さの見出しも同じ親の下にある）。
+ * 事例ごとに決まった見出しの組をくり返す所（recordRhythmMask）は、文書の作りとしての重複なので言わない。
  */
 export const repeatedSiblingHeadings = (headings: readonly MarkupHeading[]): RepeatedHeading[] => {
   const parents = parentIndexes(headings);
+  const keys = headings.map((heading) => headingKey(heading.text));
+  const inRhythm = inRecordRhythm(parents, keys);
   const seen: Seen = new Map();
-  return headings.flatMap((heading, index) => {
-    const key = headingKey(heading.text);
+  const repeats = headings.flatMap((heading, index) => {
+    const key = keys[index] ?? "";
     const parent = parents[index] ?? -1;
     const siblings = seen.get(parent) ?? new Map<string, MarkupHeading>();
     seen.set(parent, siblings);
     const first = siblings.get(key);
     if (first === undefined) siblings.set(key, heading);
-    return first === undefined || key === "" ? [] : [{ heading, first }];
+    return first === undefined || key === "" || inRhythm[index] === true ? [] : [{ heading, first }];
   });
+  return repeats;
 };
 
 export const duplicateHeading: Detector = (doc): Finding[] => {

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[] => {