chaffjs 0.15.0 → 0.17.0

package/src/detectors/signals.ts

@@ -1,12 +1,14 @@
 import { proseText } from "../measure.ts";
-import { wordsOf } from "./structure.ts";
+import { dateSpans, 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 { expansionAt, termEntryAcronyms, type ExpandedAt } from "./acronym-expansion.ts";
 import { isExplained } from "./acronym-compound.ts";
 import { conjugatedForms } from "./conjugated-form.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;
@@ -62,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);
   });
@@ -93,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;
 };
@@ -117,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 [];
@@ -194,13 +200,35 @@ const spansOf = (text: string, notation: NotAcronymSpans): Span[] => [
 
 type AcronymHit = { readonly word: string; readonly hit: Hit };
 
+/**
+ * 言語パッケージが、大文字で書いて強調した普通の語（will NEVER call）と読んだ語。辞書がその語を名前になり得ない品詞でしか
+ * 知らないときだけ、そう読む。品詞を持たない言語パッケージでは何も外れない。
+ */
+const isEmphasised = (sentence: Sentence, offset: number): boolean =>
+  (sentence.tokens ?? []).some((token) => token.span.start === offset && token.features?.["Emph"] === "Yes");
+
+/** チームが並べた名前の中の略語（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 } }));
+      .map((match) => ({ word: match[0], hit: { sentence, offset: sentence.span.start + match.index } }))
+      .filter(({ hit }) => !isEmphasised(hit.sentence, hit.offset));
+  });
+
+/** 略語ごとの、最初に現れた所。 */
+const firstHits = (hits: readonly AcronymHit[]): Map<string, Hit> => {
+  const seen = new Map<string, Hit>();
+  hits.forEach(({ word, hit }) => {
+    if (!seen.has(word)) seen.set(word, hit);
   });
+  return seen;
+};
+
+/** 日付の中の月（SEP 01, 2022）は略語ではない。 */
+const outsideDates = (hits: readonly AcronymHit[], dates: readonly Span[]): AcronymHit[] =>
+  hits.filter(({ hit }) => !dates.some((span) => span.start <= hit.offset && hit.offset < span.end));
 
 /**
  * どこか 1 か所で展開してあればよい。初出が節の見出し代わりの語（「5.3. DPA.」）で、
@@ -220,6 +248,7 @@ const notationOf = (doc: ProseDocument): NotAcronymSpans =>
     emphasis: patternsOf(doc, "emphasis-word"),
     divisions: patternsOf(doc, "numbered-division"),
     honorifics: patternsOf(doc, "honorific"),
+    titles: patternsOf(doc, "name-title"),
     dateTimeUnits: patternsOf(doc, "date-time-unit"),
   });
 
@@ -232,14 +261,16 @@ const definitionVerbsOf = (doc: ProseDocument): string[] => {
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
   // 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 (!seen.has(word)) seen.set(word, hit);
-  });
+  // 並べた名前（JAXA）も、繋いだ略語（JAXA-ISAS）の片割れとして説明済みに数える。
+  const common = new Set([...(options.lexicon ?? []).map((entry) => entry.pattern), ...patternsOf(doc, "http-method"), ...(doc.names ?? [])]);
   const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: definitionVerbsOf(doc) });
-  const explainedAlone = (word: string): boolean => common.has(word) || isExpanded(body, word, expandedAt);
-  const bare = [...seen.entries()].filter(([acronym]) => !isExplained(acronym, explainedAlone));
+  const entries = termEntryAcronyms(doc.source);
+  const explainedAlone = (word: string): boolean => common.has(word) || entries.has(word) || isExpanded(body, word, expandedAt);
+  const hits = acronymsOf(doc, notationOf(doc));
+  const unexplained = new Set([...firstHits(hits).keys()].filter((acronym) => !isExplained(acronym, explainedAlone)));
+  // 日付を読むには文書の木を作る。上限に届かない文書では作らない。
+  if (unexplained.size < options.limit) return [];
+  const bare = [...firstHits(outsideDates(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
   if (bare.length < options.limit) return [];
   return bare.map(([acronym, hit]) => ({
     rule: "undefined-acronym",
@@ -273,7 +304,8 @@ const openingOf = (sentence: Sentence | undefined, unit: ProseDocument["lengthUn
 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 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),
   );

package/src/detectors/stacked-hedge.ts

@@ -0,0 +1,96 @@
+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 つ目からは読み手が何を言い切ったのか分からなくなる。 */
+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.push((clauses.at(-1) ?? 0) + (CLAUSE_BREAK.has(token.pos) ? 1 : 0));
+    return clauses;
+  }, []);
+
+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。見せる範囲を文の中の順で返す。重ねていなければ空。
+ * 品詞が無ければ語の位置が分からないので何も言わない。
+ */
+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/stray-space.ts

