chaffjs 0.14.0 → 0.16.0

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,5 +1,7 @@
-import type { Detector, Finding, Sentence } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
+import { calendarRuns, type CalendarRun, type CalendarUnits } from "../calendar-number.ts";
 import { latinBoundaries, minorityStyle, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
+import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { digitRunAround, isNumberName, sequenceLabelStarts } from "../number-name.ts";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
@@ -30,25 +32,56 @@ const digitBeside = (boundary: Boundary): number => {
   return boundary.spaced ? boundary.offset + 1 : boundary.offset;
 };
 
-/** 番号・識別子として書かれた数の境目は、空け方の好みではないので数えない（number-name.ts）。 */
-const isCounted = (sentence: Sentence, boundary: Boundary, sequence: ReadonlySet<number>): boolean => {
+/** 文書全体で一度だけ読むもの。sequence は続き番号の行の頭、topUnits は都道府県の単位、calendar は日付・時刻の単位。 */
+type NumberContext = { readonly sequence: ReadonlySet<number>; readonly topUnits: ReadonlySet<string>; readonly calendar: CalendarUnits };
+
+/** 文の中の日付・時刻の数の、並びの頭の位置と、日付の中の位置。 */
+const calendarPlaces = (sentence: Sentence, units: CalendarUnits): ReadonlyMap<number, CalendarRun["place"]> =>
+  new Map(calendarRuns(sentence.text, sentence.tokens, sentence.span.start, units).map(({ run, place }) => [run.start, place]));
+
+/**
+ * 日付・時刻の中の境目（「9月」の数と単位のあいだ、「2026年9月」の年と 9 のあいだ）は、詰めて書く決まりで好みではない。
+ * 日付の前の境目（「は 9月」の空白）は、数の前をどう空けるかという書き手の書き方なので数える。
+ */
+const isInsideCalendar = (boundary: Boundary, place: CalendarRun["place"] | undefined): boolean =>
+  place !== undefined && (boundary.kind === "after-digit" || place === "inner");
+
+/** 番号・識別子として書かれた数（number-name.ts）と日付・時刻の中の境目は、空け方の好みではないので数えない。 */
+const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, calendar: ReadonlyMap<number, CalendarRun["place"]>): 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, sequence);
+  if (run === undefined) return true;
+  if (isInsideCalendar(boundary, calendar.get(run.start))) return false;
+  return !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, context.sequence, context.topUnits);
 };
 
+const patternList = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+const patternsOf = (doc: ProseDocument, id: string): ReadonlySet<string> => new Set(patternList(doc, id));
+
+/**
+ * 鉤括弧で引いた題名や発言（「…ガイドライン 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[] => {
   // 覆った文（prose）で探す。コードの中の「1 件」は並びに入れない。
-  const sequence = sequenceLabelStarts(doc.prose ?? doc.source);
-  const located: Located[] = doc.sentences.flatMap((sentence) =>
-    latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
-      .filter((boundary) => isCounted(sentence, boundary, sequence))
-      .map((boundary) => ({ sentence, ...boundary })),
-  );
+  const context: NumberContext = {
+    sequence: sequenceLabelStarts(doc.prose ?? doc.source),
+    topUnits: patternsOf(doc, "prefecture-unit"),
+    calendar: { chained: patternList(doc, "date-time-unit"), positional: patternsOf(doc, "calendar-unit"), year: patternsOf(doc, "calendar-year-unit") },
+  };
+  const located: Located[] = doc.sentences.flatMap((sentence) => {
+    const quoted = quotedSpans(sentence.text);
+    const calendar = calendarPlaces(sentence, context.calendar);
+    return latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
+      .filter((boundary) => !isQuoted(quoted, boundary) && isCounted(sentence, boundary, context, calendar))
+      .map((boundary) => ({ sentence, ...boundary }));
+  });
   return KINDS.flatMap((kind) => {
     const ofKind = located.filter((entry) => entry.kind === kind);
     const minority = minorityStyle(ofKind);

package/src/detectors/phrase-match.ts

@@ -1,4 +1,4 @@
-import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
 import { entryIn } from "./lexicon-match.ts";
 
 /** 冒頭は先頭 2 段落ぶん。「どの記事にも当てはまる書き出し」は冒頭にあるときだけ問題。 */
