chaffjs 0.14.0 → 0.15.0

package/src/detectors/acronym-expansion.ts

@@ -9,7 +9,9 @@ import { escapeRegExp } from "../orthography.ts";
  *   Continuous Integration (CI)      括弧の中が略語
  *   Tax Cuts and Jobs Act [TCJA]     角括弧の中が略語で、直前の語の頭文字と揃う
  *   Relief Act (RA; P.L. 112-240)    括弧の最初の項目が略語で、直前の語か区切りの後の語の頭文字と揃う
+ *   （single nucleotide polymorphism：SNP）  括弧の最後の項目が略語で、コロンの前の語の頭文字と揃う
  *   人事部（以下「HR」という。）      括弧の中が定義の語と略語だけ
+ *   overnight reverse repurchase agreement (ON RRP)  括弧の中が空白で繋いだ略語だけで、前の名前から文字が順に拾える
  * 括弧と略語の間には、引用符（(“MNDA”)、（「MNDA」））と空白だけを許す。
  */
 const WRAP = String.raw`[\s"“”'‘’「」『』]*`;
@@ -20,7 +22,9 @@ const SQUARE_CLOSES = new RegExp(String.raw`^${WRAP}\]`, "u");
 const SQUARE_OPENED = new RegExp(String.raw`\[${WRAP}$`, "u");
 const ANY_OPENED = new RegExp(String.raw`[(（[]${WRAP}$`, "u");
 /** 括弧の最初の項目のあとの区切りと、括弧が閉じるまでの残り（(ARRA; P.L. 111-5)、（OP、Originator Profile））。 */