@@ -0,0 +1,40 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { minorityStyle } from "../orthography.ts";
+import { isClosed } from "../sentence-shape.ts";
+import { phraseJoints, type Joint, type JointKind } from "../stray-space.ts";
+
+const KINDS: readonly JointKind[] = ["between-phrases", "inside-phrase"];
+
+type Quoted = Joint & { readonly quote: string };
+
+/**
+ * 空けたほうが少ないときだけ、その空白を指摘する。空けたほうが多い文書（文節ごとに空ける分かち書き）は、
+ * その書き方を選んでいるので何も言わない。詰めた境目を「空け忘れ」とは言わない。どこで空けるかは書き手が決める。
+ */
+const strays = (joints: readonly Quoted[]): readonly Quoted[] => (minorityStyle(joints) === true ? joints.filter((joint) => joint.spaced) : []);
+
+/**
+ * 日本語の語句の途中の空白（「こころさんが 払った」「確認 しました」）。句点で終わる文だけを見る。
+ * 句点の無い行（歌、名札と値、表のような行）の空白は区切りとして書かれている。
+ */
+export const straySpace: Detector = (doc, options): Finding[] => {
+  const joints: Quoted[] = doc.sentences
+    .filter(isClosed)
+    .flatMap((sentence) =>
+      phraseJoints(sentence, doc.source.slice(sentence.span.start, sentence.span.end)).map((joint) => ({ ...joint, quote: sentence.text.trim() })),
+    );
+  return KINDS.flatMap((kind) => {
+    const ofKind = joints.filter((joint) => joint.kind === kind);
+    const odd = strays(ofKind);
+    if (odd.length < options.limit) return [];
+    return odd.map((joint) => ({
+      rule: "",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: joint.quote,
+      variant: kind,
+      values: { before: joint.before, after: joint.after, count: odd.length, of: ofKind.length, limit: options.limit, offset: joint.offset },
+    }));
+  });
+};

package/src/detectors/structure.ts

@@ -3,6 +3,7 @@ import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section,
 import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { preambleParagraphs } from "../preamble-paragraphs.ts";
+import { isTooLongParagraph } from "../paragraph-length.ts";
 
 /**
  * ばらつきは変動係数（標準偏差 ÷ 平均）で測る。
@@ -41,7 +42,13 @@ const uniformity = (doc: ProseDocument, values: readonly number[], span: { start
 /** 1 段落に文を詰めすぎると、読み手はどこで息継ぎしていいか分からなくなる。 */
 export const paragraphLength: Detector = (doc, options): Finding[] =>
   doc.paragraphs
