chaffjs 0.11.0 → 0.13.0

package/src/detectors/lexicon.ts

@@ -1,7 +1,8 @@
 import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
-import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
-import { entryIn, entryOpens } from "./lexicon-match.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";
 
 const PER = 1000;
 
@@ -38,14 +39,39 @@ const densityRule =
 export const hedgingDensity = densityRule("excessive-hedging");
 export const cushionDensity = densityRule("cushion-phrase-density");
 
+/** 数字は語ではないので言語を問わない。数があれば測った結果を言っている。品詞の数（NUM）は "the best one" の one まで含むので使わない。 */
+const DIGIT = /\d/u;
+
+type Qualifiers = { readonly comparison: Lexicon; readonly scope: ScopeMarkers };
+
+const qualifiersOf = (doc: ProseDocument): Qualifiers => ({
+  comparison: doc.lexicons["comparison-marker"] ?? [],
+  scope: scopeMarkersOf(doc.lexicons["superlative-scope"] ?? []),
+});
+
+/** どの出現も範囲を持つときだけ。1 つでも範囲の無い出現があれば、その文には限定の無い最上級がある。 */
+const everyScoped = (sentence: Sentence, entry: LexiconEntry, scope: ScopeMarkers): boolean => {
+  const ranges = entryRanges(sentence, entry);
+  return ranges.length > 0 && ranges.every((range) => scoped(sentence.tokens ?? [], range, scope));
+};
+
+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);
+
+const bareHits = (doc: ProseDocument, lexicon: Lexicon): Hit[] => {
+  const qualifiers = qualifiersOf(doc);
+  return doc.sentences.flatMap((sentence) =>
+    lexicon.filter((entry) => entryIn(sentence, entry) && !qualified(sentence, entry, qualifiers)).map((entry) => ({ sentence, matched: entry.pattern })),
+  );
+};
+
 /**
  * 限定のない最上級。「最も速い」だけでは、何と比べて最もなのかが無い。
- * 同じ文に比較対象や条件があれば、それは主張であって誇張ではない。
+ * 同じ文に比較対象・条件・範囲（日本で最も、the best in the world）があれば、それは主張であって誇張ではない。
+ * 比較と範囲を言う語は言語パッケージの語彙表が持つ。
  */
