chaffjs 0.11.0 → 0.13.0

package/rules/doubled-word.yaml

@@ -0,0 +1,27 @@
+id: doubled-word
+layer: L3
+status: experimental
+how_to_find: doubled-word
+word_list: doubled-word
+requires: [pos]
+severity: warning
+
+name:
+  ja: 語を二度書いている
+  en: Word written twice
+
+why:
+  ja: 「資料をを送ります」「確認確認する」のように同じ語が続くのは、消し忘れか、書き換えの途中で残った語です。読み手はつまずき、急いで書いた文書に見えます。同じ語でも品詞が違うものと、重ねて強める書き方（「そうそう」「一つ一つ」）は数えていません。
+  en: The same word twice in a row ("the the"), or two words where English takes one ("our the platform"), is left over from an edit. The reader stumbles, and the document looks rushed. Repeats that grammar allows ("had had", "that that", "is, is") and repeats for emphasis ("very very") are not counted.
+
+message:
+  ja: 「{word}」で語が重なっています。どちらかが余分です
+  en: '"{word}" doubles a word; one of the two is left over'
+
+how_to_fix:
+  ja: 余分なほうを消してください。書き換えの途中なら、残したい言い方に揃えてください。
+  en: Delete the extra word. If a rewrite was half done ("our the platform"), keep the wording you meant.
+
+levels: { strict: 1, normal: 1, relaxed: 1 }
+
+use_for: [blog, business, technical]

package/rules/latin-spacing.yaml

@@ -4,14 +4,16 @@ status: experimental
 how_to_find: latin-spacing
 languages: [ja]
 severity: warning
+# 番号・識別子として書かれた数を見分けるのに、数の後ろの語の品詞を使う。無ければ全部数える。
+uses: [pos]
 
 name:
   ja: 英数字の前後の空白がそろっていない
   en: Spacing around Latin text is inconsistent
 
 why:
-  ja: 日本語と英字・数字のあいだを空けるか詰めるかは、どちらでも読めます。困るのは一つの文書の中で混ざることで、読み手には違いに意味があるように見えます。chaff はどちらが正しいかを決めず、文書の中で少ないほうを指摘します。英字と、数字の前、数字の後ろは別々に数えます。「を 3回」のように、数字の前は空けて助数詞とは詰める書き方がふつうにあるからです。「3GBの」のように数字に続く単位は、英字ではなく数字の側として数えます。
-  en: Whether to put a space between Japanese and Latin letters or digits is a choice either way. What reads badly is mixing both in one document, which suggests the difference means something. chaff does not decide which is right; it points at whichever the document uses less. Letters, the space before a digit and the space after one are counted separately, since spacing before a number but not before its counter is common.
+  ja: 日本語と英字・数字のあいだを空けるか詰めるかは、どちらでも読めます。困るのは一つの文書の中で混ざることで、読み手には違いに意味があるように見えます。chaff はどちらが正しいかを決めず、文書の中で少ないほうを指摘します。英字と、数字の前、数字の後ろは別々に数えます。「を 3回」のように、数字の前は空けて助数詞とは詰める書き方がふつうにあるからです。「3GBの」のように数字に続く単位は、英字ではなく数字の側として数えます。逆に「H30 等」「EC2 で」「Phase 1 は」のように英字で始まって数字で終わる名前は、英字の側として数えます。「073-489-5909」「2026-06-02」のような番号は数量ではないので数えません。題や注の番号として書かれた数（「3.1 リサーチの原則」の節番号、※1 の注番号）と、0 で始まる組を含む番号（〒102-0094）も、後ろの空白が番号と題・項目の区切りなので数えません。
+  en: Whether to put a space between Japanese and Latin letters or digits is a choice either way. What reads badly is mixing both in one document, which suggests the difference means something. chaff does not decide which is right; it points at whichever the document uses less. Letters, the space before a digit and the space after one are counted separately, since spacing before a number but not before its counter is common. A unit after a number (3GB) counts with the number; a name that starts with a letter and ends in a digit (H30, EC2, Phase 1) counts with the letters. A code such as a phone number or a date (073-489-5909, 2026-06-02) is not a quantity and is not counted. Neither is a number written as the label of a title or a note (a section number such as 3.1 before its title, a note number after ※) or a code with a part starting with 0 (〒102-0094), since the space after it separates the label from its title or the next item.
 
 message:
   ja: "日本語と{kind}のあいだを{style}（この文書はふつう{usual}。{of} 箇所のうち {count} 箇所が違う）"