-    .filter((paragraph) => paragraph.sentences.length > options.limit)
+    .filter((paragraph) =>
+      isTooLongParagraph(
+        paragraph.sentences.map((sentence) => lengthOf(sentence, doc.lengthUnit)),
+        options.limit,
+        options.fullSentence,
+      ),
+    )
     .map((paragraph) => ({
       rule: "max-paragraph-length",
       severity: "warning",
@@ -93,7 +100,8 @@ export const ruleOfThree: Detector = (doc, options): Finding[] => {
   ];
 };
 
-const dateSpans = (doc: ProseDocument): Span[] =>
+/** 言語パッケージが日付と読んだ範囲（April 1, 2024、SEP 01, 2022）。木を作るので、要るときだけ呼ぶ。 */
+export const dateSpans = (doc: ProseDocument): Span[] =>
   doc.structure === undefined ? [] : inDocumentOrder(doc.structure).flatMap((node) => (node.kind === "date" ? [node.span] : []));
 
 /** 更新日の刻印（「最終更新日:」「2025年6月20日」）は前置きに数えない。木を作るのは、数えて上限を超えたときだけ。 */

package/src/detectors/superlative-amount.ts

@@ -0,0 +1,24 @@
+import type { Lexicon, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+
+/** 名詞の後ろにこれが続けば、その名詞は句の頭ではない。解析器は形容詞を名詞と読むことがある（the most frigid weather・the most cost-effective）。 */
+const JOINED = new Set(["NOUN", "PROPN", "ADJ", "X"]);
+
+const listed = (tokens: readonly Token[], range: TokenRange, amounts: Lexicon): boolean => {
+  const words = tokens
+    .slice(range.start, range.end)
+    .map((token) => token.surface.toLowerCase())
+    .join(" ");
+  return amounts.some((entry) => entry.pattern.toLowerCase() === words);
+};
+
+/**
+ * 量も言う最上級に、句の頭になる名詞がそのまま続くか（the most work・the most students・for the most part）。
+ * それは一番多いものを言っていて、何かが一番良いという主張ではない。形容詞を挟めば（the most powerful tool）主張のまま。
+ * どの最上級が量を言うかは言語パッケージの語彙表 superlative-amount が持つ。
+ */
+export const namesAmount = (tokens: readonly Token[], range: TokenRange, amounts: Lexicon): boolean => {
+  const noun = tokens[range.end];
+  const after = tokens[range.end + 1];
+  return listed(tokens, range, amounts) && noun?.pos === "NOUN" && (after === undefined || !JOINED.has(after.pos));
+};

package/src/detectors/superlative-clause.ts

@@ -0,0 +1,82 @@
+import type { Lexicon, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+import { PHRASE_END, PHRASE_START, phraseEnd } from "./superlative-scope.ts";
+
+/** 最上級の名詞句を後ろから限る語。どちらも言語パッケージの語彙表が持つ。 */
+export type Restrictors = {
+  /** 名詞の後ろで関係節を始める語（that・which）。空の言語は、名詞の後ろに節を置かない。 */
+  readonly relatives: Lexicon;
+  /** 最上級を手に入る範囲に限る形容詞（possible・available）。 */
+  readonly bounds: Lexicon;
+  /** 節の主語になる代名詞（we・they）。themselves のような再帰の代名詞は主語にならない。 */
+  readonly subjects: Lexicon;
+};
+
+const VERBAL = new Set(["VERB", "AUX"]);
+
+const isWord = (token: Token | undefined, words: Lexicon): boolean =>
+  token !== undefined && words.some((entry) => entry.pattern.toLowerCase() === token.surface.toLowerCase());
+
+const isVerbal = (token: Token | undefined): boolean => token !== undefined && VERBAL.has(token.pos);
+
+/** 節の主語（we・managers・the team・this）を読み飛ばした先に動詞があるか。主語の無い節（that has defined）は動詞で始まる。 */
+const verbAfterSubject = (tokens: readonly Token[], at: number, subjects: Lexicon): boolean => {
+  if (isVerbal(tokens[at])) return true;
+  if (isWord(tokens[at], subjects)) return isVerbal(tokens[at + 1]);
+  if (tokens[at]?.pos === "DET") return isVerbal(tokens[at + 1]) || isVerbal(tokens[phraseEnd(tokens, at + 1)]);
+  return isVerbal(tokens[phraseEnd(tokens, at)]);
+};
+
+const isArticle = (token: Token | undefined): boolean => token?.features?.["PronType"] === "Art";
+
+/**
+ * 関係詞を省いた節の主語は、代名詞（the best we have measured）か冠詞で始まる名詞句（the best option the team selected）。
+ * each・all のような限定詞（The best teams all adapt）や、冠詞の無い名詞（The best teams adapt）は節の始まりと読まない。
+ */
+const contactClause = (tokens: readonly Token[], at: number, subjects: Lexicon): boolean => {
+  if (isWord(tokens[at], subjects)) return isVerbal(tokens[at + 1]);
+  return isArticle(tokens[at]) && isVerbal(tokens[phraseEnd(tokens, at + 1)]);
+};
+
+/** 関係節（the threats that we have seen・the option which we chose）と、関係詞を省いた節。 */
+const clause = (tokens: readonly Token[], at: number, restrictors: Restrictors): boolean =>
+  isWord(tokens[at], restrictors.relatives) ? verbAfterSubject(tokens, at + 1, restrictors.subjects) : contactClause(tokens, at, restrictors.subjects);
+
+/** 分詞の後ろに文の動詞があるか。and を挟んだ動詞（The best option changed quickly and won）は分詞と並ぶ述語。 */
+const mainVerbFollows = (tokens: readonly Token[], at: number): boolean => {
+  const rest = tokens.slice(at + 1);
+  const verb = rest.findIndex(isVerbal);
+  return verb !== -1 && !rest.slice(0, verb).some((token) => token.pos === "CCONJ");
+};
+
+/**
+ * 名詞の後ろの過去分詞（the most scalable option discussed）。名詞句が動詞の目的語か補語で（We chose the best option discussed）、
+ * または分詞の後ろに文の動詞がある（The best results obtained were poor）ときだけ。目的語を取る分詞（The best solution
+ * proposed a fix）と、ほかに述語の無い分詞（The best option changed.）は文の動詞。
+ */
+const participle = (tokens: readonly Token[], range: TokenRange, at: number): boolean => {
+  const next = tokens[at + 1];
+  if (tokens[at]?.features?.["VerbForm"] !== "Part" || (next !== undefined && PHRASE_START.has(next.pos))) return false;
+  return isVerbal(tokens[range.start - 1]) || mainVerbFollows(tokens, at);
+};
+
+/** 最上級のすぐ後ろ（the best possible outcome）か、名詞句の後ろ（the best education possible）。 */
+const bounded = (tokens: readonly Token[], range: TokenRange, at: number, bounds: Lexicon): boolean =>
+  isWord(tokens[range.end], bounds) || isWord(tokens[at], bounds);
+
+/** 修飾の語は名詞の前に来るので、句の後ろで止まった分詞は名詞の後ろにある。 */
+const clauseOrParticiple = (tokens: readonly Token[], range: TokenRange, at: number, restrictors: Restrictors): boolean => {
+  const last = tokens[at - 1];
+  const endsPhrase = at === range.end || (last !== undefined && PHRASE_END.has(last.pos));
+  return (endsPhrase && clause(tokens, at, restrictors)) || participle(tokens, range, at);
+};
+
+/**
+ * 最上級の名詞句を後ろの節か分詞か形容詞が限っているか（the best we have measured・the most scalable option discussed・
+ * the best education possible）。何の中で最もなのかを言っているので、限定の無い最上級ではない。
+ * 名詞の後ろに節を置かない言語は関係詞の語彙表が空で、節も分詞も読まない。
+ */
+export const restricted = (tokens: readonly Token[], range: TokenRange, restrictors: Restrictors): boolean => {
+  const at = phraseEnd(tokens, range.end);
+  return bounded(tokens, range, at, restrictors.bounds) || (restrictors.relatives.length > 0 && clauseOrParticiple(tokens, range, at, restrictors));
+};

package/src/detectors/superlative-scope.ts

@@ -21,14 +21,14 @@ export const scopeMarkersOf = (lexicon: Lexicon): ScopeMarkers => ({
 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"]);
+export 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"]);
+export 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());
@@ -47,7 +47,7 @@ const namedBefore = (tokens: readonly Token[], range: TokenRange, markers: Lexic
   isMarker(tokens[range.start - 1], markers) && isNamed(tokens[range.start - 2]);
 
 /** 最上級に続く名詞句の終わり。名詞が出るまでは修飾を、出た後は名詞の連なりを読む。 */
-const phraseEnd = (tokens: readonly Token[], at: number, nounSeen = false): number => {
+export 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));

package/src/detectors/team.ts

@@ -1,7 +1,8 @@
 import { proseText } from "../measure.ts";
 import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
-import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
+import { nameSpans } from "../team-names.ts";
+import type { Detector, Finding, Sentence, Span, Token } from "../plugin.ts";
 
 /**
  * チームの言葉。社内でしか通じない語を、チームが chaff.yaml に自分で並べる。
@@ -76,8 +77,23 @@ const isProperNoun = (token: Token): boolean => token.pos === "PROPN";
  * spec は未知語率としていたが、**品詞解析があれば PROPN を数えるだけで足りる**。
  * 辞書を別に持つ必要はない。
  */
+const within = (spans: readonly Span[], token: Token): Span | undefined => spans.find((span) => token.span.start >= span.start && token.span.end <= span.end);
+
+/** 並べた名前は、何語に割れても 1 つの固有名詞（Bank of England は 2 つでなく 1 つ）。名前の中の 2 語目からを落とす。 */
+const properNounsOf = (sentence: Sentence, names: readonly string[]): Token[] => {
+  const named = nameSpans(sentence.text, names).map((span) => ({ start: sentence.span.start + span.start, end: sentence.span.start + span.end }));
+  const counted = new Set<Span>();
+  return (sentence.tokens ?? []).filter(isProperNoun).filter((token) => {
+    const name = within(named, token);
+    if (name === undefined) return true;
+    if (counted.has(name)) return false;
+    counted.add(name);
+    return true;
+  });
+};
+
 export const properNounDensity: Detector = (doc, options): Finding[] => {
-  const hits = doc.sentences.flatMap((sentence) => (sentence.tokens ?? []).filter(isProperNoun).map((token) => ({ sentence, token })));
+  const hits = doc.sentences.flatMap((sentence) => properNounsOf(sentence, doc.names ?? []).map((token) => ({ sentence, token })));
   const length = wordsOf(doc);
   const rate = length === 0 ? 0 : Math.round((hits.length / length) * PER);
   const first = hits[0];

package/src/detectors/token-shape.ts

@@ -1,6 +1,6 @@
 import { hasParticle, isClosed, lastContent } from "../sentence-shape.ts";
-import { isWithinAny, quotedSpans } from "../quoted-span.ts";
-import type { Detector, Finding, Sentence, Span, Token } from "../plugin.ts";
+import { isWithinAny, quotedIn } from "../quoted-span.ts";
+import type { Detector, Finding, Span, Token } from "../plugin.ts";
 
 /**
  * 文末が名詞で終わる（体言止め）。箇条書きでは普通だが、本文では文が途中で切れて読める。
@@ -45,10 +45,11 @@ export const nounEnding: Detector = (doc, options): Finding[] => {
  */
 type Run = { readonly surface: string; readonly tokens: readonly Token[] };
 
-const extend = (runs: readonly Run[], token: Token): Run[] => {
+const extend = (runs: Run[], token: Token): Run[] => {
   const last = runs.at(-1);
-  if (last !== undefined && last.surface === token.surface) return [...runs.slice(0, -1), { surface: last.surface, tokens: [...last.tokens, token] }];
-  return [...runs, { surface: token.surface, tokens: [token] }];
+  if (last !== undefined && last.surface === token.surface) runs[runs.length - 1] = { surface: last.surface, tokens: [...last.tokens, token] };
+  else runs.push({ surface: token.surface, tokens: [token] });
+  return runs;
 };
 
 const PARTICLE = new Set(["ADP", "SCONJ", "PART", "CCONJ"]);
@@ -66,13 +67,10 @@ const runsOf = (tokens: readonly Token[], nesting: readonly string[], quoted: re
   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;
+    if (token.pos === "PUNCT" || PARTICLE.has(token.pos)) acc.push(BREAK);
+    return 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) =>