chaffjs 0.10.0 → 0.12.0

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,53 @@
+/**
+ * 大文字の語が略語ではなく、決まった書き方の一部として読める所（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 };
+
+const MERIDIEM = ["AM", "PM"];
+
+/** 業務文書で説明なしに書かれる時間帯。ここに無いもの（ACT など）は略語として数える。 */
+const TIME_ZONE = ["UTC", "GMT", "JST", "ET", "EST", "EDT", "CT", "CST", "CDT", "MT", "MST", "MDT", "PT", "PST", "PDT", "CET", "CEST"];
+
+/** ISO 4217 のうち、業務文書の読み手が説明なしで通じる主要な通貨。CAD は数の隣でも computer-aided design と読める（3 CAD files）ので入れない。 */
+const CURRENCY = ["USD", "EUR", "JPY", "GBP", "CNY", "CHF", "AUD", "KRW", "HKD", "SGD", "INR"];
+
+/** 米国の州・特別区・準州の郵便略号。住所の書き方（, CA 94720）の中でだけ見る。 */
+const US_STATE = [
+  ...["AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY"],
+  ...["LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND"],
+  ...["OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY"],
+  ...["DC", "PR", "GU", "VI", "AS", "MP"],
+];
+
+/**
+ * 略語として読む字面を持たない英語の機能語。単独の NOT や AND は強調で、展開するものが無い。
+ * OR（Oregon、operating room）や IS（International Standard）のように略語でもある語は入れない。
+ */
+const PLAIN_WORD = ["NOT", "AND"];
+
+const oneOf = (words: readonly string[]): string => `(?:${words.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 PATTERNS: readonly RegExp[] = [
+  new RegExp(String.raw`${CLOCK_12}\s*${oneOf(MERIDIEM)}`, "gu"),
+  new RegExp(String.raw`(?:${CLOCK_24}|${CLOCK_12}\s*${ANY_MERIDIEM})\s*${oneOf(TIME_ZONE)}`, "gu"),
+  new RegExp(String.raw`${oneOf(CURRENCY)}\s*[$€£¥]?${AMOUNT}`, "gu"),
+  new RegExp(String.raw`(?<![\w.,])${AMOUNT}\s*${oneOf(CURRENCY)}`, "gu"),
+  new RegExp(String.raw`,\s+${oneOf(US_STATE)}\s+\d{5}(?:-\d{4})?(?!\d)`, "gu"),
+  new RegExp(oneOf(PLAIN_WORD), "gu"),
+];
+
+/** 文の中で、略語として数えない大文字を含む範囲。略語は範囲にまるごと入るときだけ外れるので、語の境目は見なくてよい（NOTE の中の NOT）。 */
+export const notAcronymSpans = (text: string): Span[] =>
+  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,81 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 展開は略語の**すぐ隣**にあるときだけ認める。
+ * 60 文字も見ると、同じ文のどこかに括弧があるだけで「説明済み」になり、1 件も出なくなる。
+ *
+ * 認めるのは 4 つの形。どれも実際によく書かれる。
+ *   CI（継続的インテグレーション）   略語のあとに括弧
+ *   Continuous Integration (CI)      括弧の中が略語
+ *   Tax Cuts and Jobs Act [TCJA]     角括弧の中が略語で、直前の語の頭文字と揃う
+ *   人事部（以下「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");
+
+/** 括弧と略語の間の幅。空白は 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 spellsOut = (before: string, acronym: string): boolean => {
+  const letters = acronym.replaceAll("&", "");
+  const words = before
+    .replace(SQUARE_OPENED, "")
+    .trim()
+    .split(/\s+/u)
+    .slice(-letters.length * 2);
+  const initials = words.filter((word) => /^[A-Z]/u.test(word)).map((word) => word.charAt(0));
+  return initials.join("").endsWith(letters);
+};
+
+/** 言語パッケージの語彙表から読む、括弧の中で略語の前に書く語（以下、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;
+  return SQUARE_OPENED.test(before) && SQUARE_CLOSES.test(after) && spellsOut(body.slice(0, at), acronym);
+};
+
+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,15 +1,50 @@
-import type { Detector, DocumentProfile, Finding, Sentence } from "../plugin.ts";
+import type { Detector, DocumentProfile, Finding, Sentence, Token } from "../plugin.ts";
+import { compacted, placeOf } from "./gram-place.ts";
 import { maskAddresses } from "../address-chain.ts";
 import { proseText } from "../measure.ts";
 
 /**
- * 文字の並びだけを見る検出。品詞も語彙表も要らない。
+ * 文字の並びを見る検出。漢字の連なりが住所かどうかだけは、形態素解析の地名と数で決める。
  * 覆った箇所は空白になっているので、proseText で潰してから数える。
  */
 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 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));
+};
+
 const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined): string =>
-  [...maskAddresses(proseText(sentence), profile).matchAll(KANJI_RUN)].reduce((longest, match) => (match[0].length > longest.length ? match[0] : longest), "");
+  [...maskAddresses(proseText(sentence), profile).matchAll(KANJI_RUN)]
+    .map((match) => match[0])
+    .filter((run) => !isPlaceName(sentence, run))
+    .reduce((longest, run) => (run.length > longest.length ? run : longest), "");
 
 /**
  * 漢字が続くと、どこで語が切れるのか読み手が探すことになる。

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/en-shape.ts

@@ -150,6 +150,139 @@ export const titleCaseMix: Detector = (doc, options): Finding[] => {
 
 const LIST_CONJUNCTION = new Set(["and", "or"]);
 
+const isComma = (token: Token): boolean => token.surface === ",";
+
+const commaBefore = (tokens: readonly Token[], at: number): boolean => tokens[at - 1]?.surface === ",";
+
+/** 並列はこれをまたがない。セミコロンの前後は別の節。 */
+const CLAUSE_BREAK = new Set([";", ":", "—"]);
+
+/** 各 token の前で閉じていない括弧の数。括弧の中の読点（external users (e.g., guests), and ...）は外の並列を切らない。 */
+const PAREN_STEP: Readonly<Record<string, number>> = { "(": 1, ")": -1 };
+
+const depthsOf = (tokens: readonly Token[]): number[] =>
+  tokens.reduce<{ depths: number[]; open: number }>(
+    (acc, token) => ({ depths: [...acc.depths, acc.open], open: Math.max(0, acc.open + (PAREN_STEP[token.surface] ?? 0)) }),
+    { depths: [], open: 0 },
+  ).depths;
+
+type Clause = { readonly tokens: readonly Token[]; readonly depths: readonly number[] };
+
+/** 冠詞や引用符を飛ばした、項目の頭の品詞。the parser と an exporter と samples を同じ形と見る。 */
+const NOMINAL = new Set(["NOUN", "PROPN", "PRON", "NUM", "ADJ"]);
+
+const isContent = (token: Token): boolean => token.pos !== "DET" && token.pos !== "PUNCT" && token.pos !== "X";
+
+const shapeOf = (item: readonly Token[]): string | undefined => {
+  const head = item.find(isContent);
+  if (head === undefined) return undefined;
+  return NOMINAL.has(head.pos) ? "NOMINAL" : head.pos;
+};
+
+const VERBAL = new Set(["VERB", "AUX"]);
+
+/** 主語と述語のある項目。the team fixed the bug / these are crucial。gets us more は述語だけ。 */
+const isClause = (item: readonly Token[]): boolean => {
+  const first = item.find((token) => token.pos !== "PUNCT" && token.pos !== "X");
+  if (first === undefined || !(first.pos === "DET" || NOMINAL.has(first.pos))) return false;
+  return item.some((token) => token !== first && VERBAL.has(token.pos));
+};
+
+/** 節の頭から and / or の手前までを、同じ深さの読点で項目に切る。Oxford comma の読点のあとは空なので項目にならない。 */
+const itemsBefore = (clause: Clause, at: number): Token[][] => {
+  const level = clause.depths[at] ?? 0;
+  const start = clause.tokens.slice(0, at).findLastIndex((token) => CLAUSE_BREAK.has(token.surface)) + 1;
+  return clause.tokens
+    .slice(start, at)
+    .reduce<Token[][]>(
+      (items, token, offset) => {
+        if (isComma(token) && clause.depths[start + offset] === level) return [...items, []];
+        return [...items.slice(0, -1), [...(items.at(-1) ?? []), token]];
+      },
+      [[]],
+    )
+    .filter((item) => item.length > 0);
+};
+
+/** and / or の後ろの項目。次の読点か節の切れ目まで。 */
+const itemAfter = (tokens: readonly Token[], at: number): Token[] => {
+  const end = tokens.findIndex((token, index) => index > at && (isComma(token) || CLAUSE_BREAK.has(token.surface)));
+  return tokens.slice(at + 1, end === -1 ? undefined : end);
+};
+
+/**
+ * 導入の句（After the review, / If it fails, / Finally, / To test it, / Based on the review,）は並列の項目ではない。
+ * 節の最初の項目が前置詞・接続詞・副詞・to・過去分詞で始まり、次の項目と頭の形が違えば外す。
+ * Quickly, quietly and carefully は残る。For managers, engineers and designers, も外れるが、前置詞のあとの名詞を
+ * 項目と読むと、Over this period, the subcommittees and the full committee ... を並びと誤る。こちらのほうが多い。
+ */
+const LEAD_POS = new Set(["ADP", "SCONJ", "ADV", "PART"]);
+
+const isParticiple = (token: Token): boolean => token.features?.["VerbForm"] === "Part";
+
+const openingOf = (item: readonly Token[]): Token | undefined => item.find((token) => token.pos !== "PUNCT" && token.pos !== "X");
+
+const openingKind = (item: readonly Token[]): string | undefined => {
+  const opening = openingOf(item);
+  return opening !== undefined && isParticiple(opening) ? "PARTICIPLE" : shapeOf(item);
+};
+
+const withoutLead = (items: readonly Token[][]): readonly Token[][] => {
+  const [first, second] = items;
+  const opening = first === undefined ? undefined : openingOf(first);
+  if (first === undefined || second === undefined || opening === undefined) return items;
+  if (!LEAD_POS.has(opening.pos) && !isParticiple(opening)) return items;
+  return openingKind(first) === openingKind(second) ? items : items.slice(1);
+};
+
+/**
+ * 形容詞のあとの読点は、名詞の前で形容詞を重ねているだけのことが多い（the long, winding bridge）。
+ * 次の項目が名詞で終わるならつなげ直す。形容詞そのものの並び（quick, cheap and reliable）は切ったまま。
+ */
+const lastContent = (item: readonly Token[]): Token | undefined => item.findLast(isContent);
+
+const joinAdjectives = (items: readonly Token[][]): Token[][] =>
+  items.reduce<Token[][]>((joined, item) => {
+    const previous = joined.at(-1);
+    const stacked = previous !== undefined && lastContent(previous)?.pos === "ADJ" && lastContent(item)?.pos !== "ADJ";
+    return stacked ? [...joined.slice(0, -1), [...previous, ...item]] : [...joined, item];
+  }, []);
+
+/**
+ * 節を並べるなら、どの項目も節。Additionally, others can learn, and the mistake is rarer. の
+ * Additionally は項目ではなく、and の前の読点は節をつなぐ読点。名詞の並びは最初の項目に前置き
+ * （We shipped the parser）を抱えるので、この確かめは節の並びだけにする。
+ * and の後ろだけが節なのは主語の並び（The parser, the renderer and the exporter shipped.）なので外さない。
+ */
+const clausesAgree = (items: readonly Token[][], after: readonly Token[]): boolean => {
+  const last = items.at(-1);
+  if (last === undefined || !isClause(last)) return true;
+  return isClause(after) && items.every(isClause);
+};
+
+/**
+ * 動詞で始まる項目を並べるなら、どの項目にも動詞がある。The scope, in contrast, is larger, and covers ... の
+ * The scope は項目ではなく、後ろの述語の主語。
+ */
+const hasVerb = (item: readonly Token[]): boolean => item.some((token) => VERBAL.has(token.pos));
+
+const predicatesAgree = (items: readonly Token[][], shape: string): boolean => !VERBAL.has(shape) || items.every(hasVerb);
+
+/**
+ * 読点で区切った項目が and / or の前に 2 つ以上あり、最後の項目と and の後ろが同じ形のときだけ並列。
+ * 導入の読点（After the review, the team fixed the bug and shipped it.）や、節をつなぐ読点
+ * （We tested it, and the team shipped it.）は、Oxford comma を打つかどうかの選択を見せない。
+ */
+const listAt = (clause: Clause, at: number): boolean | undefined => {
+  const items = withoutLead(joinAdjectives(itemsBefore(clause, at)));
+  const after = itemAfter(clause.tokens, at);
+  const last = items.at(-1);
+  const shape = last === undefined ? undefined : shapeOf(last);
+  if (items.length < 2 || shape === undefined || shape !== shapeOf(after)) return undefined;
+  if (!clausesAgree(items, after) || !predicatesAgree(items, shape)) return undefined;
+  return commaBefore(clause.tokens, at);
+};
+
 /**
  * 3 つ以上の並列の最後の and / or の前に読点を打つか。Oxford comma。
  *
@@ -157,13 +290,11 @@ const LIST_CONJUNCTION = new Set(["and", "or"]);
  * 見るのは 1 つの文書で揃っているかだけ。spec §12.3。
  */
 const oxfordIn = (tokens: readonly Token[]): boolean | undefined => {
-  const at = tokens.findIndex((token) => LIST_CONJUNCTION.has(token.surface.toLowerCase()));
-  if (at < 1) return undefined;
-  const before = tokens.slice(0, at);
-  // 並列が 3 つ以上あるときだけ判定できる。読点が 1 つも無ければ 2 つの並列。
-  const commas = before.filter((token) => token.surface === ",").length;
-  if (commas === 0) return undefined;
-  return before.at(-1)?.surface === ",";
+  const clause = { tokens, depths: depthsOf(tokens) };
+  return tokens.reduce<boolean | undefined>(
+    (found, token, at) => found ?? (at > 0 && LIST_CONJUNCTION.has(token.surface.toLowerCase()) ? listAt(clause, at) : undefined),
+    undefined,
+  );
 };
 
 export const oxfordComma: Detector = (doc, options): Finding[] => {

package/src/detectors/gram-place.ts

@@ -0,0 +1,41 @@
+import type { LengthUnit, Span } from "../plugin.ts";
+
+/** 数えるために詰めた文と、詰めた文の各文字が元の文のどこにあったか。 */
+export type Compacted = { readonly text: string; readonly offsets: readonly number[] };
+
+/**
+ * n-gram を数えるときと同じ詰め方。word 単位は空白の並びを 1 つにして前後を削り、char 単位は空白を全部除く。
+ * 語句が元の文のどこにあるかを戻せるよう、残した文字ごとに元の位置を持つ。
+ */
+export const compacted = (text: string, unit: LengthUnit): Compacted => {
+  const chars: string[] = [];
+  const offsets: number[] = [];
+  const state = { pendingSpace: -1, at: 0 };
+  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;
+      return;
+    }
+    if (state.pendingSpace !== -1) {
+      chars.push(" ");
+      offsets.push(state.pendingSpace);
+      state.pendingSpace = -1;
+    }
+    chars.push(char);
+    // 位置は UTF-16 の単位で持つ。placeOf は indexOf の位置で引くので、絵文字（2 単位）には 2 つ置く。
+    Array.from({ length: char.length }, (_, unit) => offsets.push(at + unit));
+  });
+  return { text: chars.join(""), offsets };
+};
+
+/** 詰めた文の中の gram の最初の出現を、元の文の範囲に戻す。無ければ undefined。 */
+export const placeOf = (source: Compacted, gram: string): Span | undefined => {
+  const at = source.text.indexOf(gram);
+  if (at === -1) return undefined;
+  const start = source.offsets[at];
+  const last = source.offsets[at + gram.length - 1];
+  if (start === undefined || last === undefined) return undefined;
+  return { start, end: last + 1 };
+};

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,