package/rules/max-kanji-continuous.yaml

@@ -4,6 +4,8 @@ status: experimental
 how_to_find: kanji-run
 # 品詞があれば、住所（地名と数だけでできた連なり）を数えない。無くても文字だけで動く。
 uses: [pos]
+# 住所の先頭にしか来ない単位（都道府県）。地名の後ろに付けば、割られた町名ではなく地名の並び。
+extra_word_lists: [prefecture-unit]
 languages: [ja]
 severity: warning
 

package/rules/undefined-acronym.yaml

@@ -2,6 +2,8 @@ id: undefined-acronym
 layer: L1
 status: experimental
 how_to_find: undefined-acronym
+word_list: common-acronym
+extra_word_lists: [definition-marker, definition-verb, meridiem, time-zone, currency-code, us-state-code, emphasis-word]
 severity: info
 
 name:

package/rules/unqualified-superlative.yaml

@@ -3,6 +3,7 @@ layer: L2
 status: experimental
 how_to_find: unqualified-superlative
 word_list: superlative
+extra_word_lists: [comparison-marker, superlative-scope]
 uses: [pos]
 severity: warning
 

package/src/date-stamp.ts

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

package/src/declared-lists.ts

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

package/src/detectors/acronym-context.ts

@@ -0,0 +1,50 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 大文字の語が略語ではなく、決まった書き方の一部として読める所（3:30 PM、1pm ET、USD 1,000、Kansas City, MO 64108）。
+ * どれも閉じた集合で、しかも隣の数字があるときだけ認める。PM（project manager）、CT、CA（certificate authority）は
+ * 数字の隣でなければ略語のまま数える。語は言語パッケージの語彙表から読み、書き方の組み立てだけをここに置く。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+/** 言語パッケージの語彙表から読む、数字の隣でだけ略語から外す語と、単独で強調として書かれる語。字面どおりに照らす。 */
+export type NotationWords = {
+  readonly meridiem: readonly string[];
+  readonly timeZones: readonly string[];
+  readonly currencies: readonly string[];
+  readonly usStates: readonly string[];
+  readonly emphasis: readonly string[];
+};
+
+// 空の語彙表は「その書き方が無い」。空の選択肢 (?:) は至る所で空文字に当たるので、何にも当たらない形にする。
+const oneOf = (words: readonly string[]): string => (words.length === 0 ? "(?!)" : `(?:${words.map(escapeRegExp).join("|")})`);
+
+const MINUTES = String.raw`:[0-5]\d`;
+const CLOCK_12 = String.raw`(?<![\d:.])(?:1[0-2]|0?[1-9])(?:${MINUTES})?`;
+const CLOCK_24 = String.raw`(?<![\d:.])(?:[01]?\d|2[0-3])${MINUTES}`;
+/** 時間帯の前の午前・午後は書き方を問わない（pm、p.m.、P.M.、PM）。 */
+const ANY_MERIDIEM = String.raw`[AaPp]\.?[Mm]\.?`;
+/** 桁区切りは 3 桁ずつ揃っているときだけ金額と読む。「item 1, USD」の 1, は金額ではない。 */
+const AMOUNT = String.raw`(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?`;
+
+// 強調の記号は空白に置き換えてある（**3:30** PM）ので、部品の間の空白は数を問わない。
+const patternsOf = (words: NotationWords): readonly RegExp[] => [
+  new RegExp(String.raw`${CLOCK_12}\s*${oneOf(words.meridiem)}`, "gu"),
+  new RegExp(String.raw`(?:${CLOCK_24}|${CLOCK_12}\s*${ANY_MERIDIEM})\s*${oneOf(words.timeZones)}`, "gu"),
+  new RegExp(String.raw`${oneOf(words.currencies)}\s*[$€£¥]?${AMOUNT}`, "gu"),
+  new RegExp(String.raw`(?<![\w.,])${AMOUNT}\s*${oneOf(words.currencies)}`, "gu"),
+  new RegExp(String.raw`,\s+${oneOf(words.usStates)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
+  new RegExp(oneOf(words.emphasis), "gu"),
+];
+
+export type NotAcronymSpans = (text: string) => Span[];
+
+/**
+ * 文の中で、略語として数えない大文字を含む範囲。語彙表から一度だけ組み立てて、文ごとに呼ぶ。
+ * 略語は範囲にまるごと入るときだけ外れるので、語の境目は見なくてよい（NOTE の中の NOT）。
+ */
+export const notAcronymSpansOf = (words: NotationWords): NotAcronymSpans => {
+  const patterns = patternsOf(words);
+  return (text) => patterns.flatMap((pattern) => [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length })));
+};

package/src/detectors/acronym-expansion.ts

@@ -0,0 +1,109 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 展開は略語の**すぐ隣**にあるときだけ認める。
+ * 60 文字も見ると、同じ文のどこかに括弧があるだけで「説明済み」になり、1 件も出なくなる。
+ *
+ * 認めるのは次の形。どれも実際によく書かれる。
+ *   CI（継続的インテグレーション）   略語のあとに括弧
+ *   Continuous Integration (CI)      括弧の中が略語
+ *   Tax Cuts and Jobs Act [TCJA]     角括弧の中が略語で、直前の語の頭文字と揃う
+ *   Relief Act (RA; P.L. 112-240)    括弧の最初の項目が略語で、直前の語か区切りの後の語の頭文字と揃う
+ *   人事部（以下「HR」という。）      括弧の中が定義の語と略語だけ
+ * 括弧と略語の間には、引用符（(“MNDA”)、（「MNDA」））と空白だけを許す。
+ */
+const WRAP = String.raw`[\s"“”'‘’「」『』]*`;
+const OPENS = new RegExp(String.raw`^${WRAP}[(（]`, "u");
+const CLOSES = new RegExp(String.raw`^${WRAP}[)）]`, "u");
+const OPENED = new RegExp(String.raw`[(（]${WRAP}$`, "u");
+const SQUARE_CLOSES = new RegExp(String.raw`^${WRAP}\]`, "u");
+const SQUARE_OPENED = new RegExp(String.raw`\[${WRAP}$`, "u");
+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 QUOTES = /["“”'‘’「」『』]/gu;
+
+/** 括弧と略語の間の幅。空白は 1 つに畳んであるので、(“ MNDA ”) まで収まる。 */
+const NEAR = 3;
+
+/** 定義の語を挟む形で、括弧から略語まで・略語から括弧までに見る幅。(hereinafter referred to as “SLA”) が収まる。 */
+const DEFINITION_REACH = 60;
+
+/** 定義の語どうし、定義の語と略語の間に来てよいもの（以下、HR）。英字が続けば語の途中（(theSLA)）。 */
+const MARKER_GAP = String.raw`(?![A-Za-z])[\s、,]*`;
+
+/**
+ * 角括弧は引用の印にも使う（[IANA]、[1]）。直前の語のうち大文字で始まる語の頭文字が
+ * 略語と揃うときだけ展開と見なす。見る語は略語の文字数の 2 倍まで（and や of を挟むため）。
+ */
+const lettersOf = (acronym: string): string => acronym.replaceAll("&", "");
+
+const initialsOf = (words: readonly string[]): string =>
+  words
+    .filter((word) => /^[A-Z]/u.test(word))
+    .map((word) => word.charAt(0))
+    .join("");
+
+const spellsOut = (before: string, acronym: string): boolean => {
+  const letters = lettersOf(acronym);
+  const words = before
+    .replace(ANY_OPENED, "")
+    .trim()
+    .split(/\s+/u)
+    .slice(-letters.length * 2);
+  return initialsOf(words).endsWith(letters);
+};
+
+/**
+ * 括弧の最初の項目が略語で、区切りのあとに注記が続く形（(ARRA; P.L. 111-5)、（OP、Originator Profile））。
+ * 同じ形で列挙も書く（(MR, handbook, etc.)、(EPA, FDIC, GSA)）ので、直前の語か、区切りから括弧が閉じるまでの語の
+ * 頭文字が略語と揃うときだけ展開と見なす。区切りの後ろは閉じた括弧の中だけを見て、頭文字がちょうど略語になることを求める。
+ */
+const isSeparatedAt = (body: string, acronym: string, at: number): boolean => {
+  if (!OPENED.test(body.slice(Math.max(0, at - NEAR), at))) return false;
+  const separated = SEPARATED.exec(body.slice(at + acronym.length, at + acronym.length + DEFINITION_REACH));
+  if (separated === null) return false;
+  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));
+};
+
+/** 言語パッケージの語彙表から読む、括弧の中で略語の前に書く語（以下、hereinafter）と後ろに書く語（という）。 */
+export type DefinitionWords = { readonly markers: readonly string[]; readonly verbs: readonly string[] };
+
+type DefinitionPatterns = { readonly opened: RegExp; readonly closes: RegExp };
+
+const oneOf = (words: readonly string[]): string => (words.length === 0 ? "(?!)" : words.map(escapeRegExp).join("|"));
+
+const definitionPatterns = (words: DefinitionWords): DefinitionPatterns => ({
+  opened: new RegExp(String.raw`[(（]\s*(?<markers>(?:(?:${oneOf(words.markers)})${MARKER_GAP})*)${WRAP}(?<![A-Za-z])$`, "iu"),
+  closes: new RegExp(String.raw`^${WRAP}(?<verb>(?:${oneOf(words.verbs)})[。.]?)?${WRAP}[)）]`, "iu"),
+});
+
+/**
+ * 括弧の中に定義の語と略語だけがある形。語が 1 つも無い（CI）は OPENED と CLOSES が見るので、ここでは数えない。
+ * 括弧の中身が語と略語で尽きることを求めるので、ふつうの意味の「以下」（（以下のSRE手順））は定義にならない。
+ */
+const isDefinedAt = (patterns: DefinitionPatterns, body: string, acronym: string, at: number): boolean => {
+  const opened = patterns.opened.exec(body.slice(Math.max(0, at - DEFINITION_REACH), at));
+  const closes = patterns.closes.exec(body.slice(at + acronym.length, at + acronym.length + DEFINITION_REACH));
+  if (opened === null || closes === null) return false;
+  return (opened.groups?.["markers"] ?? "") !== "" || (closes.groups?.["verb"] ?? "") !== "";
+};
+
+const isBracketedAt = (body: string, acronym: string, at: number): boolean => {
+  const after = body.slice(at + acronym.length, at + acronym.length + NEAR);
+  const before = body.slice(Math.max(0, at - NEAR), at);
+  if (OPENS.test(after) || (OPENED.test(before) && CLOSES.test(after))) return true;
+  if (SQUARE_OPENED.test(before) && SQUARE_CLOSES.test(after) && spellsOut(body.slice(0, at), acronym)) return true;
+  return isSeparatedAt(body, acronym, at);
+};
+
+export type ExpandedAt = (body: string, acronym: string, at: number) => boolean;
+
+/** body の at にある略語が、その場で展開・定義されているか。語彙表から一度だけ組み立てて、略語ごとに呼ぶ。 */
+export const expansionAt = (words: DefinitionWords): ExpandedAt => {
+  const patterns = definitionPatterns(words);
+  return (body, acronym, at) => isBracketedAt(body, acronym, at) || isDefinedAt(patterns, body, acronym, at);
+};

package/src/detectors/char-shape.ts

@@ -1,6 +1,7 @@
-import type { Detector, DocumentProfile, Finding, Sentence, Token } from "../plugin.ts";
+import type { Detector, DocumentProfile, Finding, Sentence } from "../plugin.ts";
 import { compacted, placeOf } from "./gram-place.ts";
 import { maskAddresses } from "../address-chain.ts";
+import { isAddressRun } from "./place-run.ts";
 import { proseText } from "../measure.ts";
 
 /**
@@ -9,50 +10,30 @@ import { proseText } from "../measure.ts";
  */
 const KANJI_RUN = /[一-鿿]+/gu;
 
-/** 地名（Geo）と、地名に付く単位（GeoUnit: 都・県・市・区・町）。 */
-const isGeoName = (token: Token | undefined): boolean => token?.features?.["NameType"] === "Geo";
-const isGeo = (token: Token | undefined): boolean => isGeoName(token) || token?.features?.["NameType"] === "GeoUnit";
-const isNumber = (token: Token | undefined): boolean => token?.features?.["NumType"] === "Card";
-
-/**
- * 住所の語: 地名と地名の単位（NameType=Geo / GeoUnit）、数（NumType=Card）、数のすぐ後ろの助数詞（丁目、NounType=Class）。
- * 辞書に無い町名（新橋）は、地名の後ろで数の前に来るときだけ住所の一部とする。
- */
-const isPlacePart = (tokens: readonly Token[], index: number): boolean =>
-  isGeo(tokens[index]) ||
-  isNumber(tokens[index]) ||
-  (isNumber(tokens[index - 1]) && tokens[index]?.features?.["NounType"] === "Class") ||
-  (isGeo(tokens[index - 1]) && isNumber(tokens[index + 1]));
-
-/**
- * 漢字の連なりが住所か（東京都港区新橋二丁目）。形態素解析が地名と読んだ語で始まり、住所の語だけでできている。
- * 住所は決まった形で、ひらがなを挟んで書けない。組織名（日本経済団体連合会）は地名の後ろに普通の語が続くので住所ではない。品詞が無ければ判定しない。
- */
-const isPlaceName = (sentence: Sentence, run: string): boolean => {
+/** 漢字の連なりが住所か（東京都港区新橋二丁目）。形態素解析の地名と数で決める。品詞が無ければ判定しない。 */
+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] : []));
-  const first = covering[0];
-  // 地名が単位を挟まずに続けば（東京大阪名古屋福岡）、住所ではなく地名の並び。
-  const listed = covering.some((index) => isGeoName(tokens[index]) && isGeoName(tokens[index + 1]));
-  return first !== undefined && isGeo(tokens[first]) && !listed && covering.every((index) => isPlacePart(tokens, index));
+  return isAddressRun(tokens, covering, topUnits);
 };
 