-const SEPARATED = new RegExp(String.raw`^${WRAP}[;；,，、](?<rest>[^()（）]*)`, "u");
+const SEPARATED = new RegExp(String.raw`^${WRAP}[;；,，、:：](?<rest>[^()（）]*)`, "u");
+/** 括弧の中の名前とコロンのあと、略語の直前まで（（single nucleotide polymorphism：SNP））。名前に区切りがあれば列挙なので外す。 */
+const NAMED_BEFORE = new RegExp(String.raw`[(（](?<name>[^()（）;；,，、:：]*)[:：]${WRAP}$`, "u");
 const QUOTES = /["“”'‘’「」『』]/gu;
 
 /** 括弧と略語の間の幅。空白は 1 つに畳んであるので、(“ MNDA ”) まで収まる。 */
@@ -36,7 +40,7 @@ const MARKER_GAP = String.raw`(?![A-Za-z])[\s、,]*`;
  * 角括弧は引用の印にも使う（[IANA]、[1]）。直前の語のうち大文字で始まる語の頭文字が
  * 略語と揃うときだけ展開と見なす。見る語は略語の文字数の 2 倍まで（and や of を挟むため）。
  */
-const lettersOf = (acronym: string): string => acronym.replaceAll("&", "");
+const lettersOf = (acronym: string): string => acronym.replaceAll(/[&-]/gu, "");
 
 const initialsOf = (words: readonly string[]): string =>
   words
@@ -54,6 +58,17 @@ const spellsOut = (before: string, acronym: string): boolean => {
   return initialsOf(words).endsWith(letters);
 };
 
+/**
+ * 括弧の中で略語と組になる名前の頭文字が、略語とちょうど揃うか。大文字で始まる語だけの頭文字（Data Retention and Reuse Act）か、
+ * すべての語の頭文字（single nucleotide polymorphism）で比べる。後者は大文字小文字を問わない。
+ */
+export const namesAcronym = (name: string, acronym: string): boolean => {
+  const words = name.replace(QUOTES, " ").trim().split(/\s+/u);
+  const letters = lettersOf(acronym);
+  const allInitials = words.map((word) => word.charAt(0)).join("");
+  return initialsOf(words) === letters || allInitials.toUpperCase() === letters.toUpperCase();
+};
+
 /**
  * 括弧の最初の項目が略語で、区切りのあとに注記が続く形（(ARRA; P.L. 111-5)、（OP、Originator Profile））。
  * 同じ形で列挙も書く（(MR, handbook, etc.)、(EPA, FDIC, GSA)）ので、直前の語か、区切りから括弧が閉じるまでの語の
@@ -66,7 +81,14 @@ const isSeparatedAt = (body: string, acronym: string, at: number): boolean => {
   const rest = separated.groups?.["rest"] ?? "";
   const end = at + acronym.length + separated[0].length;
   const closed = CLOSES.test(body.slice(end, end + NEAR));
-  return spellsOut(body.slice(0, at), acronym) || (closed && initialsOf(rest.replace(QUOTES, " ").trim().split(/\s+/u)) === lettersOf(acronym));
+  return spellsOut(body.slice(0, at), acronym) || (closed && namesAcronym(rest, acronym));
+};
+
+/** 括弧の最後の項目が略語で、コロンの前に名前を書く形（（Information-technology Promotion Agency：IPA））。 */
+const isNamedBeforeAt = (body: string, acronym: string, at: number): boolean => {
+  const named = NAMED_BEFORE.exec(body.slice(Math.max(0, at - DEFINITION_REACH), at));
+  if (named === null || !CLOSES.test(body.slice(at + acronym.length, at + acronym.length + NEAR))) return false;
+  return namesAcronym(named.groups?.["name"] ?? "", acronym);
 };
 
 /** 言語パッケージの語彙表から読む、括弧の中で略語の前に書く語（以下、hereinafter）と後ろに書く語（という）。 */
@@ -92,18 +114,63 @@ const isDefinedAt = (patterns: DefinitionPatterns, body: string, acronym: string
   return (opened.groups?.["markers"] ?? "") !== "" || (closes.groups?.["verb"] ?? "") !== "";
 };
 
+/** 空白 1 つで繋いだ略語の並びのうち、at の略語の前と後ろに続く分（(ON RRP) の ON の後ろの " RRP"）。 */
+const CAPITALS = "[A-Z][A-Z&-]*[A-Z]";
+const JOINT_BEFORE = new RegExp(String.raw`(?:(?<![A-Za-z0-9_&-])${CAPITALS} )+$`, "u");
+const JOINT_AFTER = new RegExp(String.raw`^(?: ${CAPITALS}(?![A-Za-z0-9_&-]))+`, "u");
+
+const LOWER_WORDS = /[a-z]+/gu;
+
+const isSubsequence = (letters: string, text: string): boolean =>
+  [...text].reduce((matched, char) => (char === letters.charAt(matched) ? matched + 1 : matched), 0) === letters.length;
+
+/**
+ * 略語の文字が、名前のどれかの語の頭から始まって、名前の文字の中に順に拾えるか。1 つの略語を空白で分けて書くときは、
+ * 語の頭文字ではなく語の途中の文字も使う（overnight reverse repurchase agreement → ON RRP）。見る語は略語の文字数の 2 倍まで。
+ */
+export const abbreviates = (name: string, acronym: string): boolean => {
+  const letters = acronym.toLowerCase().replaceAll(/[^a-z]/gu, "");
+  const words = (name.toLowerCase().match(LOWER_WORDS) ?? []).slice(-letters.length * 2);
+  return letters !== "" && words.some((word, index) => word.startsWith(letters.charAt(0)) && isSubsequence(letters, words.slice(index).join("")));
+};
+
+/**
+ * 括弧の中身が、空白で繋いだ略語の並びだけの形（(ON RRP)）。1 つの略語を 2 語以上で書いたもの。並びの文字が括弧の前の名前から
+ * 順に拾えるときだけ展開と見なす。拾えなければ、空白で並べた略語の列挙（(SEC FINRA)）。
+ * 括弧の外の並び（AWS KMS (Key Management Service)）は、括弧の直前の語だけが展開されるので、ここでは見ない。
+ */
+const isJointBracketedAt = (body: string, acronym: string, at: number): boolean => {
+  const end = at + acronym.length;
+  const before = JOINT_BEFORE.exec(body.slice(Math.max(0, at - DEFINITION_REACH), at))?.[0] ?? "";
+  const after = JOINT_AFTER.exec(body.slice(end, end + DEFINITION_REACH))?.[0] ?? "";
+  const start = at - before.length;
+  const close = end + after.length;
+  if (!OPENED.test(body.slice(Math.max(0, start - NEAR), start)) || !CLOSES.test(body.slice(close, close + NEAR))) return false;
+  return abbreviates(body.slice(0, start), body.slice(start, close));
+};
+
 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;
   if (SQUARE_OPENED.test(before) && SQUARE_CLOSES.test(after) && spellsOut(body.slice(0, at), acronym)) return true;
-  return isSeparatedAt(body, acronym, at);
+  return isSeparatedAt(body, acronym, at) || isNamedBeforeAt(body, acronym, at) || isJointBracketedAt(body, acronym, at);
 };
 
+/**
+ * 記号を = で定義する書き方（where N = number of cases, EH = total hours worked）。定義は記号の後ろの語。
+ * 値（EH = 2,000）、比べる・矢印（==、=>）、別の略語だけ（EH = SRE）は定義ではない。定義の語は小文字か、大小の無い文字を含む。
+ * 語の値（SRE = enabled）は 1 語の定義と見分けられないので、定義と読む。値を入れる大文字の名前は設定の名前で、展開するものが無い。
+ */
+const EQUALS_DEFINITION = /^\s*[=＝]\s*(?=\p{L})\S*?[\p{Ll}\p{Lo}]/u;
+
+const isEqualsDefinedAt = (body: string, acronym: string, at: number): boolean =>
+  EQUALS_DEFINITION.test(body.slice(at + acronym.length, at + acronym.length + DEFINITION_REACH));
+
 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);
