chaffjs 0.11.0 → 0.12.0

package/src/date-stamp.ts

@@ -0,0 +1,65 @@
+import type { Span } from "./plugin.ts";
+
+/** 段落 1 つ。dates は段落の中の日付の位置で、段落の先頭から数える。 */
+export type StampCandidate = { readonly text: string; readonly dates: readonly Span[] };
+
+/** 段落ごとの候補。dates は文書の中の日付の位置で、段落の中にすっかり収まるものだけを段落の先頭からの位置にする。 */
+export const stampCandidates = (source: string, paragraphs: readonly Span[], dates: readonly Span[]): StampCandidate[] =>
+  paragraphs.map((paragraph) => ({
+    text: source.slice(paragraph.start, paragraph.end),
+    dates: dates
+      .filter((date) => date.start >= paragraph.start && date.end <= paragraph.end)
+      .map((date) => ({ start: date.start - paragraph.start, end: date.end - paragraph.start })),
+  }));
+
+/** 文字か数字。日付を除いてこれが 1 つも残らなければ、日付だけの段落。 */
+const WORD = /[\p{L}\p{N}]/u;
+const ENDS_WITH_COLON = /[:：]\s*$/u;
+const LABEL_EDGE = /[\s:：]/u;
+
+/** 幅の無い日付は日付として読まない。段落が日付だけかどうかを、何も覆わない位置で決めない。 */
+const datesOf = (candidate: StampCandidate): Span[] => candidate.dates.filter((date) => date.end > date.start);
+
+const withoutDates = (candidate: StampCandidate): string => {
+  const ordered = datesOf(candidate).sort((left, right) => left.start - right.start);
+  const gaps = ordered.reduce<{ readonly parts: readonly string[]; readonly from: number }>(
+    (acc, date) => ({ parts: [...acc.parts, candidate.text.slice(acc.from, date.start)], from: Math.max(acc.from, date.end) }),
+    { parts: [], from: 0 },
+  );
+  return [...gaps.parts, candidate.text.slice(gaps.from)].join(" ");
+};
+
+/** 前後の空白とコロンを外したラベル。「Last updated:」も「：最終更新日」も同じ語として引く。 */
+const bareLabel = (text: string): string => {
+  const chars = [...text];
+  const first = chars.findIndex((char) => !LABEL_EDGE.test(char));
+  const last = chars.findLastIndex((char) => !LABEL_EDGE.test(char));
+  return first === -1 ? "" : chars.slice(first, last + 1).join("");
+};
+
+const isLabel = (text: string, labels: readonly string[]): boolean => {
+  const bare = bareLabel(text).toLowerCase();
+  return bare !== "" && labels.some((label) => label.toLowerCase() === bare);
+};
+
+const isDateOnly = (candidate: StampCandidate | undefined): boolean =>
+  candidate !== undefined && datesOf(candidate).length > 0 && !WORD.test(withoutDates(candidate));
+
+/** 「Updated 2026-03-03」「最終更新日：2025年6月20日」。日付を除くと、語彙表のラベルしか残らない。 */
+const isLabelledDate = (candidate: StampCandidate, labels: readonly string[]): boolean =>
+  datesOf(candidate).length > 0 && isLabel(withoutDates(candidate), labels);
+
+/** 「最終更新日:」の段落のすぐ後に日付だけの段落。Web ページを写すと、ラベルと日付が別の段落に割れる。 */
+const isLabelBeforeDate = (candidate: StampCandidate, next: StampCandidate | undefined, labels: readonly string[]): boolean =>
+  ENDS_WITH_COLON.test(candidate.text) && isLabel(candidate.text, labels) && isDateOnly(next);
+
+/**
+ * 更新日・公開日の刻印になっている段落の位置。ページの付帯情報で、書いた人が読み手に読ませる前置きではない。
+ * ラベルの語は言語パッケージの語彙表（date-stamp-label）から渡す。文の中に日付があるだけの段落は刻印ではない。
+ */
+export const dateStampIndexes = (candidates: readonly StampCandidate[], labels: readonly string[]): ReadonlySet<number> =>
+  new Set(
+    candidates.flatMap((candidate, index) =>
+      isDateOnly(candidate) || isLabelledDate(candidate, labels) || isLabelBeforeDate(candidate, candidates[index + 1], labels) ? [index] : [],
+    ),
+  );

