chaffjs 0.13.0 → 0.15.0

package/src/detectors/gram-predicate.ts

@@ -0,0 +1,55 @@
+import { isNamePart } from "./name-part.ts";
+import type { LengthUnit, Span, Token } from "../plugin.ts";
+
+/** 動詞と助動詞。言い回し（ることができます、it is important to）にはこれが入り、主題の名前（state and local tax）には入らない。 */
+const PREDICATE_POS = new Set(["VERB", "AUX"]);
+
+const NOUNS = new Set(["NOUN", "PROPN", "ADJ"]);
+
+/** 中身を持たない語。名前の前後に付いても、名前の繰り返しを言い回しに変えない。 */
+const FUNCTION_POS = new Set(["ADP", "DET", "CCONJ", "SCONJ", "PART", "PUNCT", "SYM", "X"]);
+
+/**
+ * 英語で名詞のすぐ前の動詞は、名詞を飾る語（形容詞を挟んでも同じ）（the upcoming fiscal year、the Disclosing Party、the borrow checker）で、
+ * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、word 単位だけで見る。
+ */
+const modifiesNoun = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean =>
+  unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "");
+
+/** 英語で大文字の名前の一部になった動詞（Procedures Guide、the Location Object）も、述語ではない。 */
+const namePartAt = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean => unit === "word" && isNamePart(tokens, index);
+
+const isName = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean => {
+  const token = tokens[index];
+  return token !== undefined && (token.pos === "PROPN" || token.features?.["NameType"] !== undefined || namePartAt(tokens, index, unit));
+};
+
+const overlaps = (token: Token, window: Span): boolean => token.span.start < window.end && window.start < token.span.end;
+
+const isCut = (token: Token, window: Span): boolean => token.span.start < window.start || window.end < token.span.end;
+
+/**
+ * 窓が名前だけを繰り返しているか。predicate（添字）のほかに窓が触れる語が、名前と中身の無い語だけで、名前が 1 つはある。
+ * 窓の端で切れた動詞（"ed in the NSF Propos" の identified、"ed by Applicable Law" の prohibited）は語尾しか入っておらず、
+ * 動詞は出てくるたびに違ってよい。繰り返されているのは名前のほう。
+ */
+const onlyNamesBeside = (tokens: readonly Token[], predicate: number, window: Span, unit: LengthUnit): boolean => {
+  const touched = tokens.flatMap((token, index) => (index !== predicate && overlaps(token, window) ? [index] : []));
+  const names = touched.filter((index) => isName(tokens, index, unit));
+  const rest = touched.filter((index) => !isName(tokens, index, unit));
+  return names.length > 0 && rest.every((index) => FUNCTION_POS.has(tokens[index]?.pos ?? ""));
+};
+
+const countsAsPredicate = (tokens: readonly Token[], index: number, window: Span, unit: LengthUnit): boolean => {
+  const token = tokens[index];
+  if (token === undefined || !PREDICATE_POS.has(token.pos) || !overlaps(token, window)) return false;
+  if (modifiesNoun(tokens, index, unit) || namePartAt(tokens, index, unit)) return false;
+  return !isCut(token, window) || !onlyNamesBeside(tokens, index, window, unit);
+};
+
+/**
+ * 語句が文の中で占める範囲（window、文書の中の位置）に、述語になる動詞か助動詞があるか。
+ * 範囲で見る。文字で探すと、同じ文の別の所の動詞「use」が、語句の中の名詞「use」に当たる。
+ */
+export const hasPredicateIn = (tokens: readonly Token[], window: Span, unit: LengthUnit): boolean =>
+  tokens.some((_, index) => countsAsPredicate(tokens, index, window, unit));

package/src/detectors/heading-case.ts