+  return (body, acronym, at) => isBracketedAt(body, acronym, at) || isDefinedAt(patterns, body, acronym, at) || isEqualsDefinedAt(body, acronym, at);
 };

package/src/detectors/char-shape.ts

@@ -1,30 +1,58 @@
-import type { Detector, DocumentProfile, Finding, Sentence } from "../plugin.ts";
-import { compacted, placeOf } from "./gram-place.ts";
+import type { Detector, DocumentProfile, Finding, Sentence, Span, Token } from "../plugin.ts";
+import { compacted } from "./gram-place.ts";
+import { leadingCounter } from "./counter-edge.ts";
 import { maskAddresses } from "../address-chain.ts";
 import { isAddressRun } from "./place-run.ts";
+import { isOneName } from "./name-run.ts";
 import { proseText } from "../measure.ts";
 import { parallelDotCount } from "./middle-dot.ts";
 
 /**
- * 文字の並びを見る検出。漢字の連なりが住所かどうかだけは、形態素解析の地名と数で決める。
+ * 文字の並びを見る検出。漢字の連なりが住所か名前かだけは、形態素解析の固有名詞と数で決める。
  * 覆った箇所は空白になっているので、proseText で潰してから数える。
  */
 const KANJI_RUN = /[一-鿿]+/gu;
 
-/** 漢字の連なりが住所か（東京都港区新橋二丁目）。形態素解析の地名と数で決める。品詞が無ければ判定しない。 */
-const isPlaceName = (sentence: Sentence, run: string, topUnits: ReadonlySet<string>): boolean => {
-  const tokens = sentence.tokens;
-  const place = tokens === undefined ? undefined : placeOf(compacted(sentence.text, "word"), run);
-  if (tokens === undefined || place === undefined) return false;
-  const [start, end] = [sentence.span.start + place.start, sentence.span.start + place.end];
-  const covering = tokens.flatMap((token, index) => (token.span.start < end && start < token.span.end ? [index] : []));
-  return isAddressRun(tokens, covering, topUnits);
+/** 漢字の連なりと、その文書全体の座標での範囲。 */
+type KanjiRun = { readonly text: string; readonly span: Span | undefined };
+
+const SPACE = /\s/gu;
+
+/**
+ * 同じ連なりが文に二度出ても、それぞれの位置で読む。proseText は空白を詰めたり除いたりするだけなので、
+ * 空白でない k 文字目は元の文でも空白でない k 文字目。番地の覆いは長さを保つので、proseText の位置がそのまま使える。
+ */
+const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined): KanjiRun[] => {
+  const prose = proseText(sentence);
+  const printed = compacted(sentence.text, "char").offsets;
+  return [...maskAddresses(prose, profile).matchAll(KANJI_RUN)].map((match) => {
+    const before = prose.slice(0, match.index).replace(SPACE, "").length;
+    const [start, last] = [printed[before], printed[before + match[0].length - 1]];
+    const span = start === undefined || last === undefined ? undefined : { start: sentence.span.start + start, end: sentence.span.start + last + 1 };
+    return { text: match[0], span };
+  });
+};
+
+/** 漢字の連なりが住所（東京都港区新橋二丁目）か 1 つの名前（日本銀行）か。形態素解析の地名・人名・組織名と数で決める。 */
+const isPlaceName = (tokens: readonly Token[], span: Span, topUnits: ReadonlySet<string>): boolean => {
+  const covering = tokens.flatMap((token, index) => (token.span.start < span.end && span.start < token.span.end ? [index] : []));
+  return isAddressRun(tokens, covering, topUnits) || isOneName(tokens, covering);
+};
+
+/**
+ * 数えない連なりは空。頭の、数に付いた助数詞（2日日本弁護士連合会の「日」）は数えない。
+ * 住所か名前かは、助数詞を外した残りで決める（1日日本銀行の「日本銀行」）。品詞が無ければ判定しない。
+ */
+const measuredRun = (tokens: readonly Token[] | undefined, run: KanjiRun, topUnits: ReadonlySet<string>): string => {
+  if (tokens === undefined || run.span === undefined) return run.text;
+  const counter = leadingCounter(tokens, run.span.start, run.text);
+  const rest = counter === undefined ? run.span : { start: counter.span.end, end: run.span.end };
+  return isPlaceName(tokens, rest, topUnits) ? "" : run.text.slice(counter?.surface.length ?? 0);
 };
 
 const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined, topUnits: ReadonlySet<string>): string =>