@@ -22,21 +22,32 @@ const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon): Hit[] =>
     return matched === undefined ? [] : [{ sentence, matched: matched.pattern }];
   });
 
-/**
- * 語彙表との照合。detector は共通で、語彙だけが言語別に差し替わる。spec §11。
- * これが L2 の全体像で、新しい言語は語彙表を書くだけで動く。
- */
-export const phraseMatch: Detector = (doc, options): Finding[] => {
-  const lexicon = options.lexicon ?? [];
-  if (lexicon.length === 0) return [];
-  const hits = hitsIn(inScope(doc, options.where), lexicon);
-  if (hits.length < options.limit) return [];
-  return hits.map((hit) => ({
+const findingsOf = (hits: readonly Hit[], limit: number): Finding[] =>
+  hits.map((hit) => ({
     rule: "",
     severity: "warning",
     line: 0,
     column: 0,
     quote: hit.sentence.text.trim(),
-    values: { matched: hit.matched, count: hits.length, limit: options.limit, offset: hit.sentence.span.start },
+    values: { matched: hit.matched, count: hits.length, limit, offset: hit.sentence.span.start },
   }));
+
+const phraseHits = (doc: ProseDocument, options: DetectorOptions): Hit[] => {
+  const lexicon = options.lexicon ?? [];
+  return lexicon.length === 0 ? [] : hitsIn(inScope(doc, options.where), lexicon);
+};
+
+/**
+ * 語彙表との照合。detector は共通で、語彙だけが言語別に差し替わる。spec §11。
+ * これが L2 の全体像で、新しい言語は語彙表を書くだけで動く。limit は指摘に要る数で、1 なら 1 つ目から言う。
+ */
+export const phraseMatch: Detector = (doc, options): Finding[] => {
+  const hits = phraseHits(doc, options);
+  return hits.length < options.limit ? [] : findingsOf(hits, options.limit);
+};
+
+/** 回数に上限がある語。limit は許す回数で、それを超えたときだけ言う。message の「N 回まで」と同じ向き。 */
+export const phraseCount: Detector = (doc, options): Finding[] => {
+  const hits = phraseHits(doc, options);
+  return hits.length <= options.limit ? [] : findingsOf(hits, options.limit);
 };

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/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/repeated-head.ts

@@ -35,10 +35,9 @@ const runsOf = (sentences: readonly Sentence[], unit: LengthUnit, lists: readonl
     // 短すぎる書き出しは「同じ」と言えない。単位ぶん揃って初めて連なりと見る。
     const full = unit === "char" ? head.length === HEAD_CHARS : head.split(" ").length === HEAD_WORDS;
     const joins = last !== undefined && last.head === head && last.container === container && !listBetween(last.members.at(-1), sentence, lists);
-    if (last !== undefined && joins && full) {
-      return [...acc.slice(0, -1), { head, container, members: [...last.members, sentence] }];
-    }
-    return [...acc, { head, container, members: [sentence] }];
+    if (last !== undefined && joins && full) acc[acc.length - 1] = { head, container, members: [...last.members, sentence] };
+    else acc.push({ head, container, members: [sentence] });
+    return acc;
   }, []);
 
 export const repeatedHead: Detector = (doc, options): Finding[] =>

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 }));

package/src/detectors/signals.ts

@@ -3,8 +3,13 @@ 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 { isExplained } from "./acronym-compound.ts";
 import { conjugatedForms } from "./conjugated-form.ts";
-import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
+import { evidenceSpans, hasNumeral, startsWithin } from "./concrete-evidence.ts";
+import { letteredIndexEntries } from "./lettered-index.ts";
+import { hasPredicateIn } from "./gram-predicate.ts";
+import { nameSpans, touchesAny } from "../team-names.ts";
+import type { Detector, Finding, ProseDocument, Section, Sentence } from "../plugin.ts";
 
 const PER = 1000;
 