@@ -0,0 +1,41 @@
+const WORD = /[A-Za-z][A-Za-z'-]*/gu;
+
+/** 小さい語は Title Case でも小文字のままなので、大文字化の判定から外す。 */
+const MINOR = new Set(["a", "an", "the", "and", "or", "but", "of", "in", "on", "at", "to", "for", "with", "as", "by", "from", "is"]);
+
+const TITLE_DEPTH = 1;
+
+/** 見出しが Title Case か。判定できなければ undefined。 */
+export const isTitleCase = (heading: string): boolean | undefined => {
+  const words = [...heading.matchAll(WORD)].map((match) => match[0]).filter((word) => !MINOR.has(word.toLowerCase()));
+  // 1 語の見出しは、どちらの流儀でも先頭が大文字になる。判定できない。
+  if (words.length < 2) return undefined;
+  const capitalized = words.filter((word) => word[0] === word[0]?.toUpperCase()).length;
+  return capitalized === words.length;
+};
+
+/**
+ * 文書の題名。最初の見出しが深さ 1 で、深さ 1 の見出しがほかに無いときの、その見出し。
+ * 深さ 1 が複数あると、最初のものが題名なのか章なのかを構造からは決められないので、題名とは呼ばない。
+ * 見出しより前の導入部（深さ 0）は見出しではないので数えない。
+ */
+export const pageTitleOf = <T extends { readonly depth: number }>(sections: readonly T[]): T | undefined => {
+  const headed = sections.filter((section) => section.depth > 0);
+  const first = headed[0];
+  if (first?.depth !== TITLE_DEPTH) return undefined;
+  return headed.filter((section) => section.depth === TITLE_DEPTH).length === 1 ? first : undefined;
+};
+
+export type CaseCounts = { readonly titleCase: number; readonly sentenceCase: number };
+
+/**
+ * 節の見出しのうち少数派の流儀（true なら Title Case）。少数派が無ければ undefined。
+ * 題名は数に入れない。題名は名前なので、節と流儀を分けるのはよくある揃えかた。
+ * 同数のときだけ題名の流儀で決める。題名と同じ流儀のほうが、書き手の選んだ流儀である見込みが高い。
+ */
+export const minorityCase = (sections: CaseCounts, pageTitleCase: boolean | undefined): boolean | undefined => {
+  if (sections.titleCase === sections.sentenceCase) return sections.titleCase === 0 || pageTitleCase === undefined ? undefined : !pageTitleCase;
+  const minorityIsTitle = sections.titleCase < sections.sentenceCase;
+  const few = minorityIsTitle ? sections.titleCase : sections.sentenceCase;
+  return few === 0 ? undefined : minorityIsTitle;
+};

package/src/detectors/heading-echo.ts

@@ -1,5 +1,6 @@
 import { lengthOf } from "../measure.ts";
 import { handsOver } from "./lead-in.ts";
+import { withoutQuotedVariants } from "./quoted-variant.ts";
 import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../plugin.ts";
 
 /** 見出しが短すぎると、偶然の一致で 100% になる。これ未満の見出しは見ない。 */
@@ -58,12 +59,15 @@ const leadsIn = (doc: ProseDocument, section: Section, phrases: readonly string[
   return first !== undefined && handsOver(first.text, doc.source.slice(first.span.end, section.span.end), phrases);
 };
 
+/** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
+const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", section.heading);
+
 export const headingEcho: Detector = (doc, options): Finding[] => {
   const leadIns = (doc.lexicons["lead-in"] ?? []).map((entry) => entry.pattern);
   return doc.sections
     .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined && addsLittle(section, doc.lengthUnit))
     .filter((section) => !leadsIn(doc, section, leadIns))
-    .map((section) => ({ section, overlap: Math.round(containment(trigrams(section.heading), trigrams(section.firstSentence?.text ?? "")) * 100) }))
+    .map((section) => ({ section, overlap: Math.round(containment(trigrams(section.heading), trigrams(echoedText(section))) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)
     .map(({ section, overlap }) => ({
       rule: "heading-echo",

package/src/detectors/lexicon.ts

@@ -3,6 +3,7 @@ import { wordsOf } from "./structure.ts";
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
 import { entryIn, entryOpens, entryRanges } from "./lexicon-match.ts";
 import { scoped, scopeMarkersOf, type ScopeMarkers } from "./superlative-scope.ts";
+import { namesQuantity } from "./superlative-name.ts";
 
 const PER = 1000;
 
@@ -42,21 +43,23 @@ export const cushionDensity = densityRule("cushion-phrase-density");
 /** 数字は語ではないので言語を問わない。数があれば測った結果を言っている。品詞の数（NUM）は "the best one" の one まで含むので使わない。 */
 const DIGIT = /\d/u;
 
-type Qualifiers = { readonly comparison: Lexicon; readonly scope: ScopeMarkers };
+type Qualifiers = { readonly comparison: Lexicon; readonly scope: ScopeMarkers; readonly quantityNouns: Lexicon };
 
 const qualifiersOf = (doc: ProseDocument): Qualifiers => ({
   comparison: doc.lexicons["comparison-marker"] ?? [],
   scope: scopeMarkersOf(doc.lexicons["superlative-scope"] ?? []),
+  quantityNouns: doc.lexicons["quantity-noun"] ?? [],
 });
 
-/** どの出現も範囲を持つときだけ。1 つでも範囲の無い出現があれば、その文には限定の無い最上級がある。 */
-const everyScoped = (sentence: Sentence, entry: LexiconEntry, scope: ScopeMarkers): boolean => {
+/** どの出現も範囲を持つか量の名前のときだけ。1 つでもそうでない出現があれば、その文には限定の無い最上級がある。 */
+const everyQualified = (sentence: Sentence, entry: LexiconEntry, qualifiers: Qualifiers): boolean => {
+  const tokens = sentence.tokens ?? [];
   const ranges = entryRanges(sentence, entry);
-  return ranges.length > 0 && ranges.every((range) => scoped(sentence.tokens ?? [], range, scope));
+  return ranges.length > 0 && ranges.every((range) => scoped(tokens, range, qualifiers.scope) || namesQuantity(tokens, range, qualifiers.quantityNouns));
 };
 
 const qualified = (sentence: Sentence, entry: LexiconEntry, qualifiers: Qualifiers): boolean =>
-  DIGIT.test(sentence.text) || qualifiers.comparison.some((marker) => entryIn(sentence, marker)) || everyScoped(sentence, entry, qualifiers.scope);
+  DIGIT.test(sentence.text) || qualifiers.comparison.some((marker) => entryIn(sentence, marker)) || everyQualified(sentence, entry, qualifiers);
 
 const bareHits = (doc: ProseDocument, lexicon: Lexicon): Hit[] => {
   const qualifiers = qualifiersOf(doc);

package/src/detectors/middle-dot.ts

@@ -0,0 +1,10 @@
+const MIDDLE_DOT = /・/gu;
+
+/** 文頭か行頭（前に空白だけ）の「・」。前に並べる項目が無いので、箇条書きの印。 */
+const BULLET_DOT = /(^|\n)[^\S\n]*・/gu;
+
+/**
+ * 項目を並べる中黒の数。箇条書きの印の「・」は数えない。
+ * 「・ 水分を補給すること」が何行続いても、どこまでが 1 つの項目かは改行で読める。
+ */
+export const parallelDotCount = (text: string): number => [...text.replace(BULLET_DOT, "$1").matchAll(MIDDLE_DOT)].length;

package/src/detectors/name-numeral.ts

@@ -0,0 +1,37 @@
+/**
+ * 大文字で始まる語のすぐ後ろの、I・V・X だけで書いたローマ数字（Engineer II、Leopold III、World War II）。名前に付く
+ * 番号で、略語ではない。語の前に文字が無ければ（文の頭、箇条書きの番号の後ろ）、大文字は名前の印ではなく文頭の書き方なので
+ * 外さない（Start IV fluids、1. Give IV fluids）。
+ * CD、MD、DC、CI、MIX のように C・D・L・M を含む数字は略語であることが多いので、この位置でも略語のまま数える。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+const SMALL_NUMERAL = "(?=[IVX])X{0,3}(?:IX|IV|V?I{0,3})";
+const NAMED_NUMERAL = new RegExp(String.raw`(?<![\p{L}\p{N}_])\p{Lu}\p{Ll}+\s+(?<numeral>${SMALL_NUMERAL})(?![\p{L}\p{N}_&])`, "gu");
+const LETTER = /\p{L}/u;
+
+/** 文の中の、名前の後ろの番号の範囲（数字だけ）。 */
+export const nameNumeralSpans = (text: string): Span[] =>
+  [...text.matchAll(NAMED_NUMERAL)]
+    .filter((match) => LETTER.test(text.slice(0, match.index)))
+    .map((match) => {
+      const numeral = match.groups?.["numeral"] ?? "";
+      const end = match.index + match[0].length;
+      return { start: end - numeral.length, end };
+    });
+
+/**
+ * 文の頭か文の終わりの . の後ろに、. を付けて 1 語で立つ数字（Survey of Cool Stars. VII. The Inner Disk、II. Background）。
+ * 続き物や区切りの番号で、略語ではない。日本語の文分けは英文の . で切らないので、文の中の . の後ろも見る。
+ * C・D・L・M を含む数字（CD.）は略語でもあるので外さない。
+ */
+// 前置きは後ろ読みにしない。長さの決まらない後ろ読みは、長い空白の上で位置ごとに遡って二乗の時間がかかる。
+const LONE_NUMERAL = new RegExp(String.raw`(?<lead>^\s*|[.。]\s+)(?<numeral>${SMALL_NUMERAL})(?=\.(?:\s|$))`, "gu");
+
+/** 文の中の、1 語で立つ番号の範囲（数字だけ）。 */
+export const loneNumeralSpans = (text: string): Span[] =>
+  [...text.matchAll(LONE_NUMERAL)].map((match) => {
+    const start = match.index + (match.groups?.["lead"] ?? "").length;
+    return { start, end: start + (match.groups?.["numeral"] ?? "").length };
+  });

package/src/detectors/name-part.ts

@@ -0,0 +1,24 @@
+import type { Token } from "../plugin.ts";
+
+const LETTER = /\p{L}/u;
+const CAPITAL_HEAD = /^\p{Lu}/u;
+
+/** 文字を含む語の添字。&、括弧、句読点は名前の並びを切らない（Learning & Development、Guide (PAPPG)）。 */
+const wordIndexes = (tokens: readonly Token[]): number[] => tokens.flatMap((token, index) => (LETTER.test(token.surface) ? [index] : []));
+
+/** 文の最初の語より後ろで、大文字で始まる語。文頭の大文字は位置のしるしで、名前のしるしではない。 */
+const isCapitalisedAt = (tokens: readonly Token[], words: readonly number[], at: number): boolean => {
+  const index = words[at];
+  return at > 0 && index !== undefined && CAPITAL_HEAD.test(tokens[index]?.surface ?? "");
+};
+
+/**
+ * 語（添字）が、大文字で書いた名前の一部か。文の途中で大文字で始まり、隣の語も文の途中の大文字（Procedures Guide、
+ * the Location Object、Learning & Development）。解析器はこういう語を動詞と読むことがあるが、述語ではない。
+ * 文頭の語は隣に数えない。Select Save (if applicable) の Save は述語のまま。
+ */
+export const isNamePart = (tokens: readonly Token[], index: number): boolean => {
+  const words = wordIndexes(tokens);
+  const at = words.indexOf(index);
+  return isCapitalisedAt(tokens, words, at) && (isCapitalisedAt(tokens, words, at - 1) || isCapitalisedAt(tokens, words, at + 1));
+};

package/src/detectors/name-run.ts

@@ -0,0 +1,16 @@
+import type { Token } from "../plugin.ts";
+
+const nameType = (token: Token | undefined): string | undefined => token?.features?.["NameType"];
+
+/** 人の姓と名（田中太郎）。姓が 2 つ続けば（田中山田）、名前の並び。 */
+const isFullName = (named: readonly (Token | undefined)[]): boolean => named.length === 2 && nameType(named[0]) === "Sur" && nameType(named[1]) === "Giv";
+
+/**
+ * 漢字の連なりの語（covering: tokens の添字）が 1 つの名前か。辞書が固有名詞と読む 1 語（日本銀行）か、人の姓と名。
+ * 名前は書き手が変えられない。固有名詞に普通の語が続けば（武蔵野美術大学造形構想学部、東京都知事選挙管理委員会事務局）、
+ * 名前から組み立てた語で、どこで切れるかは読み手に見えない。名前が続けば（日本銀行日本電信電話）、並び。どちらも名前とは言わない。
+ */
+export const isOneName = (tokens: readonly Token[], covering: readonly number[]): boolean => {
+  const named = covering.map((index) => tokens[index]);
+  return (named.length === 1 && named[0]?.pos === "PROPN") || isFullName(named);
+};

package/src/detectors/orthography.ts

@@ -1,6 +1,7 @@
-import type { Detector, Finding, Sentence } from "../plugin.ts";
+import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
 import { latinBoundaries, minorityStyle, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
-import { digitRunAround, isNumberName } from "../number-name.ts";
+import { isWithinAny, quotedSpans } from "../quoted-span.ts";
+import { digitRunAround, isNumberName, sequenceLabelStarts } from "../number-name.ts";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
@@ -31,22 +32,32 @@ const digitBeside = (boundary: Boundary): number => {
 };
 
 /** 番号・識別子として書かれた数の境目は、空け方の好みではないので数えない（number-name.ts）。 */
-const isCounted = (sentence: Sentence, boundary: Boundary): boolean => {
+const isCounted = (sentence: Sentence, boundary: Boundary, sequence: ReadonlySet<number>, topUnits: ReadonlySet<string>): boolean => {
   if (boundary.kind === "letter") return true;
   const run = digitRunAround(sentence.text, digitBeside(boundary));
-  return run === undefined || !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start);
+  return run === undefined || !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, sequence, topUnits);
 };
 
+/**
+ * 鉤括弧で引いた題名や発言（「…ガイドライン ver. 1.1」）の中の境目。空け方は引いた元のもので、書き手の書き方ではない。
+ * 括弧は日本語の字でも英数字でもないので、境目はまるごと括弧の中か外にある。
+ */
+const isQuoted = (quoted: readonly Span[], boundary: Boundary): boolean => isWithinAny(quoted, { start: boundary.offset, end: boundary.offset });
+
 /**
  * 日本語と英字・数字のあいだを、空けるか詰めるか。文書の中で混ざっていたら、少ないほうを指摘する。
  * どちらが正しいかは決めない。決めるのはチームで、chaff はそろっているかだけを見る。
  */
 export const latinSpacing: Detector = (doc, options): Finding[] => {
-  const located: Located[] = doc.sentences.flatMap((sentence) =>
-    latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
-      .filter((boundary) => isCounted(sentence, boundary))
-      .map((boundary) => ({ sentence, ...boundary })),
-  );
+  // 覆った文（prose）で探す。コードの中の「1 件」は並びに入れない。
+  const sequence = sequenceLabelStarts(doc.prose ?? doc.source);
+  const topUnits = new Set((doc.lexicons["prefecture-unit"] ?? []).map((entry) => entry.pattern));
+  const located: Located[] = doc.sentences.flatMap((sentence) => {
+    const quoted = quotedSpans(sentence.text);
+    return latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
+      .filter((boundary) => !isQuoted(quoted, boundary) && isCounted(sentence, boundary, sequence, topUnits))
+      .map((boundary) => ({ sentence, ...boundary }));
+  });
   return KINDS.flatMap((kind) => {
     const ofKind = located.filter((entry) => entry.kind === kind);
     const minority = minorityStyle(ofKind);

package/src/detectors/placeholder.ts

@@ -0,0 +1,38 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 日付や時刻の数字の代わりに置く、同じ大文字の繰り返し（令和YY年MM月DD日 HH：MM、MM/DD/YYYY、YYYY-MM-DD）。
+ * 定型文の書式で、略語ではない。繰り返しの語が、日付・時刻の単位の語（年、月、日）の前にあるか、
+ * 区切り（/、:、-、.）で別の繰り返しの語か数字と繋がっているときだけ認める。単位の語は言語パッケージの語彙表から読む。
+ * AI時代の AI や CI/CD の CD は、同じ文字の繰り返しではないので略語のまま数える。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+const REPEATED = /^(?<letter>[A-Z])\k<letter>+$/u;
+const PART = String.raw`(?:[A-Z]{2,}|\d+)`;
+const SEPARATOR = "[/／:：.-]";
+const JOINED = new RegExp(String.raw`(?<![A-Za-z0-9_&])${PART}(?:${SEPARATOR}${PART})+(?![A-Za-z0-9_&])`, "gu");
+const CAPITALS = /[A-Z]+/gu;
+
+const isRepeated = (word: string): boolean => REPEATED.test(word);
+
+const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: match.index + match[0].length });
+
+/** 区切りで繋いだ一続きのうち、大文字の部品がどれも同じ文字の繰り返しのもの（数字だけの 2025/01/31 は略語と関係がない）。 */
+const joinedSpans = (text: string): Span[] =>
+  [...text.matchAll(JOINED)]
+    .filter((match) => {
+      const capitals = match[0].match(CAPITALS) ?? [];
+      return capitals.length > 0 && capitals.every(isRepeated);
+    })
+    .map(spanOf);
+
+const beforeUnitSpans = (text: string, units: readonly string[]): Span[] => {
+  if (units.length === 0) return [];
+  const pattern = new RegExp(String.raw`(?<![A-Za-z0-9_&])[A-Z]{2,}(?=${units.map(escapeRegExp).join("|")})`, "gu");
+  return [...text.matchAll(pattern)].filter((match) => isRepeated(match[0])).map(spanOf);
+};
+
+/** 文の中の、日付・時刻の書式に置いた大文字の範囲。units は日付・時刻の単位の語。 */
+export const placeholderSpans = (text: string, units: readonly string[]): Span[] => [...joinedSpans(text), ...beforeUnitSpans(text, units)];

package/src/detectors/polite-word.ts

@@ -0,0 +1,14 @@
+import type { LexiconEntry, Token } from "../plugin.ts";
+
+/** 語彙表の語が解析器で一語になったときの、その語。二語以上（「ございます」）は読みで照らさない。 */
+const singleWord = (entry: LexiconEntry): Token | undefined => (entry.tokens?.length === 1 ? entry.tokens[0] : undefined);
+
+/**
+ * 読みと品詞が同じなら、表記が違っても同じ語の同じ形。解析器は「下さい」の原形を「下さる」、「ください」の原形を「くださる」と
+ * 別の字で返すが、読み（クダサイ）と品詞は同じ。品詞も比べるのは、読みだけだと「升（マス）」が「ます」に当たるから。
+ */
+const sameReading = (token: Token, word: Token | undefined): boolean => word?.reading !== undefined && token.reading === word.reading && token.pos === word.pos;
+
+/** 語が丁寧語の語彙表の語か。書いた形か原形が語彙表の語と同じか、語彙表の一語と読みと品詞が同じ。 */
+export const isPoliteWord = (token: Token, entries: readonly LexiconEntry[]): boolean =>
+  entries.some((entry) => token.surface === entry.pattern || token.lemma === entry.pattern || sameReading(token, singleWord(entry)));

package/src/detectors/quoted-variant.ts

@@ -0,0 +1,20 @@
+// 引用符の中身。英語の ’ と ' はアポストロフィ（organisation’s, don't）にも使われるので、字のあとに続くものは閉じとみなさない。
+const QUOTATIONS: readonly RegExp[] = [
+  /“([^“”\n]*)”/gu,
+  /‘((?:[^‘’\n]|’(?=\p{L}))*)’(?!\p{L})/gu,
+  /"([^"\n]*)"/gu,
+  /(?<![\p{L}\p{N}])'((?:[^'\n]|'(?=\p{L}))*)'(?![\p{L}\p{N}])/gu,
+  /「([^「」\n]*)」/gu,
+  /『([^『』\n]*)』/gu,
+];
+
+// 大文字小文字は畳まない。表記の手引きは大文字小文字だけ違う形も引用して退ける（Not “Open Source software”）。
+const sameText = (left: string, right: string): boolean => left.trim() === right.trim();
+
+/**
+ * 文から、見出しとは違う形を引用した部分を抜いた文字列。
+ * 「Not “datacentre”.」の “datacentre” は語の書き方として挙げたもの（言及）で、見出し「data centre」を繰り返してはいない。
+ * 見出しそのままの引用（「利用規約への同意」について説明します）は見出しを指しているので残す。
+ */
+export const withoutQuotedVariants = (sentence: string, heading: string): string =>
+  QUOTATIONS.reduce((text, quotation) => text.replace(quotation, (whole: string, inner: string) => (sameText(inner, heading) ? whole : " ")), sentence);

package/src/detectors/register.ts

@@ -1,4 +1,5 @@
-import type { Sentence, Span, Token } from "../plugin.ts";
+import { isPoliteWord } from "./polite-word.ts";
+import type { LexiconEntry, Sentence, Span, Token } from "../plugin.ts";
 
 export type Register = "polite" | "plain";
 
@@ -25,13 +26,12 @@ const withPreceding = (ending: readonly Token[], preceding: readonly Token[]): r
  * 文末の語の調子。preceding は文末の語より前の語。
  * 文末に述語（動詞・形容詞・助動詞）が無ければ、ですます調でもである調でもないので undefined。
  * 「以下の通り。」「円錐形の麦わら帽子。」のような名詞で終わる文を数えると、そのままである調の少数派になっていた。
- * 書いた形でも原形でも当てる。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
+ * 書いた形でも原形でも読みでも当てる（polite-word.ts）。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
  */
-export const registerOf = (ending: readonly Token[], preceding: readonly Token[], polite: readonly string[]): Register | undefined => {
+export const registerOf = (ending: readonly Token[], preceding: readonly Token[], polite: readonly LexiconEntry[]): Register | undefined => {
   const judged = withPreceding(ending, preceding);
   if (!judged.some(isPredicate)) return undefined;
-  const isPolite = judged.some((token) => polite.includes(token.surface) || (token.lemma !== undefined && polite.includes(token.lemma)));
-  return isPolite ? "polite" : "plain";
+  return judged.some((token) => isPoliteWord(token, polite)) ? "polite" : "plain";
 };
 
 const EXCLAIMED = /[！？!?]$/u;
@@ -49,7 +49,11 @@ export const outermostList = (offset: number, lists: readonly Span[]): number |
     .filter((list) => offset >= list.start && offset < list.end)
     .reduce<number | undefined>((outer, list) => (outer === undefined || list.start < outer ? list.start : outer), undefined);
 
-/** group: 文が入っている箇条書き（outermostList の値）。本文なら undefined。 */
+/** 文が入っているまとまりの始まり。一番外側の箇条書き、それが無ければ番号で始まる段落の並び（runs）。本文なら undefined。 */
+export const groupOf = (offset: number, lists: readonly Span[], runs: readonly Span[]): number | undefined =>
+  outermostList(offset, lists) ?? outermostList(offset, runs);
+
+/** group: 文が入っているまとまり（groupOf の値）。本文なら undefined。 */
 export type Judged = { readonly register: Register; readonly group: number | undefined };
 
 /** 混ざった文と、その文が属する本文または箇条書きの中の少数派の数。 */
@@ -74,7 +78,7 @@ const slipsInGroup = <T extends Judged>(judged: readonly T[], group: number | un
 };
 
 /**
- * 調子が混ざった文を、judged の順で。本文は本文どうし、箇条書きは 1 つずつ、その中で揃っているかを見る。
+ * 調子が混ざった文を、judged の順で。本文は本文どうし、箇条書きと番号で始まる段落の並びは 1 つずつ、その中で揃っているかを見る。
  * ですます調の本文に常体の箇条書きを置くのはよくある書き方で、箇条書きが丸ごと揃っていれば混在ではない。
  */
 export const slipsOf = <T extends Judged>(judged: readonly T[], limit: number): Slip<T>[] => {

package/src/detectors/roman-numeral.ts

@@ -0,0 +1,5 @@
+/**
+ * 崩れのない書き方のローマ数字（I〜MMMM）。IIII や VX は数として書かれないので、略語の側に残す。
+ * 各桁が省けるので空文字にも当たる。1 文字目があることを先読みで求める。
+ */
+export const ROMAN_NUMERAL = "(?=[MDCLXVI])M{0,4}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})";

package/src/detectors/sentence-ending.ts

@@ -1,6 +1,7 @@
 import { endingTokens, isClosed } from "../sentence-shape.ts";
-import { continuesInto, outermostList, registerOf, slipsOf, type Register } from "./register.ts";
-import type { Detector, Finding, Sentence } from "../plugin.ts";
+import { enumeratedRuns, enumeratorStarts, numberedStarts } from "./enumerated-runs.ts";
+import { continuesInto, groupOf, registerOf, slipsOf, type Register } from "./register.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } from "../plugin.ts";
 
 /**
  * 文末の調子が混ざっているかを見る。日本語の「ですます / である」がこれ。
@@ -11,21 +12,37 @@ import type { Detector, Finding, Sentence } from "../plugin.ts";
  */
 type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
-const registerOfSentence = (sentence: Sentence, polite: readonly string[]): Register | undefined => {
+const registerOfSentence = (sentence: Sentence, polite: readonly LexiconEntry[]): Register | undefined => {
   const ending = endingTokens(sentence);
   const tokens = sentence.tokens ?? [];
   const head = ending[0] === undefined ? -1 : tokens.indexOf(ending[0]);
   return registerOf(ending, head > 0 ? tokens.slice(0, head) : [], polite);
 };
 
+/** 番号で始まる段落の並び。木を組むのは高いので、調子が一つだけの文書（混ざりようがない）では組まない。 */
+const runsOf = (doc: ProseDocument, registers: readonly Register[]): Span[] => {
+  const tree = new Set(registers).size > 1 ? doc.structure : undefined;
+  if (tree === undefined) return [];
+  return enumeratedRuns(
+    doc.paragraphs.map((paragraph) => paragraph.span),
+    enumeratorStarts(numberedStarts(tree), doc.sentences, doc.source),
+    doc.source,
+  );
+};
+
 export const sentenceEnding: Detector = (doc, options): Finding[] => {
-  const polite = (options.lexicon ?? []).map((entry) => entry.pattern);
+  const polite = options.lexicon ?? [];
   const lists = doc.lists.map((list) => list.span);
-  const judged = doc.sentences.flatMap((sentence, index): Entry[] => {
+  const found = doc.sentences.flatMap((sentence, index): { sentence: Sentence; register: Register }[] => {
     if (!isClosed(sentence) || continuesInto(sentence, doc.sentences[index + 1])) return [];
     const register = registerOfSentence(sentence, polite);
-    return register === undefined ? [] : [{ sentence, register, group: outermostList(sentence.span.start, lists) }];
+    return register === undefined ? [] : [{ sentence, register }];
   });
+  const runs = runsOf(
+    doc,
+    found.map((entry) => entry.register),
+  );
+  const judged = found.map((entry): Entry => ({ ...entry, group: groupOf(entry.sentence.span.start, lists, runs) }));
   return slipsOf(judged, options.limit).map(({ entry: { sentence }, count }) => ({
     rule: "no-mixed-desumasu",
     severity: "warning",

package/src/detectors/series-label.ts

@@ -0,0 +1,33 @@
+/**
+ * - で区切った文書番号のすぐ前の大文字の語（NIST SP 800-61 の SP、NSF 19-582、IEC 19757-2）。番号の一部で、略語ではない。
+ * 空白で離して書くほかは、- で繋いだ識別子（AC-2）と同じ。番号の直前の 1 語だけで、その前の語（NIST）は略語のまま数える。
+ * 区切りの無い番号（RFC 9110）、. で区切る版（SDK 3.1）、年の範囲（FY 2024-25）の前の語も略語のまま数える。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+const YEAR_RANGE = String.raw`(?:19|20)\d\d-\d`;
+const SERIES_LABEL = new RegExp(String.raw`(?<![A-Za-z0-9_&.-])[A-Z]+ (?!${YEAR_RANGE})(?<number>\d+(?:-\d+)+)[A-Za-z0-9]*(?![A-Za-z0-9_&-])`, "gu");
+
+/**
+ * 文書番号は長い通し番号を持つ（800-61、19757-2）。2 桁ずつの番号（BOD 25-01）は範囲・得点・日付（SRE 1-2、NFL 3-1、
+ * 01-02）と見分けられないので、その前の語は略語のまま数える。同じ桁数で小さいほうから書いた 2 つの数（SLO 100-200、
+ * SLA 500-599）は範囲。
+ */
+const SERIAL_DIGITS = 3;
+
+const isRange = (groups: readonly string[]): boolean => {
+  const [low, high, ...rest] = groups;
+  return rest.length === 0 && low !== undefined && high !== undefined && low.length === high.length && Number(low) < Number(high);
+};
+
+const isDocumentNumber = (number: string): boolean => {
+  const groups = number.split("-");
+  return groups.some((group) => group.length >= SERIAL_DIGITS) && !isRange(groups);
+};
+
+/** 文の中の、番号と、その前の大文字の語の範囲。 */
+export const seriesLabelSpans = (text: string): Span[] =>
+  [...text.matchAll(SERIES_LABEL)]
+    .filter((match) => isDocumentNumber(match.groups?.["number"] ?? ""))
+    .map((match) => ({ start: match.index, end: match.index + match[0].length }));