chaffjs 0.14.0 → 0.15.0

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/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,6 @@
-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 { isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { digitRunAround, isNumberName, sequenceLabelStarts } from "../number-name.ts";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
@@ -31,12 +32,18 @@ const digitBeside = (boundary: Boundary): number => {
 };
 
 /** 番号・識別子として書かれた数の境目は、空け方の好みではないので数えない（number-name.ts）。 */
-const isCounted = (sentence: Sentence, boundary: Boundary, sequence: ReadonlySet<number>): 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, sequence);
+  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 はそろっているかだけを見る。
@@ -44,11 +51,13 @@ const isCounted = (sentence: Sentence, boundary: Boundary, sequence: ReadonlySet
 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 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/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/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,11 @@ 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 { hasPredicateIn } from "./gram-predicate.ts";
+import type { Detector, Finding, ProseDocument, Section, Sentence } from "../plugin.ts";
 
 const PER = 1000;
 
@@ -98,29 +101,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[] => {
@@ -150,10 +139,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 +155,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,7 +188,7 @@ 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),
 ];
 
@@ -218,6 +219,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 +231,15 @@ 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）は略語ではないので、通じる略語と同じく展開を求めない。
+  const common = new Set([...(options.lexicon ?? []).map((entry) => entry.pattern), ...patternsOf(doc, "http-method")]);
   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 +270,16 @@ 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 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/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,

package/src/detectors/superlative-name.ts