-const QUALIFIER = /\d|より|に比べ|のうち|among|than|compared|based on|according/iu;
-
 export const unqualifiedSuperlative: Detector = (doc, options): Finding[] => {
-  const bare = hitsFor(doc, options.lexicon ?? []).filter((hit) => !QUALIFIER.test(hit.sentence.text));
+  const bare = bareHits(doc, options.lexicon ?? []);
   if (bare.length < options.limit) return [];
   return bare.map((hit) => ({
     rule: "unqualified-superlative",

package/src/detectors/orthography.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, Sentence } from "../plugin.ts";
-import { latinBoundaries, minorityStyle, occurrencesOutside, type SpacingKind } from "../orthography.ts";
+import { latinBoundaries, minorityStyle, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
+import { digitRunAround, isNumberName } from "../number-name.ts";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
@@ -23,12 +24,29 @@ const KINDS: readonly SpacingKind[] = ["letter", "before-digit", "after-digit"];
 
 type Located = { readonly sentence: Sentence; readonly offset: number; readonly kind: SpacingKind; readonly spaced: boolean };
 
+/** 境目の隣の数字の、並びの中の 1 字の位置。数字の後ろなら左の字、数字の前なら（空白を越えた）右の字。 */
+const digitBeside = (boundary: Boundary): number => {
+  if (boundary.kind === "after-digit") return boundary.offset - 1;
+  return boundary.spaced ? boundary.offset + 1 : boundary.offset;
+};
+
+/** 番号・識別子として書かれた数の境目は、空け方の好みではないので数えない（number-name.ts）。 */
+const isCounted = (sentence: Sentence, boundary: Boundary): 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);
+};
+
 /**
  * 日本語と英字・数字のあいだを、空けるか詰めるか。文書の中で混ざっていたら、少ないほうを指摘する。
  * どちらが正しいかは決めない。決めるのはチームで、chaff はそろっているかだけを見る。
  */
 export const latinSpacing: Detector = (doc, options): Finding[] => {
-  const located: Located[] = doc.sentences.flatMap((sentence) => latinBoundaries(sentence.text).map((boundary) => ({ sentence, ...boundary })));
+  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 })),
+  );
   return KINDS.flatMap((kind) => {
     const ofKind = located.filter((entry) => entry.kind === kind);
     const minority = minorityStyle(ofKind);

package/src/detectors/place-run.ts

@@ -0,0 +1,63 @@
+import type { Token } from "../plugin.ts";
+
+/** 地名（Geo）と、地名に付く単位（GeoUnit: 都・県・郡・市・区・町・村）。 */
+const isGeoName = (token: Token | undefined): boolean => token?.features?.["NameType"] === "Geo";
+const isGeoUnit = (token: Token | undefined): boolean => token?.features?.["NameType"] === "GeoUnit";
+const isGeo = (token: Token | undefined): boolean => isGeoName(token) || isGeoUnit(token);
+const isNumber = (token: Token | undefined): boolean => token?.features?.["NumType"] === "Card";
+
+/**
+ * 辞書に無い町名は、形態素解析が固有名詞か 1 字ずつに割る（紀美野町は 紀＋美野、南伊勢町は 南＋伊勢、久米島町は固有名詞,一般）。
+ * 2 字以上の普通の語（政策・総務）は地名のかけらにしない。
+ */
+const isNamePiece = (token: Token | undefined): boolean => token !== undefined && (token.pos === "PROPN" || [...token.surface].length === 1);
+
+/** 連なりの語と、閉じても 1 つの地名にならない単位（都道府県。住所の先頭にしか来ない。語彙表 prefecture-unit）。 */
+type Run = { readonly tokens: readonly Token[]; readonly last: number; readonly topUnits: ReadonlySet<string> };
+
+/**
+ * index から地名のかけらだけを読み進めて、連なりの終わりまでに都道府県より下の単位（郡・市・町）で閉じるか。
+ * 閉じれば、そこまでが 1 つの地名。連なりの外（「に」「の」も 1 字）までは読まない。
+ */
+const closedByUnit = (run: Run, index: number): boolean => {
+  const token = run.tokens[index];
+  if (index > run.last || token === undefined) return false;
+  if (isGeoUnit(token)) return !run.topUnits.has(token.surface);
+  return isNamePiece(token) && closedByUnit(run, index + 1);
+};
+
+/**
+ * 住所の語: 地名と地名の単位（NameType=Geo / GeoUnit）、数（NumType=Card）、数のすぐ後ろの助数詞（丁目、NounType=Class）。
+ * 辞書に無い町名（新橋）は、地名の後ろで数の前に来るときだけ住所の一部とする。
+ * 割られた町名（紀美野町）は、単位の後ろで、地名のかけらだけを挟んで次の単位で閉じるときだけ住所の一部とする。
+ */
+const isPlacePart = (run: Run, index: number): boolean => {
+  const tokens = run.tokens;
+  return (
+    isGeo(tokens[index]) ||
+    isNumber(tokens[index]) ||
+    (isNumber(tokens[index - 1]) && tokens[index]?.features?.["NounType"] === "Class") ||
+    (isGeo(tokens[index - 1]) && isNumber(tokens[index + 1])) ||
+    (isGeo(tokens[index - 1]) && isNamePiece(tokens[index]) && closedByUnit(run, index + 1))
+  );
+};
+
+/**
+ * 地名が単位を挟まずに続けば地名の並び（東京大阪名古屋福岡）。ただし 2 つだけで郡・市・町が閉じれば、割られた 1 つの地名
+ * （北海道虻田郡、富士河口湖町）。3 つ続けば、単位が付いても並び（京都奈良大阪神戸市）。
+ * 名古屋大阪市は北海道札幌市と品詞が同じ形なので、ここでは分けられない。
+ */
+const isListed = (run: Run, index: number): boolean =>
+  isGeoName(run.tokens[index]) && isGeoName(run.tokens[index + 1]) && (isGeoName(run.tokens[index + 2]) || !closedByUnit(run, index + 1));
+
+/**
+ * 漢字の連なりの語（covering: tokens の添字）が住所か（東京都港区新橋二丁目）。地名で始まり、住所の語だけでできている。
+ * 住所は決まった形で、ひらがなを挟んで書けない。組織名（日本経済団体連合会）は地名の後ろに普通の語が続くので住所ではない。
+ * topUnits は、住所の先頭にしか来ない単位（都道府県）。言語の語彙表から渡す。
+ */
+export const isAddressRun = (tokens: readonly Token[], covering: readonly number[], topUnits: ReadonlySet<string>): boolean => {
+  const [first, last] = [covering[0], covering.at(-1)];
+  if (first === undefined || last === undefined) return false;
+  const run: Run = { tokens, last, topUnits };
+  return isGeo(tokens[first]) && !covering.some((index) => isListed(run, index)) && covering.every((index) => isPlacePart(run, index));
+};

package/src/detectors/register.ts

@@ -0,0 +1,83 @@
+import type { Sentence, Span, Token } from "../plugin.ts";
+
+export type Register = "polite" | "plain";
+
+const PREDICATE = new Set(["VERB", "ADJ", "AUX"]);
+
+const isPredicate = (token: Token): boolean => PREDICATE.has(token.pos);
+
+const isDependent = (token: Token | undefined): boolean => token?.features?.["NounType"] === "Dependent";
+
+/** preceding の後ろの述語の連なり: 助動詞の連なりと、その前の語一つ。「おかけしましたこと」なら「し・まし・た」。 */
+const chainAtEnd = (preceding: readonly Token[]): readonly Token[] => {
+  const head = preceding.findLastIndex((token) => token.pos !== "AUX");
+  return preceding.slice(Math.max(head, 0));
+};
+
+/**
+ * 非自立名詞で終わる文末は、手前の述語の連なりまで見る。「予約できること。」「おかけしましたこと。」は手前の述語が調子を持つ。
+ * 要件や規程のである調は「〜こと。」で書く。「以下のとおり。」は手前も述語でないので、調子を持たないまま。
+ */
+const withPreceding = (ending: readonly Token[], preceding: readonly Token[]): readonly Token[] =>
+  isDependent(ending[0]) ? [...chainAtEnd(preceding), ...ending] : ending;
+
+/**
+ * 文末の語の調子。preceding は文末の語より前の語。
+ * 文末に述語（動詞・形容詞・助動詞）が無ければ、ですます調でもである調でもないので undefined。
+ * 「以下の通り。」「円錐形の麦わら帽子。」のような名詞で終わる文を数えると、そのままである調の少数派になっていた。
+ * 書いた形でも原形でも当てる。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
+ */
+export const registerOf = (ending: readonly Token[], preceding: readonly Token[], polite: readonly string[]): 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";
+};
+
+const EXCLAIMED = /[！？!?]$/u;
+
+/**
+ * 「！」「？」で切れた文が、間を置かずに助詞で始まる次の文へ続くか。「作っていた！！という人」「導入しませんか？が断られた」は、
+ * 分割器が切っても一つの文で、切れ目の手前は書き手の文末ではない。「。」で切れた文は続きとは見ない。
+ */
+export const continuesInto = (sentence: Sentence, next: Sentence | undefined): boolean =>
+  EXCLAIMED.test(sentence.text) && next !== undefined && next.span.start === sentence.span.end && next.tokens?.[0]?.pos === "ADP";
+
+/** 位置 offset を含む一番外側の箇条書きの始まり。本文なら undefined。入れ子の項目は外側の箇条書きと一緒に見る。 */
+export const outermostList = (offset: number, lists: readonly Span[]): number | undefined =>
+  lists
+    .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。 */
+export type Judged = { readonly register: Register; readonly group: number | undefined };
+
+/** 混ざった文と、その文が属する本文または箇条書きの中の少数派の数。 */
+export type Slip<T extends Judged> = { readonly entry: T; readonly count: number };
+
+const countIn = (judged: readonly Judged[], register: Register): number => judged.filter((entry) => entry.register === register).length;
+
+/** 少ないほう。同数なら文書全体で少ないほう、それも同数なら丁寧体。 */
+const minorityOf = (group: readonly Judged[], whole: readonly Judged[]): Register => {
+  const difference = countIn(group, "polite") - countIn(group, "plain");
+  if (difference !== 0) return difference < 0 ? "polite" : "plain";
+  return countIn(whole, "polite") <= countIn(whole, "plain") ? "polite" : "plain";
+};
+
+const slipsInGroup = <T extends Judged>(judged: readonly T[], group: number | undefined, limit: number): Slip<T>[] => {
+  const members = judged.filter((entry) => entry.group === group);
+  const minority = minorityOf(members, judged);
+  const slips = members.filter((entry) => entry.register === minority);
+  // 片方しか無ければ揃っている。少数派が閾値を超えて多ければ、混在ではなく別の文体。
+  if (slips.length === 0 || slips.length > limit) return [];
+  return slips.map((entry) => ({ entry, count: slips.length }));
+};
+
+/**
+ * 調子が混ざった文を、judged の順で。本文は本文どうし、箇条書きは 1 つずつ、その中で揃っているかを見る。
+ * ですます調の本文に常体の箇条書きを置くのはよくある書き方で、箇条書きが丸ごと揃っていれば混在ではない。
+ */
+export const slipsOf = <T extends Judged>(judged: readonly T[], limit: number): Slip<T>[] => {
+  const slips = [...new Set(judged.map((entry) => entry.group))].flatMap((group) => slipsInGroup(judged, group, limit));
+  return judged.flatMap((entry) => slips.filter((slip) => slip.entry === entry));
+};

package/src/detectors/sentence-ending.ts

@@ -1,4 +1,5 @@
-import { endingTokens, hasPredicate, isClosed } from "../sentence-shape.ts";
+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";
 
 /**
@@ -6,36 +7,31 @@ import type { Detector, Finding, Sentence } from "../plugin.ts";
  *
  * どちらが正しいかは決めない。決めると、方針の違う書き手にそのまま無視される。
  * 見るのは文書の中での一貫性だけで、少数派のほうを指摘する。spec §12.3 の方針を日本語にも。
+ * 終止符で終わらないもの（見出しの下の `MaaSサービス` のような名前だけの行）は文として数えない。
  */
-/**
- * 述語を持たないものは文として数えない。見出しの下の `MaaSサービス` のような
- * 名前だけの行がそのまま「である調」の少数派になり、実文書の誤検知はすべてこれだった。
- */
-const isSentence = (sentence: Sentence): boolean => isClosed(sentence) && hasPredicate(sentence) && endingTokens(sentence).length > 0;
+type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
-/**
- * 文末の語だけを見る。文の途中の引用（「ご覧ください」という表現を使う。）は文末の調子ではない。
- * 書いた形でも原形でも当てる。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
- */
-const isPolite = (sentence: Sentence, polite: readonly string[]): boolean =>
-  endingTokens(sentence).some((token) => polite.includes(token.surface) || (token.lemma !== undefined && polite.includes(token.lemma)));
+const registerOfSentence = (sentence: Sentence, polite: readonly string[]): 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);
+};
 
 export const sentenceEnding: Detector = (doc, options): Finding[] => {
   const polite = (options.lexicon ?? []).map((entry) => entry.pattern);
-  const judged = doc.sentences.filter(isSentence).map((sentence) => ({ sentence, polite: isPolite(sentence, polite) }));
-  const counts = { polite: judged.filter((entry) => entry.polite).length, plain: judged.length - judged.filter((entry) => entry.polite).length };
-  const minorityIsPolite = counts.polite <= counts.plain;
-  const few = minorityIsPolite ? counts.polite : counts.plain;
-  // 片方しか無ければ一貫している。少数派が閾値を超えて多ければ、混在ではなく別の文体。
-  if (few === 0 || few > options.limit) return [];
-  return judged
-    .filter((entry) => entry.polite === minorityIsPolite)
-    .map(({ sentence }) => ({
-      rule: "no-mixed-desumasu",
-      severity: "warning",
-      line: 0,
-      column: 0,
-      quote: sentence.text.trim(),
-      values: { count: few, limit: options.limit, offset: sentence.span.start },
-    }));
+  const lists = doc.lists.map((list) => list.span);
+  const judged = doc.sentences.flatMap((sentence, index): Entry[] => {
+    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 slipsOf(judged, options.limit).map(({ entry: { sentence }, count }) => ({
+    rule: "no-mixed-desumasu",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: sentence.text.trim(),
+    values: { count, limit: options.limit, offset: sentence.span.start },
+  }));
 };

package/src/detectors/signals.ts

@@ -1,6 +1,8 @@
 import { proseText } from "../measure.ts";
 import { wordsOf } from "./structure.ts";
 import { compacted, placeOf } from "./gram-place.ts";
+import { notAcronymSpansOf, type NotAcronymSpans } from "./acronym-context.ts";
+import { expansionAt, type ExpandedAt } from "./acronym-expansion.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 
 const PER = 1000;
@@ -181,148 +183,50 @@ type Span = { readonly start: number; readonly end: number };
 
 const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: match.index + match[0].length });
 
