chaffjs 0.36.0 → 0.37.0

package/src/detectors/citation-sentence.ts

@@ -0,0 +1,44 @@
+// A bibliographic citation written out as a sentence, as in a footnote: authors and the year in parentheses, then a title
+// or a publisher. Its length is the length of the reference, not of the writer's prose. Pure.
+import { escapeRegExp } from "../orthography.ts";
+
+/** "Keys and Reina (2025)," or "Federal Housing Finance Agency (n.d.),": the year in parentheses, a comma after it. */
+const AUTHOR_YEAR = /\((?:\d{4}[a-z]?|n\.d\.)\),/gu;
+
+/** What only a reference carries: a quoted title right after the year, a place and its publisher, or a page range. */
+const PUBLICATION_MARKS: readonly RegExp[] = [
+  /\((?:\d{4}[a-z]?|n\.d\.)\),\s*["“]/u,
+  /\(\p{Lu}[\p{L}.'’-]*(?:,?\s\p{Lu}[\p{L}.'’-]*)*:\s\p{Lu}[^()]*\)/u,
+  /\bpp?\.\s*\d+\s*[-–−]\s*\d+/u,
+];
+
+/** Where the citation's year stands: the last year before the first mark of a publication, or the first year when none is before it. */
+const citationYearAt = (text: string): number | undefined => {
+  const years = [...text.matchAll(AUTHOR_YEAR)].map((match) => match.index);
+  const marks = PUBLICATION_MARKS.flatMap((mark) => {
+    const found = mark.exec(text);
+    return found === null ? [] : [found.index + found[0].length];
+  });
+  if (years.length === 0 || marks.length === 0) return undefined;
+  const firstMark = Math.min(...marks);
+  return years.filter((at) => at < firstMark).at(-1) ?? years[0];
+};
+
+export const isCitationSentence = (text: string): boolean => citationYearAt(text) !== undefined;
+
+const signalPattern = (signals: readonly string[]): RegExp | undefined =>
+  signals.length === 0 ? undefined : new RegExp(String.raw`(?<![\p{L}\p{N}])(?:${signals.map(escapeRegExp).join("|")})(?![\p{L}\p{N}])`, "giu");
+
+/**
+ * The writer's own words in a citation sentence: what comes before the last citation signal ("see", from the language's
+ * word list) ahead of the citation's year, or everything before the year when no signal stands there (the authors' names
+ * are short). "For example, see Lisa Cook (2024), …" leads with "For example,". Undefined when the sentence is not a citation.
+ */
+export const citationLead = (text: string, signals: readonly string[]): string | undefined => {
+  const yearAt = citationYearAt(text);
+  if (yearAt === undefined) return undefined;
+  const beforeYear = text.slice(0, yearAt);
+  const pattern = signalPattern(signals);
+  const lastSignal = pattern === undefined ? undefined : [...beforeYear.matchAll(pattern)].at(-1);
+  return (lastSignal === undefined ? beforeYear : beforeYear.slice(0, lastSignal.index)).trim();
+};

package/src/detectors/contraction-mention.ts