@@ -59,9 +64,12 @@ export const emojiDensity: Detector = (doc, options): Finding[] => {
  */
 const GRAM = { char: 8, word: 20 };
 
-const countGrams = (text: string, width: number): Map<string, number> => {
+/** 並べた名前にかかる語句は数えない。名前が繰り返されれば、その前後（「the …」）も一緒に繰り返されるのは当たり前。 */
+const countGrams = (text: string, width: number, names: readonly string[]): Map<string, number> => {
   const counts = new Map<string, number>();
+  const named = nameSpans(text, names);
   Array.from({ length: Math.max(0, text.length - width + 1) }).forEach((_, index) => {
+    if (touchesAny(named, index, index + width)) return;
     const gram = text.slice(index, index + width);
     counts.set(gram, (counts.get(gram) ?? 0) + 1);
   });
@@ -90,7 +98,8 @@ const gramsOf = (doc: ProseDocument): Map<string, number> => {
   const counts = new Map<string, number>();
   doc.sentences.forEach((sentence) => {
     const text = doc.lengthUnit === "char" ? proseText(sentence).replace(/\s+/gu, "") : proseText(sentence);
-    countGrams(text, GRAM[doc.lengthUnit]).forEach((count, gram) => counts.set(gram, (counts.get(gram) ?? 0) + count));
+    const names = doc.lengthUnit === "char" ? (doc.names ?? []).map((name) => name.replace(/\s+/gu, "")) : (doc.names ?? []);
+    countGrams(text, GRAM[doc.lengthUnit], names).forEach((count, gram) => counts.set(gram, (counts.get(gram) ?? 0) + count));
   });
   return counts;
 };
@@ -98,29 +107,15 @@ const gramsOf = (doc: ProseDocument): Map<string, number> => {
 /** 数えたときと同じ形の文。char 単位では空白を詰めてから数えている。 */
 const gramText = (sentence: Sentence, unit: ProseDocument["lengthUnit"]): string => compacted(sentence.text, unit).text;
 
-/** 動詞と助動詞。言い回し（ることができます、it is important to）にはこれが入り、主題の名前（state and local tax）には入らない。 */
-const PREDICATE_POS = new Set(["VERB", "AUX"]);
-
-const NOUNS = new Set(["NOUN", "PROPN", "ADJ"]);
-
-/**
- * 英語で名詞のすぐ前の動詞は、名詞を飾る語（形容詞を挟んでも同じ）（the upcoming fiscal year、the Disclosing Party、the borrow checker）で、
- * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、word 単位だけで見る。
- */
-const modifiesNoun = (tokens: readonly Token[], index: number, unit: ProseDocument["lengthUnit"]): boolean =>
-  unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "");
-
 /**
- * 語句が文の中で占める範囲に、動詞か助動詞があるか。範囲で見る。文字で探すと、同じ文の別の所の動詞「use」が、語句の中の名詞「use」に当たる。
+ * 語句が文の中で占める範囲に、述語になる動詞か助動詞があるか（gram-predicate.ts）。
  * 品詞が無ければ見分けられないので、これまでどおり言い回しとして数える。
  */
 const hasPredicate = (gram: string, sentence: Sentence, unit: ProseDocument["lengthUnit"]): boolean => {
   if (sentence.tokens === undefined) return true;
   const place = placeOf(compacted(sentence.text, unit), gram);
   if (place === undefined) return true;
-  const [start, end] = [sentence.span.start + place.start, sentence.span.start + place.end];
-  const tokens = sentence.tokens;
-  return tokens.some((token, index) => PREDICATE_POS.has(token.pos) && token.span.start < end && start < token.span.end && !modifiesNoun(tokens, index, unit));
+  return hasPredicateIn(sentence.tokens, { start: sentence.span.start + place.start, end: sentence.span.start + place.end }, unit);
 };
 
 export const ngramRepetition: Detector = (doc, options): Finding[] => {
@@ -128,7 +123,7 @@ export const ngramRepetition: Detector = (doc, options): Finding[] => {
   const sentenceWith = (gram: string): Sentence | undefined => doc.sentences.find((sentence) => gramText(sentence, doc.lengthUnit).includes(gram));
   const worst = [...gramsOf(doc).entries()]
     .filter(([gram, count]) => count > options.limit && isPhrasing(gram, doc.lengthUnit))
-    .sort(([, left], [, right]) => right - left)
+    .toSorted(([, left], [, right]) => right - left)
     .map(([gram, count]) => ({ gram, count, at: sentenceWith(gram) }))
     .find(({ gram, at }) => at === undefined || hasPredicate(gram, at, doc.lengthUnit));
   if (worst === undefined) return [];
@@ -150,10 +145,14 @@ export const ngramRepetition: Detector = (doc, options): Finding[] => {
  * 展開は「略語の直前か直後の括弧」か「括弧の中の略語」で書かれる。
  *
  * & で繋いだ大文字は 1 語として読む（ATT&CK、M&IE）。割ると CK や IE が別の略語に見える。
+ * - で繋いだ略語どうしも 1 語（RT-PCR）。割ると RT が別の略語に見える。数字を含むもの（COVID-19）は識別子として外す。
  */
 const EDGE_BEFORE = String.raw`(?<![A-Za-z0-9_&])`;
 const EDGE_AFTER = String.raw`(?![A-Za-z0-9_&])`;
-const ACRONYM = new RegExp(String.raw`${EDGE_BEFORE}(?:[A-Z]+(?:&[A-Z]+)+|[A-Z]{2,6})${EDGE_AFTER}`, "gu");
+/** 略語として読む大文字の長さの上限。これより長い大文字の語（BILLING）は、普通の語を大文字で書いたもの。 */
+const ACRONYM_MAX = 6;
+const ACRONYM_PART = String.raw`(?:[A-Z]+(?:&[A-Z]+)+|[A-Z]{2,${ACRONYM_MAX}})`;
+const ACRONYM = new RegExp(String.raw`${EDGE_BEFORE}${ACRONYM_PART}(?:-${ACRONYM_PART})*${EDGE_AFTER}`, "gu");
 
 /**
  * 大文字で書かれていても略語ではないもの。
@@ -162,9 +161,17 @@ const ACRONYM = new RegExp(String.raw`${EDGE_BEFORE}(?:[A-Z]+(?:&[A-Z]+)+|[A-Z]{
  * 強調は読点や括弧をまたいで続くので（THE AUTHOR, THE COMPANY (IF ANY)）、そういう続きを含む
  * 「大文字以外の文字を含まない一続き」を丸ごと強調と見なす。小文字の語が挟まれば切れるので、
  * 「SRE, SLO, MTTR」のような略語の並びは残る。引用符に包まれた大文字の句（“AS IS”）も強調。
+ * 2 語でも、片方が略語にしては長い語なら強調（BILLING CODE）。略語 2 つの並び（NIST SP）は残る。
  */
 const CAPS_WORD = String.raw`[A-Z]+(?:&[A-Z]+)*`;
-const SHOUTED_RUN = new RegExp(String.raw`${EDGE_BEFORE}${CAPS_WORD}(?:[\s"“”'‘’]+${CAPS_WORD}){2,}${EDGE_AFTER}`, "u");
+const LONG_CAPS_WORD = String.raw`[A-Z]{${ACRONYM_MAX + 1},}`;
+const CAPS_GAP = String.raw`[\s"“”'‘’]+`;
+const SHOUTED_RUN = new RegExp(String.raw`${EDGE_BEFORE}${CAPS_WORD}(?:${CAPS_GAP}${CAPS_WORD}){2,}${EDGE_AFTER}`, "u");
+/** 2 語の強調は、その 2 語だけを外す。続きまで外すと、区切りの後ろの略語（NEW GUIDELINES: SRE）まで消える。 */
+const SHOUTED_PAIR = new RegExp(
+  String.raw`${EDGE_BEFORE}(?:${LONG_CAPS_WORD}${CAPS_GAP}${CAPS_WORD}|${CAPS_WORD}${CAPS_GAP}${LONG_CAPS_WORD})${EDGE_AFTER}`,
+  "gu",
+);
 const UNCASED_STRETCH = /(?:[A-Z]|\P{L})+/gu;
 const QUOTED_CAPS = new RegExp(String.raw`["“'‘]${CAPS_WORD}(?:\s+${CAPS_WORD})+["”'’]`, "gu");
 
@@ -187,15 +194,16 @@ const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: mat
 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)),
+  ...[SHOUTED_PAIR, QUOTED_CAPS, REQUIREMENT_WORD, LICENCE].flatMap((pattern) => [...text.matchAll(pattern)].map(spanOf)),
   ...notation(text),
 ];
 
 type AcronymHit = { readonly word: string; readonly hit: Hit };
 
+/** チームが並べた名前の中の略語（NTT Docomo の NTT）は、名前の一部であって説明を待つ略語ではない。 */
 const acronymsOf = (doc: ProseDocument, notation: NotAcronymSpans): AcronymHit[] =>
   doc.sentences.flatMap((sentence) => {
-    const excluded = spansOf(sentence.text, notation);
+    const excluded = [...spansOf(sentence.text, notation), ...nameSpans(sentence.text, doc.names ?? [])];
     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 } }));
@@ -218,6 +226,8 @@ const notationOf = (doc: ProseDocument): NotAcronymSpans =>
     usStates: patternsOf(doc, "us-state-code"),
     emphasis: patternsOf(doc, "emphasis-word"),
     divisions: patternsOf(doc, "numbered-division"),
+    honorifics: patternsOf(doc, "honorific"),
+    dateTimeUnits: patternsOf(doc, "date-time-unit"),
   });
 
 /** 定義の語は、語彙表の形（という）と、この文書で活用して書かれた形（といいます）の両方で照らす。 */