-const spansOf = (text: string): Span[] => [
+const spansOf = (text: string, notation: NotAcronymSpans): Span[] => [
   ...[...text.matchAll(UNCASED_STRETCH)].filter((match) => SHOUTED_RUN.test(match[0])).map(spanOf),
   ...[...text.matchAll(IDENTIFIER)].filter((match) => /\d/u.test(match[0])).map(spanOf),
   ...[QUOTED_CAPS, REQUIREMENT_WORD, LICENCE].flatMap((pattern) => [...text.matchAll(pattern)].map(spanOf)),
+  ...notation(text),
 ];
 
 type AcronymHit = { readonly word: string; readonly hit: Hit };
 
-const acronymsOf = (doc: ProseDocument): AcronymHit[] =>
+const acronymsOf = (doc: ProseDocument, notation: NotAcronymSpans): AcronymHit[] =>
   doc.sentences.flatMap((sentence) => {
-    const excluded = spansOf(sentence.text);
+    const excluded = spansOf(sentence.text, notation);
     return [...sentence.text.matchAll(ACRONYM)]
       .filter((match) => !excluded.some((span) => span.start <= match.index && match.index + match[0].length <= span.end))
       .map((match) => ({ word: match[0], hit: { sentence, offset: sentence.span.start + match.index } }));
   });
 
-/** 読み手が説明なしで通じると見なしてよい語。展開すると逆に読みにくい。 */
-const COMMON = new Set([
-  "OK",
-  "NG",
-  "URL",
-  "API",
-  "CSS",
-  "HTML",
-  "JSON",
-  "YAML",
-  "HTTP",
-  "HTTPS",
-  "PDF",
-  "CPU",
-  "GPU",
-  "RAM",
-  "USB",
-  "AI",
-  "ID",
-  "FAQ",
-  "PR",
-  "OS",
-  "CLI",
-  "UI",
-  "UX",
-  "SQL",
-  "CSV",
-  "XML",
-  "TODO",
-  "NOTE",
-  // 通信と符号化。技術文書でなくても説明なしで通じる。
-  "DNS",
-  "IP",
-  "TCP",
-  "UDP",
-  "SSH",
-  "SSL",
-  "TLS",
-  "VPN",
-  "LAN",
-  "UTF",
-  "ASCII",
-  // 機器・形式・単位。
-  "PC",
-  "IT",
-  "SDK",
-  "IDE",
-  "PNG",
-  "JPEG",
-  "GIF",
-  "SVG",
-  "QR",
-  "GPS",
-  "SNS",
-  "TV",
-  "KB",
-  "MB",
-  "GB",
-  "TB",
-  // 役職と国・地域。
-  "CEO",
-  "CTO",
-  "CFO",
-  "US",
-  "UK",
-  "EU",
-  "UN",
-  "DNA",
-]);
-
-/**
- * 展開は略語の**すぐ隣**にあるときだけ認める。
- * 60 文字も見ると、同じ文のどこかに括弧があるだけで「説明済み」になり、1 件も出なくなる。
- *
- * 認めるのは 3 つの形。どれも実際によく書かれる。
- *   CI（継続的インテグレーション）   略語のあとに括弧
- *   Continuous Integration (CI)      括弧の中が略語
- *   Tax Cuts and Jobs Act [TCJA]     角括弧の中が略語で、直前の語の頭文字と揃う
- * 括弧と略語の間には、引用符（(“MNDA”)、（「MNDA」））と空白だけを許す。
- */
-const WRAP = String.raw`[\s"“”'‘’「」『』]*`;
-const OPENS = new RegExp(String.raw`^${WRAP}[(（]`, "u");
-const CLOSES = new RegExp(String.raw`^${WRAP}[)）]`, "u");
-const OPENED = new RegExp(String.raw`[(（]${WRAP}$`, "u");
-const SQUARE_CLOSES = new RegExp(String.raw`^${WRAP}\]`, "u");
-const SQUARE_OPENED = new RegExp(String.raw`\[${WRAP}$`, "u");
-
-/** 括弧と略語の間の幅。空白は 1 つに畳んであるので、(“ MNDA ”) まで収まる。 */
-const NEAR = 3;
-
-/**
- * 角括弧は引用の印にも使う（[IANA]、[1]）。直前の語のうち大文字で始まる語の頭文字が
- * 略語と揃うときだけ展開と見なす。見る語は略語の文字数の 2 倍まで（and や of を挟むため）。
- */
-const spellsOut = (before: string, acronym: string): boolean => {
-  const letters = acronym.replaceAll("&", "");
-  const words = before
-    .replace(SQUARE_OPENED, "")
-    .trim()
-    .split(/\s+/u)
-    .slice(-letters.length * 2);
-  const initials = words.filter((word) => /^[A-Z]/u.test(word)).map((word) => word.charAt(0));
-  return initials.join("").endsWith(letters);
-};
-
-const isExpandedAt = (body: string, acronym: string, at: number): boolean => {
-  const after = body.slice(at + acronym.length, at + acronym.length + NEAR);
-  const before = body.slice(Math.max(0, at - NEAR), at);
-  if (OPENS.test(after) || (OPENED.test(before) && CLOSES.test(after))) return true;
-  return SQUARE_OPENED.test(before) && SQUARE_CLOSES.test(after) && spellsOut(body.slice(0, at), acronym);
-};
-
 /**
  * どこか 1 か所で展開してあればよい。初出が節の見出し代わりの語（「5.3. DPA.」）で、
  * 展開がその直後の文にあることが契約書では普通にある。見るのは語として現れた所だけ（CISA の中の CI は見ない）。
  */
-const isExpanded = (body: string, acronym: string): boolean =>
-  [...body.matchAll(new RegExp(`${EDGE_BEFORE}${acronym}${EDGE_AFTER}`, "gu"))].some((match) => isExpandedAt(body, acronym, match.index));
+const isExpanded = (body: string, acronym: string, expandedAt: ExpandedAt): boolean =>
+  [...body.matchAll(new RegExp(`${EDGE_BEFORE}${acronym}${EDGE_AFTER}`, "gu"))].some((match) => expandedAt(body, acronym, match.index));
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const notationOf = (doc: ProseDocument): NotAcronymSpans =>
+  notAcronymSpansOf({
+    meridiem: patternsOf(doc, "meridiem"),
+    timeZones: patternsOf(doc, "time-zone"),
+    currencies: patternsOf(doc, "currency-code"),
+    usStates: patternsOf(doc, "us-state-code"),
+    emphasis: patternsOf(doc, "emphasis-word"),
+  });
 
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
+  const common = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
   const seen = new Map<string, Hit>();
-  acronymsOf(doc).forEach(({ word, hit }) => {
-    if (!COMMON.has(word) && !seen.has(word)) seen.set(word, hit);
+  acronymsOf(doc, notationOf(doc)).forEach(({ word, hit }) => {
+    if (!common.has(word) && !seen.has(word)) seen.set(word, hit);
   });
-  const bare = [...seen.entries()].filter(([acronym]) => !isExpanded(body, acronym));
+  const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: patternsOf(doc, "definition-verb") });
+  const bare = [...seen.entries()].filter(([acronym]) => !isExpanded(body, acronym, expandedAt));
   if (bare.length < options.limit) return [];
   return bare.map(([acronym, hit]) => ({
     rule: "undefined-acronym",

package/src/detectors/structure.ts

@@ -1,5 +1,7 @@
 import { charLength, lengthOf } from "../measure.ts";
-import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section } from "../plugin.ts";
+import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section, Span } from "../plugin.ts";
+import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
 
 /**
  * ばらつきは変動係数（標準偏差 ÷ 平均）で測る。
@@ -90,6 +92,21 @@ export const ruleOfThree: Detector = (doc, options): Finding[] => {
   ];
 };
 
+const dateSpans = (doc: ProseDocument): Span[] =>
+  doc.structure === undefined ? [] : inDocumentOrder(doc.structure).flatMap((node) => (node.kind === "date" ? [node.span] : []));
+
+/** 更新日の刻印（「最終更新日:」「2025年6月20日」）は前置きに数えない。木を作るのは、数えて上限を超えたときだけ。 */
+const withoutDateStamps = (doc: ProseDocument, paragraphs: readonly Paragraph[]): Paragraph[] => {
+  const labels = (doc.lexicons["date-stamp-label"] ?? []).map((entry) => entry.pattern);
+  const candidates = stampCandidates(
+    doc.source,
+    paragraphs.map((paragraph) => paragraph.span),
+    dateSpans(doc),
+  );
+  const stamps = dateStampIndexes(candidates, labels);
+  return paragraphs.filter((_, index) => !stamps.has(index));
+};
+
 /**
  * 本題に入るまでが長い。業務文書では、読み手は結論を探しに来ている。
  *
@@ -99,7 +116,9 @@ export const ruleOfThree: Detector = (doc, options): Finding[] => {
 export const preambleLength: Detector = (doc, options): Finding[] => {
   const body = doc.sections.find((section) => section.depth >= 2);
   if (body === undefined) return [];
-  const before = doc.paragraphs.filter((paragraph) => paragraph.span.start < body.span.start);
+  const all = doc.paragraphs.filter((paragraph) => paragraph.span.start < body.span.start);
+  if (all.length <= options.limit) return [];
+  const before = withoutDateStamps(doc, all);
   if (before.length <= options.limit) return [];
   const first = before[0];
   return first === undefined

package/src/detectors/superlative-scope.ts

@@ -0,0 +1,66 @@
+import type { Lexicon, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+
+/**
+ * 最上級が範囲を持っているか。「日本で最も」「国内最大」"the best in the world" は、何の中で最もなのかを言っている。
+ * 範囲を示す語は言語で違い、置く側も違う（日本語は最上級の前、英語は後ろ）。どちらの語も言語パッケージの語彙表が持つ。
+ */
+export type ScopeMarkers = {
+  /** 最上級の直前に置く語（で）。その前に固有名詞か地名が要る。 */
+  readonly before: Lexicon;
+  /** 最上級の名詞句の直後に置く語（in・of）。その後ろに名詞句が要る。 */
+  readonly after: Lexicon;
+};
+
+/** 語彙表の position で分ける。position の無い語は、どちら側の語か分からないので使わない。 */
+export const scopeMarkersOf = (lexicon: Lexicon): ScopeMarkers => ({
+  before: lexicon.filter((entry) => entry.position === "before"),
+  after: lexicon.filter((entry) => entry.position === "after"),
+});
+
+const NOMINAL = new Set(["NOUN", "PROPN"]);
+
+/** 名詞句の始まり。the world・Chicago・our products・the three・all。 */
+const PHRASE_START = new Set(["DET", "NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
+
+/** 名詞の前に来る修飾（most skilled・widely used・stuffed）。名詞が出た後は名詞の連なりだけが続く。 */
+const PREMODIFIER = new Set(["ADJ", "ADV", "VERB", "NOUN", "PROPN", "NUM"]);
+const NOUN_RUN = new Set(["NOUN", "PROPN", "NUM"]);
+
+/** 範囲の前に置ける語。修飾だけで終わった句（the best is in …）は範囲ではなく述語。 */
+const PHRASE_END = new Set(["NOUN", "PROPN", "NUM", "ADJ"]);
+
+const isMarker = (token: Token | undefined, markers: Lexicon): boolean =>
+  token !== undefined && markers.some((entry) => entry.pattern.toLowerCase() === token.surface.toLowerCase());
+
+const isNamed = (token: Token | undefined): boolean => token !== undefined && (token.pos === "PROPN" || token.features?.["NameType"] !== undefined);
+
+/** 空白も助詞も挟まずに名詞が付いた最上級（国内最大・業界最速・世界唯一）。前の名詞が範囲。 */
+const compound = (tokens: readonly Token[], range: TokenRange): boolean => {
+  const before = tokens[range.start - 1];
+  const first = tokens[range.start];
+  return before !== undefined && first !== undefined && NOMINAL.has(before.pos) && before.span.end === first.span.start;
+};
+
+/** 名前 + 範囲の語 + 最上級（日本で最も・トヨタで最も・東京都で最大）。「費用で最大の効果」の「費用」は名前ではないので範囲にしない。 */
+const namedBefore = (tokens: readonly Token[], range: TokenRange, markers: Lexicon): boolean =>
+  isMarker(tokens[range.start - 1], markers) && isNamed(tokens[range.start - 2]);
+
+/** 最上級に続く名詞句の終わり。名詞が出るまでは修飾を、出た後は名詞の連なりを読む。 */
+const phraseEnd = (tokens: readonly Token[], at: number, nounSeen = false): number => {
+  const token = tokens[at];
+  if (token === undefined || !(nounSeen ? NOUN_RUN : PREMODIFIER).has(token.pos)) return at;
+  return phraseEnd(tokens, at + 1, nounSeen || NOMINAL.has(token.pos));
+};
+
+/** 最上級 + 名詞句 + 範囲の語 + 名詞句（the best pizza in Chicago・the most famous of the sculptures）。 */
+const phraseAfter = (tokens: readonly Token[], range: TokenRange, markers: Lexicon): boolean => {
+  const at = phraseEnd(tokens, range.end);
+  const last = tokens[at - 1];
+  const endsPhrase = at === range.end || (last !== undefined && PHRASE_END.has(last.pos));
+  const opens = tokens[at + 1];
+  return endsPhrase && isMarker(tokens[at], markers) && opens !== undefined && PHRASE_START.has(opens.pos);
+};
+
+export const scoped = (tokens: readonly Token[], range: TokenRange, markers: ScopeMarkers): boolean =>
+  compound(tokens, range) || namedBefore(tokens, range, markers.before) || phraseAfter(tokens, range, markers.after);