@@ -0,0 +1,24 @@
+import { quotedSpans } from "../quoted-span.ts";
+
+// A short phrase in quotation marks ("Do Not Disturb", ‘we’re going to x’) is a name or an example: the form is mentioned,
+// not used, so it says nothing about the document's register. Spoken words carry punctuation ("We don't know," she
+// said) and stay. The text must already have straight apostrophes, so a ’ left in it closes a quotation.
+
+const MENTION_MARKS: Readonly<Record<string, string>> = { "“": "”", '"': '"', "‘": "’" };
+/** More words than this in quotation marks is a quoted sentence, not a phrase named as an example. */
+const MAX_MENTION_WORDS = 4;
+const PHRASE = /^[\p{L}' ]+$/u;
+
+const isMention = (quoted: string): boolean => {
+  const phrase = quoted.trim();
+  return PHRASE.test(phrase) && phrase.split(/\s+/u).length <= MAX_MENTION_WORDS;
+};
+
+/** The text with each quoted short phrase blanked out, every other character at its place. */
+export const withoutMentions = (text: string): string => {
+  const mentions = quotedSpans(text, MENTION_MARKS).filter((span) => isMention(text.slice(span.start, span.end)));
+  if (mentions.length === 0) return text;
+  const units = text.split("");
+  mentions.forEach((span) => units.fill(" ", span.start, span.end));
+  return units.join("");
+};

package/src/detectors/dash-break.ts

@@ -0,0 +1,45 @@
+// A dash with space on both sides after the last comma before an and / or ("Washington, DC – The Cybersecurity and
+// Infrastructure Security Agency"). The dash closes off what came before it, a dateline here, so the commas before it
+// do not separate the items of a list the and / or ends. Commas and dashes inside brackets or quotation marks are not
+// the and / or's own. Pure, and one pass over the sentence.
+import type { Token } from "../plugin.ts";
+
+const DASHES = new Set(["–", "—", "―", "-", "--"]);
+const OPENERS = new Set(["(", "[", "{", "“"]);
+const CLOSERS = new Set([")", "]", "}", "”"]);
+const SPACE = /\s/u;
+
+const isSpacedDash = (token: Token, source: string): boolean =>
+  DASHES.has(token.surface) && SPACE.test(source.charAt(token.span.start - 1)) && SPACE.test(source.charAt(token.span.end));
+
+/** The last comma and the last spaced dash seen at one depth of brackets. */
+type Seen = { comma: number; dash: number };
+
+type Scan = { depth: number; readonly seen: Seen[]; readonly breaks: boolean[] };
+
+const seenAt = (scan: Scan): Seen => {
+  const seen = scan.seen[scan.depth] ?? { comma: -1, dash: -1 };
+  scan.seen[scan.depth] = seen;
+  return seen;
+};
+
+/**
+ * For each token, whether a spaced dash comes between the last comma before it and it, at its depth, and not right
+ * before it: a dash right before the and / or sets off its last item (the plan, the budget – and the schedule).
+ */
+export const dashBreaks = (tokens: readonly Token[], source: string): boolean[] =>
+  tokens.reduce<Scan>(
+    (scan, token, at) => {
+      if (CLOSERS.has(token.surface)) {
+        scan.seen.length = scan.depth;
+        scan.depth = Math.max(0, scan.depth - 1);
+      }
+      const seen = seenAt(scan);
+      scan.breaks.push(seen.comma !== -1 && seen.dash > seen.comma && seen.dash < at - 1);
+      if (token.surface === ",") seen.comma = at;
+      if (isSpacedDash(token, source)) seen.dash = at;
+      if (OPENERS.has(token.surface)) scan.depth += 1;
+      return scan;
+    },
+    { depth: 0, seen: [], breaks: [] },
+  ).breaks;

package/src/detectors/date-any-year.ts

@@ -24,7 +24,7 @@ export type AnyYearMarker = { readonly word: string; readonly reach: MarkerReach
 /** The span of a yearless date in the source. */
 export type DateSpan = { readonly offset: number; readonly end: number };
 
-/** How far apart the two ends of a period may stand: the joiner and a year word (「から翌年」, " to "). */
+/** How far apart the two ends of a period may stand besides the joiner itself: a year word (「から翌年」, " to the next "). */
 const SPAN_GAP_REACH = 12;
 
 /** How many lines above a list item its introducing line is looked for: a longer list is read as no example. */
@@ -191,7 +191,11 @@ export const anyYearDate = (date: DateSpan, source: string, markers: readonly An
 
 /** The date opens a period whose other end, just after it, follows a joiner (「4月1日から翌年3月31日」). */
 export const opensSpan = (date: DateSpan, next: DateSpan | undefined, source: string, joiners: readonly string[]): boolean => {
-  if (next === undefined || next.offset - date.end > SPAN_GAP_REACH) return false;
+  const longest = Math.max(0, ...joiners.map((joiner) => joiner.length));
+  if (next === undefined || next.offset - date.end > SPAN_GAP_REACH + longest) return false;
   const gap = source.slice(date.end, next.offset).trimStart();
-  return !SENTENCE_END.test(gap) && joiners.some((joiner) => joiner !== "" && gap.startsWith(joiner) && !runsOn(gap, joiner));
+  return (
+    !SENTENCE_END.test(gap) &&
+    joiners.some((joiner) => joiner !== "" && gap.length - joiner.length <= SPAN_GAP_REACH && gap.startsWith(joiner) && !runsOn(gap, joiner))
+  );
 };

package/src/detectors/definition-use.ts

@@ -27,16 +27,20 @@ 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) }));
 