-  [...maskAddresses(proseText(sentence), profile).matchAll(KANJI_RUN)]
-    .map((match) => match[0])
-    .filter((run) => !isPlaceName(sentence, run, topUnits))
+  runsOf(sentence, profile)
+    .map((run) => measuredRun(sentence.tokens, run, topUnits))
     .reduce((longest, run) => (run.length > longest.length ? run : longest), "");
 
 /**

package/src/detectors/citation-key.ts

@@ -0,0 +1,13 @@
+/**
+ * 仕様書が参考文献を指す角括弧の見出し語（[RFC9110]、[HPACK]、[SECURING-WEB]）。中身は文献一覧の見出しで、読み手はそこへ
+ * 飛ぶので、略語として展開を求めない。空白を含まない 1 語だけを見る。Markdown のリンク（[DRI](/url)、[DRI][ref]）と
+ * 参照の定義（[DRI]: /url）は括弧の後ろの記号で外し、その中の語は略語のまま数える。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+const CITATION_KEY = /(?<![\p{L}\p{N}_!\]])\[[A-Za-z][A-Za-z0-9.-]*[A-Za-z0-9]\](?![([:])/gu;
+
+/** 文の中の、参考文献の見出し語の範囲（括弧を含む）。 */
+export const citationKeySpans = (text: string): Span[] =>
+  [...text.matchAll(CITATION_KEY)].map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/detectors/cited-name.ts

@@ -0,0 +1,23 @@
+import type { StructureNode, Token } from "../plugin.ts";
+
+/** 他の文書を指す参照（民法第709条の第709条）の始まりの位置から、その文書の名前（民法）へ。 */
+export type CitedNames = ReadonlyMap<number, string>;
+
+const namedReferences = (node: StructureNode): (readonly [number, string])[] => {
+  const document = node.attrs["document"];
+  const own: (readonly [number, string])[] = node.kind === "reference" && typeof document === "string" ? [[node.span.start, document]] : [];
+  return [...own, ...node.children.flatMap(namedReferences)];
+};
+
+export const citedNamesOf = (structure: StructureNode | undefined): CitedNames => new Map(structure === undefined ? [] : namedReferences(structure));
+
+/** 略した名前は、頭の一字と種類の一字（所法・法法・措令）。二字の種類の語の重なり（規則規則）は略さない書き方。 */
+const ABBREVIATED_KIND_LENGTH = 1;
+
+/**
+ * 重なった二語が、番地のすぐ前に書いた文書の名前の全部で、頭の一字と種類の一字か。通達の「法法第64条」は法人税法の略で、
+ * 略した頭（法）と種類の語（法）がたまたま同じ字になる。名前の一部だけの重なり（就業規則規則第3条）や、種類の語でない語の
+ * 重なり（民法民法第709条）は書き損じのまま。
+ */
+export const endsCitedName = (first: Token, second: Token, cited: CitedNames, kinds: ReadonlySet<string>): boolean =>
+  kinds.has(second.surface) && [...second.surface].length === ABBREVIATED_KIND_LENGTH && cited.get(second.span.end) === `${first.surface}${second.surface}`;

package/src/detectors/concrete-evidence.ts

@@ -0,0 +1,31 @@
+import type { Span, StructureKind, StructureNode, Token } from "../plugin.ts";
+
+/**
+ * 形態素解析が数と読んだ語（UD の NumType=Card）。漢数字の「二割」「十五分」も、算用数字と同じ具体的な数。
+ * 言い回しの「二人三脚」「一人ひとり」は、辞書が一語として持つので数にならない。
+ */
+const isCardinal = (token: Token): boolean => token.features?.["NumType"] === "Card";
+
+const HYPHEN = /^[-‐‑]$/u;
+
+/** ハイフンで前の語に続く数（one-on-one の後ろの one）は、合成語の部品。 */
+const isCompoundPart = (token: Token, previous: Token | undefined): boolean =>
+  previous !== undefined && previous.span.end === token.span.start && HYPHEN.test(previous.surface);
+
+/** 数の語（UPOS の NUM）が、すぐ後ろの複数形の名詞を数えている（five minutes）。one of や two-way は量ではない。 */
+const countsPlural = (tokens: readonly Token[], index: number): boolean => {
+  const token = tokens[index];
+  return token?.pos === "NUM" && tokens[index + 1]?.features?.["Number"] === "Plur" && !isCompoundPart(token, tokens[index - 1]);
+};
+
+/** 品詞が無ければ何も言わない。数字そのものは呼ぶ側が文字で見る。 */
+export const hasNumeral = (tokens: readonly Token[]): boolean => tokens.some((token, index) => isCardinal(token) || countsPlural(tokens, index));
+
+/** 節の中で始まるものがある。節は見出しの直後から次の見出しの前まで。 */
+export const startsWithin = (section: Span, spans: readonly Span[]): boolean => spans.some((span) => span.start >= section.start && span.start < section.end);
+
+/** 構造の木が読んだ参照（第3条・Section VI）・数量・日付。どれも読み手が確かめに行ける具体物。 */
+const EVIDENCE: ReadonlySet<StructureKind> = new Set(["reference", "quantity", "date"]);
+
+export const evidenceSpans = (node: StructureNode | undefined): Span[] =>
+  node === undefined ? [] : [...(EVIDENCE.has(node.kind) ? [node.span] : []), ...node.children.flatMap((child) => evidenceSpans(child))];