-const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined): string =>
+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))
+    .filter((run) => !isPlaceName(sentence, run, topUnits))
     .reduce((longest, run) => (run.length > longest.length ? run : longest), "");
 
 /**
  * 漢字が続くと、どこで語が切れるのか読み手が探すことになる。
  * 「情報処理推進機構認定試験」は 12 字。ひらがなを 1 つ挟むだけで読める。
  */
-export const kanjiRun: Detector = (doc, options): Finding[] =>
-  doc.sentences
-    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile) }))
+export const kanjiRun: Detector = (doc, options): Finding[] => {
+  const topUnits = new Set((doc.lexicons["prefecture-unit"] ?? []).map((entry) => entry.pattern));
+  return doc.sentences
+    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile, topUnits) }))
     .filter(({ run }) => run.length > options.limit)
     .map(({ sentence, run }) => ({
       rule: "max-kanji-continuous",
@@ -62,6 +43,7 @@ export const kanjiRun: Detector = (doc, options): Finding[] =>
       quote: sentence.text.trim(),
       values: { word: run, count: run.length, limit: options.limit, offset: sentence.span.start },
     }));
+};
 
 const MIDDLE_DOT = /・/gu;
 

package/src/detectors/doubled-word.ts

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

package/src/detectors/heading-echo.ts

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

package/src/detectors/index.ts

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

package/src/detectors/lead-in.ts

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

package/src/detectors/lexicon-match.ts

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