@@ -228,13 +238,16 @@ const definitionVerbsOf = (doc: ProseDocument): string[] => {
 
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
-  const common = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
+  // HTTP のメソッド名（GET）は略語ではないので、通じる略語と同じく展開を求めない。
+  // 並べた名前（JAXA）も、繋いだ略語（JAXA-ISAS）の片割れとして説明済みに数える。
+  const common = new Set([...(options.lexicon ?? []).map((entry) => entry.pattern), ...patternsOf(doc, "http-method"), ...(doc.names ?? [])]);
   const seen = new Map<string, Hit>();
   acronymsOf(doc, notationOf(doc)).forEach(({ word, hit }) => {
-    if (!common.has(word) && !seen.has(word)) seen.set(word, hit);
+    if (!seen.has(word)) seen.set(word, hit);
   });
   const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: definitionVerbsOf(doc) });
-  const bare = [...seen.entries()].filter(([acronym]) => !isExpanded(body, acronym, expandedAt));
+  const explainedAlone = (word: string): boolean => common.has(word) || isExpanded(body, word, expandedAt);
+  const bare = [...seen.entries()].filter(([acronym]) => !isExplained(acronym, explainedAlone));
   if (bare.length < options.limit) return [];
   return bare.map(([acronym, hit]) => ({
     rule: "undefined-acronym",
@@ -265,16 +278,17 @@ const openingOf = (sentence: Sentence | undefined, unit: ProseDocument["lengthUn
   return pieces.length <= OPENING[unit] ? pieces.join(joiner) : `${pieces.slice(0, OPENING[unit]).join(joiner)}…`;
 };
 
-/**
- * 形態素解析が数と読んだ語（UD の NumType=Card）。漢数字の「二割」「十五分」も、算用数字と同じ具体的な数。
- * 言い回しの「二人三脚」「一人ひとり」は、辞書が一語として持つので数にならない。品詞が無ければ、数字だけを見る。
- */
-const hasNumeral = (section: Section): boolean =>
-  section.sentences.some((sentence) => (sentence.tokens ?? []).some((token) => token.features?.["NumType"] === "Card"));
+const hasNumeralIn = (section: Section): boolean => section.sentences.some((sentence) => hasNumeral(sentence.tokens ?? []));
 
 export const concreteEvidence: Detector = (doc, options): Finding[] => {
-  const sections = doc.sections.filter((section) => section.sentences.length >= 3);
-  const empty = sections.filter((section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)) && !hasNumeral(section));
+  const entries = letteredIndexEntries(doc.sections);
+  const sections = doc.sections.filter((section) => section.sentences.length >= 3 && !entries.has(section));
+  const bare = sections.filter(
+    (section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)) && !hasNumeralIn(section) && !startsWithin(section.span, doc.links),
+  );
+  // 構造の木は作るのに手間がかかる。指摘に届かない文書では作らない。
+  const nodes = bare.length < options.limit ? [] : evidenceSpans(doc.structure);
+  const empty = bare.filter((section) => !startsWithin(section.span, nodes));
   if (empty.length < options.limit) return [];
   return empty.map((section) => ({
     rule: "concrete-evidence-density",

package/src/detectors/stacked-hedge.ts

@@ -0,0 +1,93 @@
+import type { Lexicon, Sentence, Span, Token } from "../plugin.ts";
+import { entryRanges, type TokenRange } from "./lexicon-match.ts";
+import { isWithinAny, quotedIn, QUOTATION_MARKS } from "../quoted-span.ts";
+
+/** 重ねたと言うのに要る数。1 つなら慎重さで、2 つ目からは読み手が何を言い切ったのか分からなくなる。 */
+export const STACKED_AT = 2;
+
+/**
+ * 語彙表 3 つ。hedges は逃げの表現そのもの、frames はそれだけでは逃げていない包む言い方（「という状況です」、may）、
+ * scope は hedges のうち、どれだけ確かかではなくどこで成り立つかを言うもの（「場合がある」、in some cases）。
+ */
+export type HedgeWords = { readonly hedges: Lexicon; readonly frames: Lexicon; readonly scope: Lexicon };
+
+type Device = { readonly range: TokenRange; readonly hedge: boolean };
+
+export type StackedHedge = { readonly sentence: Sentence; readonly spans: readonly Span[] };
+
+const rangesOf = (sentence: Sentence, lexicon: Lexicon): TokenRange[] => lexicon.flatMap((entry) => entryRanges(sentence, entry));
+
+const contains = (outer: TokenRange, inner: TokenRange): boolean => outer.start <= inner.start && inner.end <= outer.end;
+
+const sameRange = (left: TokenRange, right: TokenRange): boolean => left.start === right.start && left.end === right.end;
+
+/**
+ * 同じ語に当たった見出しは 1 つに数える。「could」は「it could be」の一部。
+ * 同じ範囲に hedge と frame が両方当たったら hedge として残す（devices は hedge が先に並んでいる）。
+ */
+const outermost = (devices: readonly Device[]): Device[] =>
+  devices.filter(
+    (device, index) =>
+      !devices.some((other, at) => at !== index && contains(other.range, device.range) && (!sameRange(other.range, device.range) || at < index)),
+  );
+
+/** 語の並びの、文書全体の座標での範囲。 */
+const spanOf = (tokens: readonly Token[], range: TokenRange): Span | undefined => {
+  const first = tokens[range.start];
+  const last = tokens[range.end - 1];
+  return first === undefined || last === undefined ? undefined : { start: first.span.start, end: last.span.end };
+};
+
+/** 句読点と等位接続詞（and、but、及び）は節を切る。別の節の逃げは、同じ主張を二重にぼかしていない。 */
+const CLAUSE_BREAK = new Set(["PUNCT", "CCONJ"]);
+
+/** 語ごとの、文の頭から数えた節の番号。 */
+const clauseOf = (tokens: readonly Token[]): number[] =>
+  tokens.reduce<number[]>((clauses, token) => [...clauses, (clauses.at(-1) ?? 0) + (CLAUSE_BREAK.has(token.pos) ? 1 : 0)], []);
+
+const PREDICATE = new Set(["VERB", "AUX"]);
+
+/** 見せる範囲。活用する語で終わる見出し（と考えられる）は、後ろの助動詞（ます）まで含めて書いたとおりに見せる。 */
+const shownEnd = (tokens: readonly Token[], range: TokenRange): number => {
+  const last = tokens[range.end - 1];
+  if (last === undefined || !PREDICATE.has(last.pos)) return range.end;
+  const stop = tokens.findIndex((token, at) => at >= range.end && token.pos !== "AUX");
+  return stop === -1 ? tokens.length : stop;
+};
+
+/** 書き手の言葉で、どこで成り立つかを言う語ではない見出し。引用（「」『』“” "）の中は話し手の言葉。 */
+const devicesIn = (sentence: Sentence, words: HedgeWords): Device[] => {
+  const tokens = sentence.tokens ?? [];
+  const quoted = quotedIn(sentence, QUOTATION_MARKS);
+  const scope = rangesOf(sentence, words.scope);
+  const hedges = rangesOf(sentence, words.hedges).filter((range) => !scope.some((outer) => contains(outer, range)));
+  const devices = [...hedges.map((range) => ({ range, hedge: true })), ...rangesOf(sentence, words.frames).map((range) => ({ range, hedge: false }))];
+  return outermost(devices).filter((device) => {
+    const span = spanOf(tokens, device.range);
+    return span !== undefined && !isWithinAny(quoted, span);
+  });
+};
+
+/** 1 つの節に 2 つ以上あり、そのうち 1 つ以上が逃げの表現そのもの。包む言い方だけ（「という状況です」）は逃げていない。 */
+const stackedClause = (devices: readonly Device[], clauses: readonly number[]): Device[] => {
+  const clauseAt = (device: Device): number => clauses[device.range.start] ?? 0;
+  const groups = [...new Set(devices.map(clauseAt))].map((clause) => devices.filter((device) => clauseAt(device) === clause));
+  return groups.find((group) => group.length >= STACKED_AT && group.some((device) => device.hedge)) ?? [];
+};
+
+/**
+ * 1 つの文の 1 つの節に、逃げの表現を重ねているか。business-blog-harness-spec §7.2。見せる範囲を文の中の順で返す。重ねていなければ空。
+ * 品詞が無ければ語の位置が分からないので何も言わない。
+ */
+export const stackedHedgeIn = (sentence: Sentence, words: HedgeWords): Span[] => {
+  const tokens = sentence.tokens ?? [];
+  return stackedClause(devicesIn(sentence, words), clauseOf(tokens))
+    .toSorted((left, right) => left.range.start - right.range.start)
+    .flatMap((device) => spanOf(tokens, { start: device.range.start, end: shownEnd(tokens, device.range) }) ?? []);
+};
+
+export const stackedHedges = (sentences: readonly Sentence[], words: HedgeWords): StackedHedge[] =>
+  sentences.flatMap((sentence) => {
+    const spans = stackedHedgeIn(sentence, words);
+    return spans.length === 0 ? [] : [{ sentence, spans }];
+  });

package/src/detectors/structure-tree.ts

@@ -17,11 +17,11 @@ const quoteAt = (source: string, offset: number): string => {
 };
 
 const findingsOf =
-  (rule: string, issuesOf: (tree: NonNullable<ProseDocument["structure"]>) => StructureIssue[]): Detector =>
+  (rule: string, issuesOf: (tree: NonNullable<ProseDocument["structure"]>, source: string) => StructureIssue[]): Detector =>
   (doc): Finding[] =>
     doc.structure === undefined
       ? []
-      : issuesOf(doc.structure).map((issue) => ({
+      : issuesOf(doc.structure, doc.source).map((issue) => ({
           rule,
           severity: "error",
           line: 0,