package/src/detectors/counter-edge.ts

@@ -0,0 +1,29 @@
+import type { Token } from "../plugin.ts";
+
+const BLANK = /^\s+$/u;
+
+const isNumber = (token: Token | undefined): boolean => token?.features?.["NumType"] === "Card";
+const isCounter = (token: Token | undefined): boolean => token?.features?.["NounType"] === "Class";
+
+const touches = (left: Token, right: Token): boolean => left.span.end === right.span.start;
+
+/** at の語のすぐ前の語。空白一つを挟んでもよい（「2 日」）。 */
+const wordBefore = (tokens: readonly Token[], at: number): Token | undefined => {
+  const [previous, token] = [tokens[at - 1], tokens[at]];
+  if (previous === undefined || token === undefined || !touches(previous, token)) return undefined;
+  if (!BLANK.test(previous.surface)) return previous;
+  const beyond = tokens[at - 2];
+  return beyond !== undefined && touches(beyond, previous) ? beyond : undefined;
+};
+
+/**
+ * 漢字の連なり run（文書全体の座標で start から始まる）の頭が、直前の数に付いた助数詞（2日、第76回、24時間）なら、その助数詞の語。
+ * 数字が区切りを見せるので、助数詞は数と読まれ、後ろの複合語の一部ではない。そうでなければ undefined。
+ * 折り返しをまたぐ語（年\n度）は span が surface より長いので、連なりの残りは span の終わりから始まる。
+ */
+export const leadingCounter = (tokens: readonly Token[], start: number, run: string): Token | undefined => {
+  const at = tokens.findIndex((token) => token.span.start === start);
+  const counter = tokens[at];
+  if (counter === undefined || !isCounter(counter) || !isNumber(wordBefore(tokens, at))) return undefined;
+  return run.startsWith(counter.surface) ? counter : undefined;
+};

package/src/detectors/dotted-name.ts

@@ -0,0 +1,14 @@
+/**
+ * . で空白を挟まずに繋いだ語（GOV.UK、SAM.gov、README.md、ASP.NET）。ドメイン名やファイル名で、中の大文字は略語ではない。
+ * 文の終わりの . は後ろに空白か行末が来る（…by the IRS. Then）ので、ここには当たらない。空白を落とした文の境目
+ * （the IRS.Then、Mr.HAWLEY）は頭だけ大文字の部品で分かるので、部品は全部大文字か全部小文字（と数字）に限る。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+const LABEL = "(?:[A-Z0-9][A-Z0-9-]*|[a-z0-9][a-z0-9-]*)";
+const DOTTED_NAME = new RegExp(String.raw`(?<![A-Za-z0-9_&.-])${LABEL}(?:\.${LABEL})+(?![A-Za-z0-9_&])`, "gu");
+
+/** 文の中の、. で繋いだ名前の範囲。 */
+export const dottedNameSpans = (text: string): Span[] =>
+  [...text.matchAll(DOTTED_NAME)].map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/detectors/doubled-word.ts

@@ -1,4 +1,5 @@
 import type { Detector, Finding, Lexicon, Sentence, Token } from "../plugin.ts";
+import { citedNamesOf, endsCitedName } from "./cited-name.ts";
 
 /**
  * 語を書き損じて二度書いた（the the / 資料をを）。消し忘れと、書き換えの途中で残った語（our the platform）の二つ。
@@ -99,11 +100,22 @@ const repeatsPrevious = (tokens: readonly Token[], at: number): boolean => {
 /** 語彙表の重なり（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 の at 語目から、語彙表の決まった句（a priori・a la carte）が始まるか。句の頭の a は冠詞ではなく句の一部なので、
+ * 前の違う冠詞と並んでも（the a priori approach）書き損じではない。同じ語（a a priori）は書き損じのまま。
+ */
+export const opensPhrase = (tokens: readonly Token[], at: number, phrases: Lexicon): boolean =>
+  phrases.some((entry) => {
+    const words = entry.tokens ?? [];
+    return words.length > 1 && surfacesOf(tokens.slice(at, at + words.length)) === surfacesOf(words);
+  });
+
+export const doubledIn = (source: string, tokens: readonly Token[], spaced: boolean, allowed: Lexicon, phrases: 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 [];
+    if (!sameWord(first, second) && opensPhrase(tokens, index, phrases)) return [];
     return isNameBefore(first, second, opensSentence(tokens, index - 1)) ? [] : [{ first, second }];
   });
 