@@ -0,0 +1,30 @@
+import type { Lexicon, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+
+/** 記号（最高!）は名詞と付いても語を作らない。 */
+const LETTER = /\p{L}/u;
+
+const joinsAsNoun = (previous: Token, token: Token | undefined): token is Token =>
+  token !== undefined && token.pos === "NOUN" && LETTER.test(token.surface) && previous.span.end === token.span.start;
+
+/** 空白も助詞も挟まずに続く名詞の連なり（最大|瞬間|風速）の最後の語。連なりが無ければ undefined。 */
+const lastJoined = (tokens: readonly Token[], at: number): Token | undefined => {
+  const previous = tokens[at - 1];
+  const token = tokens[at];
+  if (previous === undefined || !joinsAsNoun(previous, token)) return undefined;
+  return lastJoined(tokens, at + 1) ?? token;
+};
+
+const measures = (noun: Token, quantities: Lexicon): boolean => quantities.some((entry) => entry.pattern === noun.surface);
+
+/**
+ * 最上級の名詞がそのまま名詞と 1 語になり、その連なりが測る量の名詞で終わるか（最大風速・最高気温・最大値・最大駐車台数）。
+ * これは量の名前で、何かが一番だという主張ではない。「最大の効果」「最も速い」は助詞や用言を挟むので当たらない。
+ * ほかの名詞で終わる語（最高品質・最高精度・最大効果）は一番だという主張のまま。量の名詞は言語パッケージの語彙表が持つ。
+ */
+export const namesQuantity = (tokens: readonly Token[], range: TokenRange, quantities: Lexicon): boolean => {
+  const superlative = tokens[range.start];
+  const single = range.end - range.start === 1 && superlative?.pos === "NOUN";
+  const last = single ? lastJoined(tokens, range.end) : undefined;
+  return last !== undefined && measures(last, quantities);
+};

package/src/detectors/token-shape.ts

@@ -1,5 +1,6 @@
 import { hasParticle, isClosed, lastContent } from "../sentence-shape.ts";
-import type { Detector, Finding, Span, Token } from "../plugin.ts";
+import { isWithinAny, quotedSpans } from "../quoted-span.ts";
+import type { Detector, Finding, Sentence, Span, Token } from "../plugin.ts";
 
 /**
  * 文末が名詞で終わる（体言止め）。箇条書きでは普通だが、本文では文が途中で切れて読める。
@@ -57,17 +58,25 @@ const BREAK: Run = { surface: "", tokens: [] };
 /**
  * 名詞は連なりの中身なので飛ばす。読点と、語彙表に無い助詞は連なりを切る。
  * 「弊社のAはBの」を 2 回続いたと数えないため。「は」でいちど句が閉じている。
+ *
+ * 鉤括弧で引いたもの（括弧ごと）は、名詞と同じく連なりの中身として飛ばす。引いた題名（「食品中のウイルスの制御のための…ガイドライン」）や
+ * 発言は書き手が言い換えられないので、中の助詞は数えない。題名も名前なので、外の連なり（弊社の「新製品」の販売の計画）は続けて数える。
  */
-const runsOf = (tokens: readonly Token[], nesting: readonly string[]): Run[] =>
+const runsOf = (tokens: readonly Token[], nesting: readonly string[], quoted: readonly Span[]): Run[] =>
   tokens.reduce<Run[]>((acc, token) => {
+    if (isWithinAny(quoted, token.span)) return acc;
     if (nesting.includes(token.surface)) return extend(acc, token);
     return token.pos === "PUNCT" || PARTICLE.has(token.pos) ? [...acc, BREAK] : acc;
   }, []);
 
+/** 文の中の、鉤括弧で引いたものを括弧ごと、文書全体の座標で。 */
+const quotedIn = (sentence: Sentence): Span[] =>
+  quotedSpans(sentence.text).map((span) => ({ start: sentence.span.start + span.start - 1, end: sentence.span.start + span.end + 1 }));
+
 export const doubledParticle: Detector = (doc, options): Finding[] => {
   const nesting = (options.lexicon ?? []).map((entry) => entry.pattern);
   return doc.sentences.flatMap((sentence) =>
-    runsOf(sentence.tokens ?? [], nesting)
+    runsOf(sentence.tokens ?? [], nesting, quotedIn(sentence))
       .filter((run) => run.tokens.length > options.limit)
       .map((run) => ({
         rule: "no-doubled-joshi",

package/src/document.ts

@@ -6,6 +6,8 @@ import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
 import { atxHeadingText, headingText } from "./heading-text.ts";
 import { hasTitle } from "./heading-title.ts";
 import { maskSpans } from "./mask.ts";
+import { spansWithin, unmaskedSoftBreaks } from "./soft-break.ts";
+import { segmentJoined } from "./joined-view.ts";
 import { buildTree, type Outline } from "./structure/build.ts";
 import { isMarkdownPath } from "./structure/markdown-path.ts";
 import { pageFurniture, textOutline } from "./page-furniture.ts";
@@ -187,15 +189,17 @@ const spansOfType = (root: Node, type: string, keep: (node: Node) => boolean = (
  */
 const shift = (span: Span, by: number): Span => ({ start: by + span.start, end: by + span.end });
 
-const sentencesOf = (prose: string, paragraphs: readonly Span[], adapter: LanguageAdapter): Sentence[] =>
+const breaksWithin = (breaks: readonly Span[], paragraph: Span): Span[] => spansWithin(breaks, paragraph).map((span) => shift(span, -paragraph.start));
+
+const sentencesOf = (prose: string, paragraphs: readonly Span[], adapter: LanguageAdapter, softBreaks: readonly Span[]): Sentence[] =>
   paragraphs.flatMap((paragraph) =>
-    adapter
-      .segment(prose.slice(paragraph.start, paragraph.end))
-      .sentences.filter((sentence) => sentence.text.trim().length > 0)
+    segmentJoined(prose.slice(paragraph.start, paragraph.end), breaksWithin(softBreaks, paragraph), (text) => adapter.segment(text))
+      .filter((sentence) => sentence.text.trim().length > 0)
       .map((sentence) => ({
         span: shift(sentence.span, paragraph.start),
         text: sentence.text,
         ...(sentence.tokens === undefined ? {} : { tokens: sentence.tokens.map((token) => ({ ...token, span: shift(token.span, paragraph.start) })) }),
+        ...(sentence.wrapBreaks === undefined ? {} : { wrapBreaks: sentence.wrapBreaks.map((span) => shift(span, paragraph.start)) }),
       })),
   );
 
@@ -279,7 +283,9 @@ export const buildDocument = (
   // ページの案内は段落としても数えない。数えると、目次の行が「本題までの段落」に入る。
   const paragraphSpans = spansOfType(root, "paragraph", (node) => !isInPageNavigation(node, anchors));
   const listItems = spansOfType(root, "listItem");
-  const sentences = sentencesOf(prose, paragraphSpans, adapter);
+  // Markdown は段落を流し込んで表示するので、段落の中の改行は読み手に見えない。テキストの文書は行をそのまま見せる（法令は 1 行 1 号）。
+  const softBreaks = isMarkdownPath(path) ? unmaskedSoftBreaks(source, prose) : [];
+  const sentences = sentencesOf(prose, paragraphSpans, adapter, softBreaks);
   const lexicons = {
     ...adapter.lexicons,
     "internal-jargon": team.jargon.map((pattern) => ({ pattern })),
@@ -301,6 +307,7 @@ export const buildDocument = (
     listSpans: listItems,
     paragraphs: paragraphsOf(paragraphSpans, sentences, listItems),
     lists: listsOf(root, source, anchors),
+    links: [...spansOfType(root, "link"), ...spansOfType(root, "linkReference")],
     lexicons: tagged ? tokenizedLexicons(lexicons, adapter) : lexicons,
     requiredSections: team.requiredSections,
     // 構造の rule（参照先が無い・番号の抜け）が読む木。どの rule も読まなければ作らない。何万行の契約書で、他の rule の lint に代金を払わせない。

package/src/genre-check.ts

@@ -0,0 +1,46 @@
+import { frontMatterValues } from "./genre.ts";
+
+/** Where a genre was set: the command line, chaff.yaml's genre, or one of its by_path entries. */
+export type GenreSetting = "--genre" | "config" | "by_path";
+
+type UnknownGenre = {
+  readonly where: GenreSetting;
+  readonly genre: string;
+  /** The by_path entry's files, so the message can say which entry; empty elsewhere. */
+  readonly files: readonly string[];
+};
+
+type PathGenre = { readonly files: readonly string[]; readonly genre: string | undefined };
+
+type WrittenGenres = { readonly flag: string | undefined; readonly config: string | undefined; readonly byPath: readonly PathGenre[] };
+
+/** Commands that never read a genre from chaff.yaml. A wrong one there must not stop them: genres is how to find the right name. */
+const GENRE_FREE: ReadonlySet<string> = new Set(["init", "genres", "skill", "relax", "strict", "off", "tree", "cite"]);
+
+/** The genres a command would read: --genre always (every command refuses a wrong one), chaff.yaml's only where the command reads a genre. */
+export const writtenGenres = (
+  command: string,
+  flag: string | undefined,
+  config: { readonly genre: string | undefined; readonly byPath: readonly PathGenre[] },
+): WrittenGenres => (GENRE_FREE.has(command) ? { flag, config: undefined, byPath: [] } : { flag, config: config.genre, byPath: config.byPath });
+
+const setting = (where: GenreSetting, genre: string | undefined, files: readonly string[] = []): UnknownGenre[] =>
+  genre === undefined ? [] : [{ where, genre, files }];
+
+/**
+ * Every genre a setting names that chaff does not know: no rule's use_for matches one, so nothing would run and nothing be listed as not run.
+ * All of them, not only the one a file would use, because a wrong setting is wrong for every file.
+ */
+export const unknownGenres = (written: WrittenGenres, known: readonly string[]): UnknownGenre[] =>
+  [
+    ...setting("--genre", written.flag),
+    ...setting("config", written.config),
+    ...written.byPath.flatMap((entry) => setting("by_path", entry.genre, entry.files)),
+  ].filter((entry) => !known.includes(entry.genre));
+
+/**
+ * The front matter's genre that was not read. Front matter is the document's and often another tool's, so this warns and does not stop:
+ * the file falls back to the path, the content or the default. type is not looked at (Zenn's tech / idea mean something else).
+ */
+export const unknownFrontMatterGenre = (source: string, known: readonly string[]): string | undefined =>
+  frontMatterValues(source, "genre").find((value) => value !== "" && !known.includes(value));