-/** 定義したのに、定義の外（文と見出し）で一度も使っていない語。 */
-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 }),
-      );
-
 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[] => {
+  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 の見出し、章・節の行、条の前の見出しの行）と、目次・索引の行の上の位置か。 */
 const titleIn = (doc: ProseDocument): IsTitle => {
   const lines = linesOf(doc.source);

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/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/email-letter.ts

@@ -1,9 +1,10 @@
 // A work email or letter's own parts: a greeting and a closing, a subject line, and an attachment the text mentions.
 // Pure. The words (お世話になっております, Dear, Best regards, 件名, attached) come from the language's email-greeting,
-// email-closing, email-sentence-end, memo-header-label, email-subject-field, attachment-mention, attachment-not-mention and attachment-line lexicons. The
+// email-closing, email-sentence-end, memo-header-label, notice-header, email-subject-field, attachment-mention, attachment-not-mention and attachment-line lexicons. The
 // header and the signature are masked in doc.prose; a quoted reply is someone else's words and is left out.
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { isNoticeHead, noticeWordsOf } from "../notice-header.ts";
 import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
 
 /** A greeting comes before the body: past the subject, the addressee (株式会社… / 総務部 山田様) and the writer's name. */
@@ -123,18 +124,51 @@ export const greetingLineCount = (lines: readonly BodyLine[], sentenceEnds: read
   return Math.max(GREETING_LINES, firstSentence + 1);
 };
 
-/** A missing greeting (none in the first lines, or past the letter's header) and a missing closing (none in the last lines of any part). */
+/** A signing line: a rule of underscores the writer signs on, alone on its line (not "Date: ____", a field to fill in). */
+const SIGNING_LINE = /^[ \t]*_{5,}[ \t]*$/u;
+
+/** The signer's name or title under a signing line is short; a paragraph there means the underscores were a section break. */
+const MAX_SIGNER_LENGTH = 60;
+
+/** Whether the next line with text is a signer's line: short, holding a letter, not a heading. */
+const signerBelow = (lines: readonly SourceLine[], index: number): boolean => {
+  const below = nextText(lines, index);
+  const signer = withoutMarks(below);
+  return !below.startsWith("#") && [...signer].length <= MAX_SIGNER_LENGTH && LETTER.test(signer);
+};
+
+/** Where each signing line starts in the source: underscores alone on a line, a signer's line below, outside a quoted reply. */
+export const signingLines = (source: string, replyQuotes: readonly Span[] = []): number[] => {
+  const quoted = insideCursor(replyQuotes);
+  const lines = linesWithOffsets(source);
+  return lines.flatMap(({ start, text }, index) => (!quoted(start) && SIGNING_LINE.test(text) && signerBelow(lines, index) ? [start] : []));
+};
+
+/** Whether a signing line stands among the part's last lines or between them and the next part: the part is signed off. */
+const signedOff = (part: readonly BodyLine[], next: BodyLine | undefined, signings: readonly number[]): boolean => {
+  const from = part.slice(-CLOSING_LINES)[0]?.start ?? Infinity;
+  return signings.some((offset) => offset >= from && offset < (next?.start ?? Infinity));
+};
+
+/**
+ * A missing greeting (none in the first lines, or past the letter's header) and a missing closing: none in the last lines
+ * of any part, and no part signed off on a signing line (a letter signed before an acceptance block the recipient signs).
+ */
 export const frameSlips = (
   lines: readonly BodyLine[],
   greetings: readonly string[],
   closings: readonly string[],
   sentenceEnds: readonly string[],
+  signings: readonly number[] = [],
 ): FrameSlip[] => {
   const first = lines[0];
   const last = lines.at(-1);
   if (first === undefined || last === undefined) return [];
   const greeted = lines.slice(0, greetingLineCount(lines, sentenceEnds)).some((line) => lineHas(line.text, greetings));
-  const closed = partsOf(lines).some((part) => part.slice(-CLOSING_LINES).some((line) => lineHas(line.text, closings)));
+  const parts = partsOf(lines);
+  const closed = parts.some(
+    (part, index) => part.slice(-CLOSING_LINES).some((line) => lineHas(line.text, closings)) || signedOff(part, parts[index + 1]?.[0], signings),
+  );
   return [
     ...(greeted ? [] : [{ variant: "greeting" as const, offset: first.start }]),
     ...(closed ? [] : [{ variant: "closing" as const, offset: last.start }]),
@@ -169,17 +203,26 @@ export const isMemoLabel = (line: string, labels: readonly string[]): boolean =>
  * one). The source, not the body, since a block of TO: / FROM: lines is masked as an email's header. A memo takes no
  * greeting and no closing.
  */
-export const isMemo = (source: string, labels: readonly string[], sentenceEnds: readonly string[]): boolean => {
+export const isMemo = (source: string, labels: readonly string[], sentenceEnds: readonly string[]): boolean =>
+  headLines(source, sentenceEnds).some((line) => isMemoLabel(line, labels));
+
+/** The source's lines before the first sentence (the first lines, when no line ends one), past blank lines and a quoted reply. */
+export const headLines = (source: string, sentenceEnds: readonly string[]): string[] => {
   const lines = source.split("\n").filter((line) => line.trim() !== "" && !line.trimStart().startsWith(">"));
   const firstSentence = lines.findIndex((line) => endsSentence(line, sentenceEnds));
-  return lines.slice(0, firstSentence === -1 ? HEADER_LINES : firstSentence).some((line) => isMemoLabel(line, labels));
+  return lines.slice(0, firstSentence === -1 ? HEADER_LINES : firstSentence);
 };
 
+/** A memo (TO: / 発信者：) or an official notice (課資2－7 / 各国税局長 殿) takes no greeting and no closing. */
+const takesNoFrame = (doc: ProseDocument, sentenceEnds: readonly string[]): boolean =>
+  isMemo(doc.source, patternsOf(doc, "memo-header-label"), sentenceEnds) ||
+  isNoticeHead(headLines(doc.source, sentenceEnds), noticeWordsOf(doc.lexicons["notice-header"] ?? []));
+
 const frameSlipsOf = (doc: ProseDocument): FrameSlip[] => {
   const sentenceEnds = patternsOf(doc, "email-sentence-end");
-  if (isMemo(doc.source, patternsOf(doc, "memo-header-label"), sentenceEnds)) return [];
+  if (takesNoFrame(doc, sentenceEnds)) return [];
   const lines = bodyLines(doc.source, doc.prose ?? doc.source, doc.replyQuotes ?? []);
-  return frameSlips(lines, patternsOf(doc, "email-greeting"), patternsOf(doc, "email-closing"), sentenceEnds);
+  return frameSlips(lines, patternsOf(doc, "email-greeting"), patternsOf(doc, "email-closing"), sentenceEnds, signingLines(doc.source, doc.replyQuotes ?? []));
 };
 
 export const emailFrame: Detector = (doc): Finding[] =>

package/src/detectors/fullwidth-alnum.ts

@@ -91,6 +91,14 @@ const otherWidth = (run: AlnumRun): string => (run.fullwidth ? run.written.norma
 
 type Located = { readonly sentence: Sentence; readonly run: AlnumRun };
 
+const HALFWIDTH_LOWER = /[a-z]/u;
+
+/**
+ * 小文字を含む半角の英字の語（AI for Science の for と Science）。英語の語は、略語を全角で書く文書（ＡＩ）でも半角で書く。
+ * 文書の英字の書き方の票には入れるが、少ないほうとしては指摘しない。
+ */
+const isHalfwidthEnglishWord = (run: AlnumRun): boolean => run.kind === "letters" && !run.fullwidth && HALFWIDTH_LOWER.test(run.written);
+
 const findingOf = ({ sentence, run }: Located, count: number, of: number, limit: number): Finding => ({
   rule: "",
   severity: "warning",
@@ -113,6 +121,6 @@ export const fullwidthAlnum: Detector = (doc, options): Finding[] => {
   return KINDS.flatMap((kind) => {
     const ofKind = located.filter(({ run }) => run.kind === kind);
     const odd = minorityWithin(ofKind, ({ run }) => run.fullwidth, options.limit);
-    return odd.map((entry) => findingOf(entry, odd.length, ofKind.length, options.limit));
+    return odd.filter(({ run }) => !isHalfwidthEnglishWord(run)).map((entry) => findingOf(entry, odd.length, ofKind.length, options.limit));
   });
 };

package/src/detectors/gram-openers.ts

@@ -6,16 +6,45 @@ const LIST_OR_TABLE_NEXT = /^[ \t]*\n\s*(?:[-*+]\s|\d{1,3}[.)]\s|\|)/u;
 /** How far past the sentence to look for that line: blank lines between, never the rest of a long document. */
 const LOOKAHEAD = 200;
 
+/** 番号の印（（1）、(2)、3．、第4、⑤）。数の点の後ろに数字が続けば小数（3.14）。 */
+const ITEM_LABEL = String.raw`(?:[（(][\d０-９一二三四五六七八九十]{1,3}[）)]|[\d０-９]{1,3}[．.)）](?![\d０-９])|第[\d０-９一二三四五六七八九十]{1,3}|[①-⑳])`;
+/** 箇条書きの印（- 、1. ）。 */
+const LIST_MARKER = String.raw`(?:[-*+]|\d{1,3}[.)])[ \t]+`;
+const OPENS_WITH_LABEL = new RegExp(String.raw`^\s*${ITEM_LABEL}`, "u");
+const SENTENCE_END = /[。．.!?！？]\s*$/u;
+/** 行の頭か、箇条書きの印の後ろ。 */
+const LINE_START = new RegExp(String.raw`(?:^|\n)[ \t]*(?:${LIST_MARKER})?$`, "u");
+const LINE_START_REACH = 8;
+/**
+ * 行の終わりの後ろの、次の空でない行が本文であること。次の行も番号の印で始まれば、番号を振った項目の並び（（1）申請書を出す、
+ * （2）…）で、見出しではない。
+ */
+const FOLLOWED_BY_BODY = new RegExp(String.raw`^[ \t]*\n\s*(?!(?:${LIST_MARKER})?${ITEM_LABEL})\S`, "u");
+
+/**
+ * 行の頭の番号の印で始まり、句点で終わらず、一行を占め、後ろに本文が続く文（「（1）芸術の振興に係る規定に関する改正（第8条関係）」）。項目ごとの見出しで、
+ * 並べた見出しは同じ枠（…に係る規定に関する改正）を繰り返す。言い回しがどれもこの文にだけ出るなら見出しのひな形。
+ */
+export const itemTitles = (sentences: readonly Sentence[], source: string): Sentence[] =>
+  sentences.filter(
+    (sentence) =>
+      OPENS_WITH_LABEL.test(sentence.text) &&
+      !SENTENCE_END.test(sentence.text) &&
+      LINE_START.test(source.slice(Math.max(0, sentence.span.start - LINE_START_REACH), sentence.span.start)) &&
+      FOLLOWED_BY_BODY.test(source.slice(sentence.span.end, sentence.span.end + LOOKAHEAD)),
+  );
+
 /**
  * 見出しのある節の最初の文のうち、次の行から箇条書きか表が続くもの。参照用の文書は、節ごとに同じ書き出しで一覧を導く
  * （「…によると以下の制約である。」の後ろに制約の箇条書き）。言い回しがどれもこの文にだけ出るなら節のひな形で、書き手が言い直したのではない。
  * 後ろが本文の文なら、節ごとの口癖（正直なところ、…）と見分けられないので入れない。導入部（見出しの前）は節ではない。
  */
+const leadsIntoList = (section: Pick<Section, "depth" | "sentences">, source: string): Sentence[] => {
+  const first = section.sentences[0];
+  if (section.depth === 0 || first === undefined) return [];
+  return LIST_OR_TABLE_NEXT.test(source.slice(first.span.end, first.span.end + LOOKAHEAD)) ? [first] : [];
+};
+
+/** 節のひな形の文: 一覧を導く節の最初の文と、項目ごとの見出し（itemTitles）。 */
 export const sectionOpeners = (sections: readonly Pick<Section, "depth" | "sentences">[], source: string): Set<Sentence> =>
-  new Set(
-    sections.flatMap((section) => {
-      const first = section.sentences[0];
-      if (section.depth === 0 || first === undefined) return [];
-      return LIST_OR_TABLE_NEXT.test(source.slice(first.span.end, first.span.end + LOOKAHEAD)) ? [first] : [];
-    }),
-  );
+  new Set(sections.flatMap((section) => [...leadsIntoList(section, source), ...itemTitles(section.sentences, source)]));

package/src/detectors/heading-record-rhythm.ts

@@ -0,0 +1,57 @@
+/** 見出しの言葉から括弧の添え書き（「事例（約款）」の「（約款）」）を除いた、記録の型としての言葉。 */
+export const recordLabelOf = (key: string): string => {
+  const stem = key.replace(/[（(][^（）()]*[）)]/gu, "").trim();
+  return stem === "" ? key : stem;
+};
+
+/** start から period 個の型がみな違うか。窓をずらしながら数えるので、一つの period で列全体を一度なめるだけ。 */
+const distinctWindows = (labels: readonly string[], period: number): boolean[] => {
+  const counts = new Map<string, number>();
+  const add = (label: string | undefined, by: number): void => {
+    if (label !== undefined) counts.set(label, (counts.get(label) ?? 0) + by);
+    if (label !== undefined && counts.get(label) === 0) counts.delete(label);
+  };
+  return labels.map((label, start) => {
+    if (start === 0) labels.slice(0, period).forEach((first) => add(first, 1));
+    else {
+      add(labels[start - 1], -1);
+      add(labels[start + period - 1], 1);
+    }
+    return start + period <= labels.length && counts.size === period;
+  });
+};
+
+/** 各位置までに、period 前と同じ型だった位置の数（累積）。 */
+const repeatCounts = (labels: readonly string[], period: number): number[] =>
+  labels.reduce<number[]>((sums, label, at) => {
+    sums.push((sums.at(-1) ?? 0) + (at >= period && labels[at - period] === label ? 1 : 0));
+    return sums;
+  }, []);
+
+/** period の組が二度続く窓 [start, start + 2 * period) を、覆う範囲の印として足す。 */
+const markRepeats = (labels: readonly string[], period: number, cover: number[]): void => {
+  const distinct = distinctWindows(labels, period);
+  const repeats = repeatCounts(labels, period);
+  const repeatsIn = (from: number, to: number): number => (repeats[to - 1] ?? 0) - (repeats[from - 1] ?? 0);
+  distinct.forEach((isDistinct, start) => {
+    const end = start + 2 * period;
+    if (!isDistinct || end > labels.length || repeatsIn(start + period, end) !== period) return;
+    cover[start] = (cover[start] ?? 0) + 1;
+    cover[end] = (cover[end] ?? 0) - 1;
+  });
+};
+
+/**
+ * 兄弟の見出しの型（recordLabelOf）の並びで、「二つ以上の違う型の組が、同じ順で二度続く」所にある見出しの印。
+ * 事例ごとに【相談事例】【アドバイス】、Question / Answer をくり返す FAQ の決まった見出しで、写し忘れの重複ではない。
+ * 組の長さごとに列を一度なめるので、見出しの数の二乗で済む。
+ */
+export const recordRhythmMask = (labels: readonly string[]): boolean[] => {
+  const cover = Array.from({ length: labels.length + 1 }, () => 0);
+  Array.from({ length: Math.max(0, Math.floor(labels.length / 2) - 1) }, (_, offset) => offset + 2).forEach((period) => markRepeats(labels, period, cover));
+  const depths = cover.reduce<number[]>((sums, change) => {
+    sums.push((sums.at(-1) ?? 0) + change);
+    return sums;
+  }, []);
+  return labels.map((_, at) => (depths[at] ?? 0) > 0);
+};

package/src/detectors/kutoten-consistency.ts

@@ -76,6 +76,14 @@ const isNextInRun = ({ source, offset }: Place): boolean => {
   return previous > 0 && countsUpTo(earlier, previous);
 };
 
+/**
+ * 番号を指す点（「3．から5．までの規定」「（1）4．の改正」）。数の点の直後に、番号を受ける助詞が続く。文の終わりの点の後ろは
+ * 次の文の頭。一字の助詞は後ろが平仮名でないときだけ（「のちほど」は文の頭）。文の頭になる語の字（で、も、は、と）は入れない。
+ */
+const ITEM_REFERENCE_AFTER = /^(?:から|まで|及び|又は|並びに|[のをにへ](?![ぁ-ゖ]))/u;
+
+const isItemReference = ({ text, at }: Place): boolean => DIGIT.test(text.charAt(at - 1)) && ITEM_REFERENCE_AFTER.test(text.slice(at + 1));
+
 const isInsideNumber = (text: string, at: number): boolean => DIGIT.test(text.charAt(at - 1)) && DIGIT.test(text.charAt(at + 1));
 
 const isLabelPeriod = (place: Place, kana: ReadonlySet<string>): boolean => {
@@ -86,6 +94,7 @@ const isLabelPeriod = (place: Place, kana: ReadonlySet<string>): boolean => {
     ((NOTE_NUMBER_LABEL.test(text.slice(Math.max(0, at - NOTE_REACH), at)) || CLOSED_FIRST_NUMBER.test(beforeNumber)) &&
       isFollowed(place.source, place.offset)) ||
     isNextInRun(place) ||
+    isItemReference(place) ||
     LIST_NUMBER.test(beforeNumber) ||
     LATIN_LABEL.test(text.slice(Math.max(0, at - LATIN_LABEL_REACH), at))
   );

package/src/detectors/lexicon.ts

@@ -1,11 +1,12 @@
 import { joinWords } from "./word-list.ts";
 import { pairMinority } from "./contraction-minority.ts";
+import { withoutMentions } from "./contraction-mention.ts";
 import { straightApostrophes } from "../orthography.ts";
 import { wordsOf } from "./structure.ts";
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 import { entryIn, entryOpens, entryRanges, type TokenRange } from "./lexicon-match.ts";
 import { scoped, scopeMarkersOf, type ScopeMarkers } from "./superlative-scope.ts";
-import { namesQuantity } from "./superlative-name.ts";
+import { makesWord, namesQuantity } from "./superlative-name.ts";
 import { namesAmount } from "./superlative-amount.ts";
 import { restricted, type Restrictors } from "./superlative-clause.ts";
 import { stackedHedges, type StackedHedge } from "./stacked-hedge.ts";
@@ -121,6 +122,7 @@ type Qualifiers = {
   readonly comparison: ComparisonMarkers;
   readonly scope: ScopeMarkers;
   readonly quantityNouns: Lexicon;
+  readonly suffixes: Lexicon;
   readonly amounts: Lexicon;
   readonly restrictors: Restrictors;
 };
@@ -129,6 +131,7 @@ const qualifiersOf = (doc: ProseDocument): Qualifiers => ({
   comparison: comparisonMarkersOf(doc.lexicons["comparison-marker"] ?? []),
   scope: scopeMarkersOf(doc.lexicons["superlative-scope"] ?? []),
   quantityNouns: doc.lexicons["quantity-noun"] ?? [],
+  suffixes: doc.lexicons["superlative-suffix"] ?? [],
   amounts: doc.lexicons["superlative-amount"] ?? [],
   restrictors: {
     relatives: doc.lexicons["relative-word"] ?? [],
@@ -143,6 +146,7 @@ const qualifiedAt = (tokens: readonly Token[], range: TokenRange, qualifiers: Qu
   scoped(tokens, range, qualifiers.scope) ||
   restricted(tokens, range, qualifiers.restrictors) ||
   namesQuantity(tokens, range, qualifiers.quantityNouns) ||
+  makesWord(tokens, range, qualifiers.suffixes) ||
   namesAmount(tokens, range, qualifiers.amounts);
 
 /** どの出現も引いた言葉か、限られているか、量を言うときだけ。1 つでもそうでない出現があれば、その文には限定の無い最上級がある。 */
@@ -283,7 +287,7 @@ const containsWord = (text: string, word: string): boolean => wordUses(text, wor
  * アポストロフィの形（don’t と don't）は短縮形かどうかを変えない。違うのは印刷の形で、文体ではない。
  * 折り返した行（「do」で改行して「not」）も、空白 1 つと同じに読む。
  */
-const comparableText = (sentence: Sentence): string => straightApostrophes(sentence.text).replace(/\s+/gu, " ").toLowerCase();
+const comparableText = (sentence: Sentence): string => withoutMentions(straightApostrophes(sentence.text)).replace(/\s+/gu, " ").toLowerCase();
 
 type MixedPair = { readonly minority: string; readonly majority: string; readonly count: number };
 

package/src/detectors/mark-shape.ts

@@ -5,7 +5,7 @@ import { minorityReport } from "../spacing-minority.ts";
 import { externalLinkTitleSpans } from "../link-title.ts";
 import { formulaBracketSpans } from "../formula-brackets.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
-import { captionsOf, isCaptionAt, letterheadSpans } from "./caps-caption.ts";
+import { capitalLineSpans, captionsOf, isCaptionAt, isWithinSorted } from "./caps-caption.ts";
 import { lineStarts } from "../position.ts";
 
 /** The letters a mark must touch to count as part of the document's text, by language. */
@@ -125,6 +125,28 @@ const ENUMERATOR_KIND = "\u0000enumerator";
 const withEnumeratorKind = (mark: Mark, enumerators: ReadonlySet<number>): Mark =>
   enumerators.has(mark.offset) ? { ...mark, form: { ...mark.form, kind: `${mark.form.kind}${ENUMERATOR_KIND}` } } : mark;
 
+/**
+ * A doubled parenthesis around text with no parenthesis inside, such as ((居住の用に供したとき等)) or （（注））: one mark written
+ * with two characters, as a directive sets an article's caption. Its width is that notation's, not the prose's.
+ */
+const DOUBLED_PAREN = /\(\([^()（）\n]*\)\)|（（[^()（）\n]*））/gu;
+const PAIR_LENGTH = 2;
+
+/** The offsets in `source` of every character of a doubled parenthesis. */
+export const doubledParenOffsets = (source: string): ReadonlySet<number> =>
+  new Set(
+    [...source.matchAll(DOUBLED_PAREN)].flatMap((match) => {
+      const end = match.index + match[0].length;
+      return [match.index, match.index + 1, end - PAIR_LENGTH, end - 1];
+    }),
+  );
+
+const DOUBLED_KIND = "\u0000doubled";
+
+/** A doubled parenthesis is a kind of its own, compared only with the other doubled parentheses. */
+const withDoubledKind = (mark: Mark, doubled: ReadonlySet<number>): Mark =>
+  doubled.has(mark.offset) ? { ...mark, form: { ...mark.form, kind: `${mark.form.kind}${DOUBLED_KIND}` } } : mark;
+
 /**
  * A mark written two ways in one document (（ and (, “ and "), the less common way reported. The two ways come from the
  * lexicon; neither is called right. Only marks next to a letter of the document's script count, so a bracket in code-like
@@ -137,7 +159,10 @@ export const markConsistency: Detector = (doc, options): Finding[] => {
   const titles = externalLinkTitleSpans(doc.source, doc.links);
   const forms = formsOf(options.lexicon ?? []);
   const enumerators = enumeratorBracketOffsets(doc.source);
-  const marks = ownSentences(doc).flatMap((sentence) => marksIn(doc.source, sentence, forms, script).map((mark) => withEnumeratorKind(mark, enumerators)));
+  const doubled = doubledParenOffsets(doc.source);
+  const marks = ownSentences(doc).flatMap((sentence) =>
+    marksIn(doc.source, sentence, forms, script).map((mark) => withDoubledKind(withEnumeratorKind(mark, enumerators), doubled)),
+  );
   const kinds = [...new Set(marks.map((mark) => mark.form.kind))];
   return kinds.flatMap((kind) =>
     minorityFindings(
@@ -263,17 +288,17 @@ export const isShouting = (run: string, known: ReadonlySet<string>, conventional
 
 /**
  * Runs of three or more all-capital words that are ordinary words, not acronyms ("DO NOT DELETE THIS"), and not a
- * caption, a mention of one, or a letterhead.
+ * caption, a mention of one, a paragraph of capital lines that ends no sentence (a letterhead, a heading), or a roster name.
  */
 export const capsShouting: Detector = (doc, options): Finding[] => {
   const known = lowerCaseWords(doc.prose ?? doc.source);
   const conventional = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
   const captions = captionsOf(doc.source);
-  const letterheads = letterheadSpans(doc.source);
+  const capitalLines = capitalLineSpans(doc.source);
   const isCaptionOrLetterhead = (hit: Hit): boolean =>
     captions.has(hit.matched) ||
     isCaptionAt(doc.source, hit.offset, hit.offset + hit.matched.length) ||
-    isWithinAny(letterheads, { start: hit.offset, end: hit.offset + hit.matched.length });
+    isWithinSorted(capitalLines, { start: hit.offset, end: hit.offset + hit.matched.length });
   const hits = hitsOf(ownSentences(doc), CAPS_RUN).filter((hit) => isShouting(hit.matched, known, conventional) && !isCaptionOrLetterhead(hit));
   return reportFrom(hits, options.limit);
 };