@@ -119,10 +131,21 @@ const findingOf = (sentence: Sentence, doubled: Doubled, spaced: boolean): Findi
   values: { word: wordOf(doubled, spaced), offset: doubled.second.span.start },
 });
 
+/** 文書の種類の語（法・規則・契約書）。語彙表はアダプタが持つ。 */
+const DOCUMENT_KIND = "document-kind";
+
+/** 冠詞のような語で始まる決まった句。語彙表はアダプタが持つ。冠詞の無い言語（日本語）は持たない。 */
+const FIXED_PHRASE = "fixed-phrase";
+
 export const doubledWord: Detector = (doc, options): Finding[] => {
   const spaced = doc.lengthUnit === "word";
   const allowed = options.lexicon ?? [];
+  const cited = citedNamesOf(doc.structure);
+  const kinds = new Set((doc.lexicons[DOCUMENT_KIND] ?? []).map((entry) => entry.pattern));
+  const phrases = doc.lexicons[FIXED_PHRASE] ?? [];
   return doc.sentences.flatMap((sentence) =>
-    doubledIn(doc.source, sentence.tokens ?? [], spaced, allowed).map((doubled) => findingOf(sentence, doubled, spaced)),
+    doubledIn(doc.source, sentence.tokens ?? [], spaced, allowed, phrases)
+      .filter((doubled) => !endsCitedName(doubled.first, doubled.second, cited, kinds))
+      .map((doubled) => findingOf(sentence, doubled, spaced)),
   );
 };

package/src/detectors/en-shape.ts

@@ -1,5 +1,6 @@
 import { lengthOf } from "../measure.ts";
 import { isClosed } from "../sentence-shape.ts";
+import { isTitleCase, minorityCase, pageTitleOf } from "./heading-case.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 
 const PER = 1000;
@@ -106,19 +107,6 @@ export const conjunctionRun: Detector = (doc, options): Finding[] => {
     });
 };
 