package/src/declared-lists.ts

@@ -0,0 +1,5 @@
+import type { Lexicon, RuleDefinition } from "./plugin.ts";
+
+/** rule が宣言した語彙表のうち、その言語に無い最初のもの。無いまま動かすと、照らす語が無いだけの 0 件や指摘が本物に見える。 */
+export const missingList = (rule: RuleDefinition, lexicons: Readonly<Record<string, Lexicon>>): string | undefined =>
+  [...(rule.word_list === undefined ? [] : [rule.word_list]), ...rule.extra_word_lists].find((name) => lexicons[name] === undefined);

package/src/detectors/acronym-context.ts

@@ -0,0 +1,53 @@
+/**
+ * 大文字の語が略語ではなく、決まった書き方の一部として読める所（3:30 PM、1pm ET、USD 1,000、Kansas City, MO 64108）。
+ * どれも閉じた集合で、しかも隣の数字があるときだけ認める。PM（project manager）、CT、CA（certificate authority）は
+ * 数字の隣でなければ略語のまま数える。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+const MERIDIEM = ["AM", "PM"];
+
+/** 業務文書で説明なしに書かれる時間帯。ここに無いもの（ACT など）は略語として数える。 */
+const TIME_ZONE = ["UTC", "GMT", "JST", "ET", "EST", "EDT", "CT", "CST", "CDT", "MT", "MST", "MDT", "PT", "PST", "PDT", "CET", "CEST"];
+
+/** ISO 4217 のうち、業務文書の読み手が説明なしで通じる主要な通貨。CAD は数の隣でも computer-aided design と読める（3 CAD files）ので入れない。 */
+const CURRENCY = ["USD", "EUR", "JPY", "GBP", "CNY", "CHF", "AUD", "KRW", "HKD", "SGD", "INR"];
+
+/** 米国の州・特別区・準州の郵便略号。住所の書き方（, CA 94720）の中でだけ見る。 */
+const US_STATE = [
+  ...["AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY"],
+  ...["LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND"],
+  ...["OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY"],
+  ...["DC", "PR", "GU", "VI", "AS", "MP"],
+];
+
+/**
+ * 略語として読む字面を持たない英語の機能語。単独の NOT や AND は強調で、展開するものが無い。
+ * OR（Oregon、operating room）や IS（International Standard）のように略語でもある語は入れない。
+ */
+const PLAIN_WORD = ["NOT", "AND"];
+
+const oneOf = (words: readonly string[]): string => `(?:${words.join("|")})`;
+
+const MINUTES = String.raw`:[0-5]\d`;
+const CLOCK_12 = String.raw`(?<![\d:.])(?:1[0-2]|0?[1-9])(?:${MINUTES})?`;
+const CLOCK_24 = String.raw`(?<![\d:.])(?:[01]?\d|2[0-3])${MINUTES}`;
+/** 時間帯の前の午前・午後は書き方を問わない（pm、p.m.、P.M.、PM）。 */
+const ANY_MERIDIEM = String.raw`[AaPp]\.?[Mm]\.?`;
+/** 桁区切りは 3 桁ずつ揃っているときだけ金額と読む。「item 1, USD」の 1, は金額ではない。 */
+const AMOUNT = String.raw`(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?`;
+
+// 強調の記号は空白に置き換えてある（**3:30** PM）ので、部品の間の空白は数を問わない。
+const PATTERNS: readonly RegExp[] = [
+  new RegExp(String.raw`${CLOCK_12}\s*${oneOf(MERIDIEM)}`, "gu"),
+  new RegExp(String.raw`(?:${CLOCK_24}|${CLOCK_12}\s*${ANY_MERIDIEM})\s*${oneOf(TIME_ZONE)}`, "gu"),
+  new RegExp(String.raw`${oneOf(CURRENCY)}\s*[$€£¥]?${AMOUNT}`, "gu"),
+  new RegExp(String.raw`(?<![\w.,])${AMOUNT}\s*${oneOf(CURRENCY)}`, "gu"),
+  new RegExp(String.raw`,\s+${oneOf(US_STATE)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
+  new RegExp(oneOf(PLAIN_WORD), "gu"),
+];
+
+/** 文の中で、略語として数えない大文字を含む範囲。略語は範囲にまるごと入るときだけ外れるので、語の境目は見なくてよい（NOTE の中の NOT）。 */
+export const notAcronymSpans = (text: string): Span[] =>
+  PATTERNS.flatMap((pattern) => [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length })));

package/src/detectors/acronym-expansion.ts

@@ -0,0 +1,81 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 展開は略語の**すぐ隣**にあるときだけ認める。
+ * 60 文字も見ると、同じ文のどこかに括弧があるだけで「説明済み」になり、1 件も出なくなる。
+ *
+ * 認めるのは 4 つの形。どれも実際によく書かれる。
+ *   CI（継続的インテグレーション）   略語のあとに括弧
+ *   Continuous Integration (CI)      括弧の中が略語
+ *   Tax Cuts and Jobs Act [TCJA]     角括弧の中が略語で、直前の語の頭文字と揃う
+ *   人事部（以下「HR」という。）      括弧の中が定義の語と略語だけ
+ * 括弧と略語の間には、引用符（(“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;
+
+/** 定義の語を挟む形で、括弧から略語まで・略語から括弧までに見る幅。(hereinafter referred to as “SLA”) が収まる。 */
+const DEFINITION_REACH = 60;
+
+/** 定義の語どうし、定義の語と略語の間に来てよいもの（以下、HR）。英字が続けば語の途中（(theSLA)）。 */
+const MARKER_GAP = String.raw`(?![A-Za-z])[\s、,]*`;
+
+/**
+ * 角括弧は引用の印にも使う（[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);
+};
+
+/** 言語パッケージの語彙表から読む、括弧の中で略語の前に書く語（以下、hereinafter）と後ろに書く語（という）。 */
+export type DefinitionWords = { readonly markers: readonly string[]; readonly verbs: readonly string[] };
+
+type DefinitionPatterns = { readonly opened: RegExp; readonly closes: RegExp };
+
+const oneOf = (words: readonly string[]): string => (words.length === 0 ? "(?!)" : words.map(escapeRegExp).join("|"));
+
+const definitionPatterns = (words: DefinitionWords): DefinitionPatterns => ({
+  opened: new RegExp(String.raw`[(（]\s*(?<markers>(?:(?:${oneOf(words.markers)})${MARKER_GAP})*)${WRAP}(?<![A-Za-z])$`, "iu"),
+  closes: new RegExp(String.raw`^${WRAP}(?<verb>(?:${oneOf(words.verbs)})[。.]?)?${WRAP}[)）]`, "iu"),
+});
+
+/**
+ * 括弧の中に定義の語と略語だけがある形。語が 1 つも無い（CI）は OPENED と CLOSES が見るので、ここでは数えない。
+ * 括弧の中身が語と略語で尽きることを求めるので、ふつうの意味の「以下」（（以下のSRE手順））は定義にならない。
+ */
+const isDefinedAt = (patterns: DefinitionPatterns, body: string, acronym: string, at: number): boolean => {
+  const opened = patterns.opened.exec(body.slice(Math.max(0, at - DEFINITION_REACH), at));
+  const closes = patterns.closes.exec(body.slice(at + acronym.length, at + acronym.length + DEFINITION_REACH));
+  if (opened === null || closes === null) return false;
+  return (opened.groups?.["markers"] ?? "") !== "" || (closes.groups?.["verb"] ?? "") !== "";
+};
+
+const isBracketedAt = (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);
+};
+
+export type ExpandedAt = (body: string, acronym: string, at: number) => boolean;
+
+/** body の at にある略語が、その場で展開・定義されているか。語彙表から一度だけ組み立てて、略語ごとに呼ぶ。 */
+export const expansionAt = (words: DefinitionWords): ExpandedAt => {
+  const patterns = definitionPatterns(words);
+  return (body, acronym, at) => isBracketedAt(body, acronym, at) || isDefinedAt(patterns, body, acronym, at);
+};

package/src/detectors/doubled-word.ts

@@ -0,0 +1,128 @@
+import type { Detector, Finding, Lexicon, Sentence, Token } from "../plugin.ts";
+
+/**
+ * 語を書き損じて二度書いた（the the / 資料をを）。消し忘れと、書き換えの途中で残った語（our the platform）の二つ。
+ *
+ * 同じ語は、表層（大文字小文字は問わない）と品詞の両方が同じときだけ。「that that」は接続詞と指示語で品詞が違う。
+ * 冠詞と所有の語は名詞の前に一つしか立たないので、違う語でも二つ並べば書き損じ。印はアダプタが UD の FEATS で付ける。
+ * どの言語でも書き損じでない重なり（had had / 一つ一つ）は、言語ごとの語彙表に置く。
+ */
+
+/**
+ * 重ねても書き損じにならない品詞。記号と数は語ではない。間投詞（はいはい / no no）と副詞（そうそう / very very）は
+ * 重ねて強める書き方がどの語でもできるので、語彙表では尽くせない。固有名詞は重なった名前（Walla Walla）がある。
+ */
+const REPEATABLE = new Set(["PUNCT", "SYM", "NUM", "X", "INTJ", "ADV", "PROPN"]);
+
+/** 強調やリンクの印を挟んで重なった内容語は、画面名とその名詞（**app settings** settings screen）。機能語だけが書き損じ。 */
+const FUNCTION_WORD = new Set(["DET", "ADP", "PRON", "AUX", "CCONJ", "SCONJ", "PART"]);
+
+const LETTER = /\p{L}/u;
+const LETTER_OR_DIGIT = /[\p{L}\p{N}]/u;
+const SPACE_ONLY = /^\s*$/u;
+/** 語を空白で区切る言語で、語に接していれば長い語の一部（114A The の A、Content-Type の Content）。 */
+const JOINED = /[\p{L}\p{N}-]/u;
+
+const isWord = (token: Token): boolean => LETTER.test(token.surface) && !REPEATABLE.has(token.pos) && token.features?.["NumType"] !== "Card";
+
+const isDeterminer = (token: Token): boolean => token.features?.["PronType"] === "Art" || token.features?.["Poss"] === "Yes";
+
+const sameWord = (first: Token, second: Token): boolean => first.surface.toLowerCase() === second.surface.toLowerCase() && first.pos === second.pos;
+
+/** 二語のあいだ。space は空白だけ、markup は印だけ（文字も数字も無い）、text はそれ以外で、別々の語。 */
+export type Gap = "space" | "markup" | "text";
+
+export const gapBetween = (source: string, first: Token, second: Token): Gap => {
+  const between = source.slice(first.span.end, second.span.start);
+  if (SPACE_ONLY.test(between)) return "space";
+  return LETTER_OR_DIGIT.test(between) ? "text" : "markup";
+};
+
+/** 語を空白で区切る言語だけ。日本語は語どうしが接しているのが普通。 */
+export const isPartOfLongerWord = (source: string, first: Token, second: Token): boolean =>
+  JOINED.test(source.charAt(first.span.start - 1)) || JOINED.test(source.charAt(second.span.end));
+
+const surfacesOf = (tokens: readonly Token[]): string => tokens.map((token) => token.surface.toLowerCase()).join("\u0000");
+
+/**
+ * 語彙表の行（had had、sign in in、set up up to）の k 語目と k+1 語目を重なりに重ねて、行の語が全部並んでいるか。
+ * 一語の行は重なりを言っていないので、重ねる位置が無い。
+ */
+const coversPairAt = (tokens: readonly Token[], at: number, words: readonly Token[]): boolean =>
+  Array.from({ length: words.length - 1 }, (_, k) => tokens.slice(at - k, at - k + words.length)).some((row) => surfacesOf(row) === surfacesOf(words));
+
+/**
+ * tokens の at 語目と次の語の重なりを、語彙表のどれかの行がそのまま含むか。
+ * 語彙表の語は、文と同じ解析器で分けたもの（entry.tokens）で比べる。書き方の空白の有無に左右されない。
+ */
+export const isAllowed = (tokens: readonly Token[], at: number, allowed: Lexicon): boolean =>
+  allowed.some((entry) => coversPairAt(tokens, at, entry.tokens ?? []));
+
+export type Doubled = { readonly first: Token; readonly second: Token };
+
+const LOWER_START = /^\p{Ll}/u;
+const UPPER_START = /^\p{Lu}/u;
+
+/** 小文字の語の後ろの大文字は、題名や名前の書き出し（the [Your Rights section]）。同じ語の the The は書き損じのまま。 */
+export const startsTitle = (first: Token, second: Token): boolean => LOWER_START.test(first.surface) && UPPER_START.test(second.surface);
+
+/** アダプタが重ね言葉（UD の Echo=Rdp）と読んだ語。「会社会社で」の二つ目。 */
+const isEcho = (token: Token): boolean => token.features?.["Echo"] === "Rdp";
+
+const isDeterminerPair = (first: Token, second: Token): boolean => isDeterminer(first) && isDeterminer(second) && !startsTitle(first, second);
+
+const isDoubled = (first: Token, second: Token): boolean =>
+  isWord(first) && isWord(second) && !isEcho(second) && (sameWord(first, second) || isDeterminerPair(first, second));
+
+/** 並んだ二語が書き損じか。source は文書全体で、token の span もその座標。 */
+export const doubledAt = (source: string, first: Token, second: Token, spaced: boolean): boolean => {
+  if (!isDoubled(first, second)) return false;
+  if (spaced && isPartOfLongerWord(source, first, second)) return false;
+  const gap = gapBetween(source, first, second);
+  return gap === "space" || (gap === "markup" && FUNCTION_WORD.has(first.pos));
+};
+
+/**
+ * 文の途中で、大文字の語の後ろに小文字の同じ語が来たら、一つ目は名前（Payment for May may be delayed）。
+ * 文頭の The the と、冠詞・所有の語（review The the draft）は名前にならないので書き損じ。
+ */
+export const isNameBefore = (first: Token, second: Token, opensSentence: boolean): boolean =>
+  !opensSentence && !isDeterminer(first) && UPPER_START.test(first.surface) && LOWER_START.test(second.surface);
+
+const opensSentence = (tokens: readonly Token[], at: number): boolean => !tokens.slice(0, at).some((token) => LETTER.test(token.surface));
+
+const repeatsPrevious = (tokens: readonly Token[], at: number): boolean => {
+  const [previous, token] = [tokens[at - 1], tokens[at]];
+  return previous !== undefined && token !== undefined && surfacesOf([previous]) === surfacesOf([token]);
+};
+
+/** 語彙表の重なり（had had）も、三つ続けば（had had had）書き損じ。 */
+const allowedAt = (tokens: readonly Token[], at: number, allowed: Lexicon): Lexicon => (repeatsPrevious(tokens, at) ? [] : allowed);
+
+export const doubledIn = (source: string, tokens: readonly Token[], spaced: boolean, allowed: Lexicon): Doubled[] =>
+  tokens.flatMap((second, index) => {
+    const first = tokens[index - 1];
+    if (first === undefined || !doubledAt(source, first, second, spaced)) return [];
+    if (isAllowed(tokens, index - 1, allowedAt(tokens, index - 1, allowed))) return [];
+    return isNameBefore(first, second, opensSentence(tokens, index - 1)) ? [] : [{ first, second }];
+  });
+
+/** 印を挟んでいても（the [the）、見せるのは二語だけ。 */
+const wordOf = (doubled: Doubled, spaced: boolean): string => [doubled.first.surface, doubled.second.surface].join(spaced ? " " : "");
+
+const findingOf = (sentence: Sentence, doubled: Doubled, spaced: boolean): Finding => ({
+  rule: "doubled-word",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: sentence.text.trim(),
+  values: { word: wordOf(doubled, spaced), offset: doubled.second.span.start },
+});
+
+export const doubledWord: Detector = (doc, options): Finding[] => {
+  const spaced = doc.lengthUnit === "word";
+  const allowed = options.lexicon ?? [];
+  return doc.sentences.flatMap((sentence) =>
+    doubledIn(doc.source, sentence.tokens ?? [], spaced, allowed).map((doubled) => findingOf(sentence, doubled, spaced)),
+  );
+};

package/src/detectors/heading-echo.ts

@@ -1,5 +1,6 @@
 import { lengthOf } from "../measure.ts";
-import type { Detector, Finding, LengthUnit, Section } from "../plugin.ts";
+import { handsOver } from "./lead-in.ts";
+import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../plugin.ts";
 
 /** 見出しが短すぎると、偶然の一致で 100% になる。これ未満の見出しは見ない。 */
 const MIN_GRAMS = 4;
@@ -51,9 +52,17 @@ const addsLittle = (section: Section, unit: LengthUnit): boolean => {
   return lengthOf(first, unit) - headingUnits(section.heading, unit) <= NEW_MATERIAL[unit];
 };
 
-export const headingEcho: Detector = (doc, options): Finding[] =>
-  doc.sections
+/** 最初の文が、同じ節の後ろ（箇条書き・表・コード）へ読者を渡している。 */
+const leadsIn = (doc: ProseDocument, section: Section, phrases: readonly string[]): boolean => {
+  const first = section.firstSentence;
+  return first !== undefined && handsOver(first.text, doc.source.slice(first.span.end, section.span.end), phrases);
+};
+
+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) }))
     .filter(({ overlap }) => overlap >= options.limit)
     .map(({ section, overlap }) => ({
@@ -64,3 +73,4 @@ export const headingEcho: Detector = (doc, options): Finding[] =>
       quote: section.firstSentence?.text.trim() ?? "",
       values: { heading: section.heading, count: overlap, limit: options.limit, offset: section.firstSentence?.span.start ?? section.span.start },
     }));
+};

package/src/detectors/index.ts

@@ -6,6 +6,7 @@ import { repeatedHead } from "./repeated-head.ts";
 import { sentenceRhythm } from "./sentence-rhythm.ts";
 import { phraseMatch } from "./phrase-match.ts";
 import { agentlessPassive } from "./agentless-passive.ts";
+import { doubledWord } from "./doubled-word.ts";
 import { sentenceEnding } from "./sentence-ending.ts";
 import { doubledParticle, nounEnding } from "./token-shape.ts";
 import { kanjiRun, middleDot } from "./char-shape.ts";
@@ -29,6 +30,7 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "sentence-ending": sentenceEnding,
   "noun-ending": nounEnding,
   "doubled-particle": doubledParticle,
+  "doubled-word": doubledWord,
   "kanji-run": kanjiRun,
   "middle-dot": middleDot,
   "adverb-density": adverbDensity,

package/src/detectors/lead-in.ts

@@ -0,0 +1,14 @@
+/** 文末のコロン。後ろに強調の印（**・_）や空白が残っていても見る。 */
+const ENDS_WITH_COLON = /[:：][\s*_]*$/u;
+
+/**
+ * 後ろの箇条書きや表へ読者を渡す文（「次のとおりとする。」「The following expenses require receipts:」）。
+ * 見出しの語を繰り返していても、中身は後ろにある。言い回しは言語パッケージの語彙表 lead-in が持つ。
+ */
+export const isLeadIn = (sentence: string, phrases: readonly string[]): boolean => {
+  const text = sentence.trim().toLowerCase();
+  return ENDS_WITH_COLON.test(text) || phrases.some((phrase) => phrase !== "" && text.includes(phrase.toLowerCase()));
+};
+
+/** 渡す先（following: 同じ節の、その文より後ろ）が空なら、渡す文ではなくただの繰り返し。 */
+export const handsOver = (sentence: string, following: string, phrases: readonly string[]): boolean => following.trim() !== "" && isLeadIn(sentence, phrases);

package/src/detectors/lexicon-match.ts

@@ -32,6 +32,16 @@ export const entryIn = (sentence: Sentence, entry: LexiconEntry): boolean => {
   return tokens.some((_token, start) => runsAt(tokens, words, start));
 };
 
+export type TokenRange = { readonly start: number; readonly end: number };
+
+/** 語彙の語が文のどの語の並びに当たったか（始まりと、終わった次の位置）。品詞が無ければ位置を言えないので空。 */
+export const entryRanges = (sentence: Sentence, entry: LexiconEntry): TokenRange[] => {
+  const tokens = sentence.tokens;
+  const words = entry.tokens;
+  if (tokens === undefined || words === undefined || words.length === 0) return [];
+  return tokens.flatMap((_token, start) => (runsAt(tokens, words, start) ? [{ start, end: start + words.length }] : []));
+};
+
 const LEADING_MARK = new Set(["PUNCT", "SYM"]);
 
 /** 語彙の語で文が始まるか。文頭の記号は飛ばす。品詞が無ければ文字列の前方一致。 */

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/signals.ts

@@ -1,6 +1,8 @@
 import { proseText } from "../measure.ts";
 import { wordsOf } from "./structure.ts";
 import { compacted, placeOf } from "./gram-place.ts";
+import { 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;
@@ -185,6 +187,7 @@ const spansOf = (text: string): 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)),
+  ...notAcronymSpans(text),
 ];
 
 type AcronymHit = { readonly word: string; readonly hit: Hit };
@@ -197,132 +200,24 @@ const acronymsOf = (doc: ProseDocument): AcronymHit[] =>
       .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);
 
 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);
+    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",