-const WORD = /[A-Za-z][A-Za-z'-]*/gu;
-
-/** 小さい語は Title Case でも小文字のままなので、大文字化の判定から外す。 */
-const MINOR = new Set(["a", "an", "the", "and", "or", "but", "of", "in", "on", "at", "to", "for", "with", "as", "by", "from", "is"]);
-
-const isTitleCase = (heading: string): boolean | undefined => {
-  const words = [...heading.matchAll(WORD)].map((match) => match[0]).filter((word) => !MINOR.has(word.toLowerCase()));
-  // 1 語の見出しは、どちらの流儀でも先頭が大文字になる。判定できない。
-  if (words.length < 2) return undefined;
-  const capitalized = words.filter((word) => word[0] === word[0]?.toUpperCase()).length;
-  return capitalized === words.length;
-};
-
 const headingsOf = (sections: readonly Section[]): { readonly section: Section; readonly title: boolean }[] =>
   sections.flatMap((section) => {
     const title = isTitleCase(section.heading);
@@ -127,25 +115,24 @@ const headingsOf = (sections: readonly Section[]): { readonly section: Section;
 
 /**
  * 見出しの大文字化が混ざっている。どちらの流儀が正しいかは決めない。spec §12.3。
- * 見るのは文書の中で揃っているかだけで、少数派のほうを指摘する。
+ * 見るのは文書の中で揃っているかだけで、少数派のほうを指摘する。題名は指摘しない（minorityCase）。
  */
 export const titleCaseMix: Detector = (doc, options): Finding[] => {
-  const judged = headingsOf(doc.sections);
-  const title = judged.filter((entry) => entry.title).length;
-  const minorityIsTitle = title <= judged.length - title;
-  const few = minorityIsTitle ? title : judged.length - title;
-  // 同数なら少数派は無い。どちらかを「他と違う」と呼ぶのは、選びかたが恣意的になる。
-  if (few === 0 || few * 2 === judged.length || few > options.limit) return [];
-  return judged
-    .filter((entry) => entry.title === minorityIsTitle)
-    .map(({ section }) => ({
-      rule: "title-case-consistency",
-      severity: "info",
-      line: 0,
-      column: 0,
-      quote: section.heading,
-      values: { count: few, limit: options.limit, offset: section.span.start },
-    }));
+  const pageTitle = pageTitleOf(doc.sections);
+  const judged = headingsOf(doc.sections.filter((section) => section !== pageTitle));
+  const titleCase = judged.filter((entry) => entry.title).length;
+  const pageTitleCase = pageTitle === undefined ? undefined : isTitleCase(pageTitle.heading);
+  const minorityIsTitle = minorityCase({ titleCase, sentenceCase: judged.length - titleCase }, pageTitleCase);
+  const few = minorityIsTitle === undefined ? [] : judged.filter((entry) => entry.title === minorityIsTitle);
+  if (few.length > options.limit) return [];
+  return few.map(({ section }) => ({
+    rule: "title-case-consistency",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: section.heading,
+    values: { count: few.length, limit: options.limit, offset: section.span.start },
+  }));
 };
 
 const LIST_CONJUNCTION = new Set(["and", "or"]);

package/src/detectors/gram-place.ts

@@ -1,3 +1,4 @@
+import { softBreaks } from "../soft-break.ts";
 import type { LengthUnit, Span } from "../plugin.ts";
 
 /** 数えるために詰めた文と、詰めた文の各文字が元の文のどこにあったか。 */
@@ -7,15 +8,21 @@ export type Compacted = { readonly text: string; readonly offsets: readonly numb
  * n-gram を数えるときと同じ詰め方。word 単位は空白の並びを 1 つにして前後を削り、char 単位は空白を全部除く。
  * 語句が元の文のどこにあるかを戻せるよう、残した文字ごとに元の位置を持つ。
  */
+/** spans が覆う位置（UTF-16 の単位）。 */
+const offsetsIn = (spans: readonly Span[]): Set<number> =>
+  new Set(spans.flatMap((span) => Array.from({ length: span.end - span.start }, (_, step) => span.start + step)));
+
 export const compacted = (text: string, unit: LengthUnit): Compacted => {
   const chars: string[] = [];
   const offsets: number[] = [];
   const state = { pendingSpace: -1, at: 0 };
+  // 読み手に見えない改行は空白 1 つにもしない。proseText がつないだ語句を、ここでも同じ形で探せるように。
+  const hidden = offsetsIn(unit === "word" ? softBreaks(text) : []);
   Array.from(text).forEach((char) => {
     const at = state.at;
     state.at += char.length;
     if (/\s/u.test(char)) {
-      if (unit === "word" && chars.length > 0 && state.pendingSpace === -1) state.pendingSpace = at;
+      if (unit === "word" && chars.length > 0 && state.pendingSpace === -1 && !hidden.has(at)) state.pendingSpace = at;
       return;
     }
     if (state.pendingSpace !== -1) {

package/src/detectors/gram-predicate.ts

@@ -0,0 +1,55 @@
+import { isNamePart } from "./name-part.ts";
+import type { LengthUnit, Span, Token } from "../plugin.ts";
+
+/** 動詞と助動詞。言い回し（ることができます、it is important to）にはこれが入り、主題の名前（state and local tax）には入らない。 */
+const PREDICATE_POS = new Set(["VERB", "AUX"]);
+
+const NOUNS = new Set(["NOUN", "PROPN", "ADJ"]);
+
+/** 中身を持たない語。名前の前後に付いても、名前の繰り返しを言い回しに変えない。 */
+const FUNCTION_POS = new Set(["ADP", "DET", "CCONJ", "SCONJ", "PART", "PUNCT", "SYM", "X"]);
+
+/**
+ * 英語で名詞のすぐ前の動詞は、名詞を飾る語（形容詞を挟んでも同じ）（the upcoming fiscal year、the Disclosing Party、the borrow checker）で、
+ * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、word 単位だけで見る。
+ */
+const modifiesNoun = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean =>
+  unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "");
+
+/** 英語で大文字の名前の一部になった動詞（Procedures Guide、the Location Object）も、述語ではない。 */
+const namePartAt = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean => unit === "word" && isNamePart(tokens, index);
+
+const isName = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean => {
+  const token = tokens[index];
+  return token !== undefined && (token.pos === "PROPN" || token.features?.["NameType"] !== undefined || namePartAt(tokens, index, unit));
+};
+
+const overlaps = (token: Token, window: Span): boolean => token.span.start < window.end && window.start < token.span.end;
+
+const isCut = (token: Token, window: Span): boolean => token.span.start < window.start || window.end < token.span.end;
+
+/**
+ * 窓が名前だけを繰り返しているか。predicate（添字）のほかに窓が触れる語が、名前と中身の無い語だけで、名前が 1 つはある。
+ * 窓の端で切れた動詞（"ed in the NSF Propos" の identified、"ed by Applicable Law" の prohibited）は語尾しか入っておらず、
+ * 動詞は出てくるたびに違ってよい。繰り返されているのは名前のほう。
+ */
+const onlyNamesBeside = (tokens: readonly Token[], predicate: number, window: Span, unit: LengthUnit): boolean => {
+  const touched = tokens.flatMap((token, index) => (index !== predicate && overlaps(token, window) ? [index] : []));
+  const names = touched.filter((index) => isName(tokens, index, unit));
+  const rest = touched.filter((index) => !isName(tokens, index, unit));
+  return names.length > 0 && rest.every((index) => FUNCTION_POS.has(tokens[index]?.pos ?? ""));
+};
+
+const countsAsPredicate = (tokens: readonly Token[], index: number, window: Span, unit: LengthUnit): boolean => {
+  const token = tokens[index];
+  if (token === undefined || !PREDICATE_POS.has(token.pos) || !overlaps(token, window)) return false;
+  if (modifiesNoun(tokens, index, unit) || namePartAt(tokens, index, unit)) return false;
+  return !isCut(token, window) || !onlyNamesBeside(tokens, index, window, unit);
+};
+
+/**
+ * 語句が文の中で占める範囲（window、文書の中の位置）に、述語になる動詞か助動詞があるか。
+ * 範囲で見る。文字で探すと、同じ文の別の所の動詞「use」が、語句の中の名詞「use」に当たる。
+ */
+export const hasPredicateIn = (tokens: readonly Token[], window: Span, unit: LengthUnit): boolean =>
+  tokens.some((_, index) => countsAsPredicate(tokens, index, window, unit));

package/src/detectors/heading-case.ts

@@ -0,0 +1,41 @@
+const WORD = /[A-Za-z][A-Za-z'-]*/gu;
+
+/** 小さい語は Title Case でも小文字のままなので、大文字化の判定から外す。 */
+const MINOR = new Set(["a", "an", "the", "and", "or", "but", "of", "in", "on", "at", "to", "for", "with", "as", "by", "from", "is"]);
+
+const TITLE_DEPTH = 1;
+
+/** 見出しが Title Case か。判定できなければ undefined。 */
+export const isTitleCase = (heading: string): boolean | undefined => {
+  const words = [...heading.matchAll(WORD)].map((match) => match[0]).filter((word) => !MINOR.has(word.toLowerCase()));
+  // 1 語の見出しは、どちらの流儀でも先頭が大文字になる。判定できない。
+  if (words.length < 2) return undefined;
+  const capitalized = words.filter((word) => word[0] === word[0]?.toUpperCase()).length;
+  return capitalized === words.length;
+};
+
+/**
+ * 文書の題名。最初の見出しが深さ 1 で、深さ 1 の見出しがほかに無いときの、その見出し。
+ * 深さ 1 が複数あると、最初のものが題名なのか章なのかを構造からは決められないので、題名とは呼ばない。
+ * 見出しより前の導入部（深さ 0）は見出しではないので数えない。
+ */
+export const pageTitleOf = <T extends { readonly depth: number }>(sections: readonly T[]): T | undefined => {
+  const headed = sections.filter((section) => section.depth > 0);
+  const first = headed[0];
+  if (first?.depth !== TITLE_DEPTH) return undefined;
+  return headed.filter((section) => section.depth === TITLE_DEPTH).length === 1 ? first : undefined;
+};
+
+export type CaseCounts = { readonly titleCase: number; readonly sentenceCase: number };
+
+/**
+ * 節の見出しのうち少数派の流儀（true なら Title Case）。少数派が無ければ undefined。
+ * 題名は数に入れない。題名は名前なので、節と流儀を分けるのはよくある揃えかた。
+ * 同数のときだけ題名の流儀で決める。題名と同じ流儀のほうが、書き手の選んだ流儀である見込みが高い。
+ */
+export const minorityCase = (sections: CaseCounts, pageTitleCase: boolean | undefined): boolean | undefined => {
+  if (sections.titleCase === sections.sentenceCase) return sections.titleCase === 0 || pageTitleCase === undefined ? undefined : !pageTitleCase;
+  const minorityIsTitle = sections.titleCase < sections.sentenceCase;
+  const few = minorityIsTitle ? sections.titleCase : sections.sentenceCase;
+  return few === 0 ? undefined : minorityIsTitle;
+};

package/src/detectors/heading-echo.ts

@@ -1,5 +1,6 @@
 import { lengthOf } from "../measure.ts";
 import { handsOver } from "./lead-in.ts";
+import { withoutQuotedVariants } from "./quoted-variant.ts";
 import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../plugin.ts";
 
 /** 見出しが短すぎると、偶然の一致で 100% になる。これ未満の見出しは見ない。 */
@@ -58,12 +59,15 @@ const leadsIn = (doc: ProseDocument, section: Section, phrases: readonly string[
   return first !== undefined && handsOver(first.text, doc.source.slice(first.span.end, section.span.end), phrases);
 };
 
+/** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
+const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", section.heading);
+
 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) }))
+    .map((section) => ({ section, overlap: Math.round(containment(trigrams(section.heading), trigrams(echoedText(section))) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)
     .map(({ section, overlap }) => ({
       rule: "heading-echo",