chaffjs 0.2.0 → 0.4.0

package/src/detectors/repeated-head.ts

@@ -1,23 +1,34 @@
-import type { Detector, Finding, Sentence } from "../plugin.ts";
+import type { Detector, Finding, LengthUnit, Sentence } from "../plugin.ts";
 
 const HEAD_CHARS = 6;
+const HEAD_WORDS = 3;
 
-const headOf = (sentence: Sentence): string => sentence.text.trim().replace(/\s+/gu, "").slice(0, HEAD_CHARS);
+/**
+ * 書き出しの「同じさ」を測る単位は言語で違う。日本語は文字、英語は語。
+ * 文字で切ると "We continued" が "Wecont" になり、引用がそのまま読み手に出る。
+ */
+const headOf = (sentence: Sentence, unit: LengthUnit): string => {
+  const text = sentence.text.trim();
+  if (unit === "char") return text.replace(/\s+/gu, "").slice(0, HEAD_CHARS);
+  return text.split(/\s+/u).slice(0, HEAD_WORDS).join(" ");
+};
 
 type Run = { readonly head: string; readonly members: readonly Sentence[] };
 
-const runsOf = (sentences: readonly Sentence[]): Run[] =>
+const runsOf = (sentences: readonly Sentence[], unit: LengthUnit): Run[] =>
   sentences.reduce<Run[]>((acc, sentence) => {
-    const head = headOf(sentence);
+    const head = headOf(sentence, unit);
     const last = acc.at(-1);
-    if (last !== undefined && last.head === head && head.length === HEAD_CHARS) {
+    // 短すぎる書き出しは「同じ」と言えない。単位ぶん揃って初めて連なりと見る。
+    const full = unit === "char" ? head.length === HEAD_CHARS : head.split(" ").length === HEAD_WORDS;
+    if (last !== undefined && last.head === head && full) {
       return [...acc.slice(0, -1), { head, members: [...last.members, sentence] }];
     }
     return [...acc, { head, members: [sentence] }];
   }, []);
 
 export const repeatedHead: Detector = (doc, options): Finding[] =>
-  runsOf(doc.sentences)
+  runsOf(doc.sentences, doc.lengthUnit)
     .filter((run) => run.members.length > options.limit)
     .map((run) => ({
       rule: "repeated-sentence-head",

package/src/detectors/sentence-ending.ts

@@ -0,0 +1,37 @@
+import { hasPredicate, isClosed } from "../sentence-shape.ts";
+import type { Detector, Finding, Sentence } from "../plugin.ts";
+
+/**
+ * 文末の調子が混ざっているかを見る。日本語の「ですます / である」がこれ。
+ *
+ * どちらが正しいかは決めない。決めると、方針の違う書き手にそのまま無視される。
+ * 見るのは文書の中での一貫性だけで、少数派のほうを指摘する。spec §12.3 の方針を日本語にも。
+ */
+/**
+ * 述語を持たないものは文として数えない。見出しの下の `MaaSサービス` のような
+ * 名前だけの行がそのまま「である調」の少数派になり、実文書の誤検知はすべてこれだった。
+ */
+const isSentence = (sentence: Sentence): boolean => isClosed(sentence) && hasPredicate(sentence);
+
+const isPolite = (sentence: Sentence, polite: readonly string[]): boolean =>
+  (sentence.tokens ?? []).some((token) => polite.includes(token.lemma ?? token.surface));
+
+export const sentenceEnding: Detector = (doc, options): Finding[] => {
+  const polite = (options.lexicon ?? []).map((entry) => entry.pattern);
+  const judged = doc.sentences.filter(isSentence).map((sentence) => ({ sentence, polite: isPolite(sentence, polite) }));
+  const counts = { polite: judged.filter((entry) => entry.polite).length, plain: judged.length - judged.filter((entry) => entry.polite).length };
+  const minorityIsPolite = counts.polite <= counts.plain;
+  const few = minorityIsPolite ? counts.polite : counts.plain;
+  // 片方しか無ければ一貫している。少数派が閾値を超えて多ければ、混在ではなく別の文体。
+  if (few === 0 || few > options.limit) return [];
+  return judged
+    .filter((entry) => entry.polite === minorityIsPolite)
+    .map(({ sentence }) => ({
+      rule: "no-mixed-desumasu",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { count: few, limit: options.limit, offset: sentence.span.start },
+    }));
+};

package/src/detectors/signals.ts

@@ -0,0 +1,199 @@
+import { proseText } from "../measure.ts";
+import { wordsOf } from "./structure.ts";
+import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+
+const PER = 1000;
+
+/**
+ * これより短い文書では密度が暴れる。1 個で「1000 あたり 100」になる。
+ * 単位は言語で違うので、床も分ける。英語の 200 語と日本語の 200 文字では長さが桁で違う。
+ */
+const FLOOR = { word: 200, char: 500 };
+
+const bodyOf = (doc: ProseDocument): string => doc.sentences.map(proseText).join(" ");
+
+type Hit = { readonly sentence: Sentence; readonly offset: number };
+
+const findIn = (doc: ProseDocument, pattern: RegExp): Hit[] =>
+  doc.sentences.flatMap((sentence) => [...sentence.text.matchAll(pattern)].map((match) => ({ sentence, offset: sentence.span.start + (match.index ?? 0) })));
+
+const density = (doc: ProseDocument, count: number): number => {
+  const length = wordsOf(doc);
+  return length === 0 ? 0 : Math.round((count / length) * PER);
+};
+
+/**
+ * 絵文字と装飾記号。1 つなら親しみだが、並ぶと文字そのものが読めなくなる。
+ * 件数ではなく密度で見る。長い文書ほど当たるのを避けるため（bold-density と同じ）。
+ */
+const EMOJI = /\p{Extended_Pictographic}|[←-⇿☀-➿]/gu;
+
+export const emojiDensity: Detector = (doc, options): Finding[] => {
+  const hits = findIn(doc, EMOJI);
+  const first = hits[0];
+  const rate = density(doc, hits.length);
+  if (wordsOf(doc) < FLOOR[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
+  return [
+    {
+      rule: "emoji-density",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: first.sentence.text.trim(),
+      values: { count: hits.length, density: rate, limit: options.limit, offset: first.offset },
+    },
+  ];
+};
+
+/**
+ * 同じ言い回しの繰り返し。character n-gram で見るので、語の区切りが要らない。
+ * spec §10 が n-gram を選んだのはこのためで、新しい言語でそのまま動く。
+ */
+const GRAM = 8;
+
+/** 短い n-gram は偶然一致する。8 文字は「〜することができます」のような言い回しの長さ。 */
+const countGrams = (text: string): Map<string, number> => {
+  const counts = new Map<string, number>();
+  Array.from({ length: Math.max(0, text.length - GRAM + 1) }).forEach((_, index) => {
+    const gram = text.slice(index, index + GRAM);
+    counts.set(gram, (counts.get(gram) ?? 0) + 1);
+  });
+  return counts;
+};
+
+/**
+ * 名前ではなく言い回しだけを数える。実文書で測ったら、上位は
+ * 「AGENTS.m」「シンギュラリティ」のような固有名詞と識別子だった。名前は繰り返して当たり前。
+ *
+ * 言い回しは、その言語の「つなぎの материал」を含む。日本語ならひらがな、英語なら語の切れ目。
+ * どちらを見るかは adapter が宣言する単位で決める。ひらがなを持たない char 単位の言語が
+ * 来たら、この見分けは効かなくなる（そのときは adapter 側に判定を移す）。
+ */
+const CONNECTIVE = { char: /[ぁ-ゖ]/u, word: / /u };
+
+const isPhrasing = (gram: string, unit: ProseDocument["lengthUnit"]): boolean => CONNECTIVE[unit].test(gram);
+
+/** 文をまたいで数えない。文の終わりと次の文の始まりが繋がると、固有名詞が言い回しに見える。 */
+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).forEach((count, gram) => counts.set(gram, (counts.get(gram) ?? 0) + count));
+  });
+  return counts;
+};
+
+export const ngramRepetition: Detector = (doc, options): Finding[] => {
+  if (wordsOf(doc) < FLOOR[doc.lengthUnit]) return [];
+  const worst = [...gramsOf(doc).entries()]
+    .filter(([gram]) => isPhrasing(gram, doc.lengthUnit))
+    .reduce<{ gram: string; count: number }>((best, [gram, count]) => (count > best.count ? { gram, count } : best), { gram: "", count: 0 });
+  if (worst.count <= options.limit) return [];
+  const at = doc.sentences.find((sentence) => sentence.text.includes(worst.gram));
+  return [
+    {
+      rule: "ngram-repetition",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: at?.text.trim() ?? worst.gram,
+      values: { word: worst.gram, count: worst.count, limit: options.limit, offset: at?.span.start ?? 0 },
+    },
+  ];
+};
+
+/**
+ * 略語が初出で展開されているか。「CI」だけでは、読む人によって指すものが違う。
+ * 展開は「略語の直前か直後の括弧」か「括弧の中の略語」で書かれる。
+ */
+const ACRONYM = /\b[A-Z]{2,6}\b/gu;
+
+/** 読み手が説明なしで通じると見なしてよい語。展開すると逆に読みにくい。 */
+const COMMON = new Set([
+  "OK",
+  "NG",
+  "URL",
+  "API",
+  "CSS",
+  "HTML",
+  "JSON",
+  "YAML",
+  "HTTP",
+  "HTTPS",
+  "PDF",
+  "CPU",
+  "GPU",
+  "RAM",
+  "USB",
+  "AI",
+  "ID",
+  "FAQ",
+  "PR",
+  "OS",
+  "CLI",
+  "UI",
+  "UX",
+  "SQL",
+  "CSV",
+  "XML",
+  "TODO",
+  "NOTE",
+]);
+
+/**
+ * 展開は略語の**すぐ隣**にあるときだけ認める。
+ * 60 文字も見ると、同じ文のどこかに括弧があるだけで「説明済み」になり、1 件も出なくなる。
+ */
+const AFTER = /^\s*[(（]/u;
+const BEFORE = /[)）]\s*$/u;
+
+const isExpanded = (body: string, acronym: string): boolean => {
+  const at = body.indexOf(acronym);
+  if (at === -1) return false;
+  return AFTER.test(body.slice(at + acronym.length, at + acronym.length + 3)) || BEFORE.test(body.slice(Math.max(0, at - 3), at));
+};
+
+export const undefinedAcronym: Detector = (doc, options): Finding[] => {
+  const body = bodyOf(doc);
+  const seen = new Map<string, Hit>();
+  findIn(doc, ACRONYM).forEach((hit) => {
+    const text = /^[A-Z]{2,6}/u.exec(doc.source.slice(hit.offset, hit.offset + 6))?.[0] ?? "";
+    if (text.length > 0 && !COMMON.has(text) && !seen.has(text)) seen.set(text, hit);
+  });
+  const bare = [...seen.entries()].filter(([acronym]) => !isExpanded(body, acronym));
+  if (bare.length < options.limit) return [];
+  return bare.map(([acronym, hit]) => ({
+    rule: "undefined-acronym",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: hit.sentence.text.trim(),
+    values: { word: acronym, count: bare.length, limit: options.limit, offset: hit.offset },
+  }));
+};
+
+/**
+ * 具体物の密度。数値・コード・リンク・引用が 1 つも無い節は、
+ * 読み終えても何も持ち帰れない。**少ないほうを指摘する**ので、他の密度 rule と向きが逆。
+ */
+const CONCRETE = /\d|`|https?:\/\//u;
+
+export const concreteEvidence: Detector = (doc, options): Finding[] => {
+  const sections = doc.sections.filter((section) => section.sentences.length >= 3);
+  const empty = sections.filter((section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)));
+  if (empty.length < options.limit) return [];
+  return empty.map((section) => ({
+    rule: "concrete-evidence-density",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: section.heading.length > 0 ? section.heading : (section.sentences[0]?.text.trim() ?? ""),
+    values: {
+      word: section.heading.length > 0 ? section.heading : "この節",
+      count: empty.length,
+      total: sections.length,
+      limit: options.limit,
+      offset: section.span.start,
+    },
+  }));
+};

package/src/detectors/structure.ts

@@ -0,0 +1,119 @@
+import { charLength, lengthOf } from "../measure.ts";
+import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section } from "../plugin.ts";
+
+/**
+ * ばらつきは変動係数（標準偏差 ÷ 平均）で測る。
+ *
+ * 標準偏差そのものを見ると、長い文書ほど大きくなって閾値が効かない。
+ * 平均で割ると長さに依らなくなり、「揃いすぎ」と「ばらつきすぎ」を同じ尺度で言える。
+ */
+export const coefficientOfVariation = (values: readonly number[]): number | undefined => {
+  if (values.length < 2) return undefined;
+  const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
+  if (mean === 0) return undefined;
+  const variance = values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / values.length;
+  return Math.sqrt(variance) / mean;
+};
+
+/** 変動係数は 0..1 では読めないので、パーセントの整数にして閾値と突き合わせる。 */
+const PERCENT = 100;
+
+const asPercent = (value: number): number => Math.round(value * PERCENT);
+
+const uniformity = (doc: ProseDocument, values: readonly number[], span: { start: number }, limit: number, rule: string): Finding[] => {
+  const cv = coefficientOfVariation(values);
+  if (cv === undefined || asPercent(cv) >= limit) return [];
+  return [
+    {
+      rule,
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: doc.source.slice(span.start, span.start + 80).trim(),
+      values: { count: values.length, variance: asPercent(cv), limit, offset: span.start },
+    },
+  ];
+};
+
+/** 1 段落に文を詰めすぎると、読み手はどこで息継ぎしていいか分からなくなる。 */
+export const paragraphLength: Detector = (doc, options): Finding[] =>
+  doc.paragraphs
+    .filter((paragraph) => paragraph.sentences.length > options.limit)
+    .map((paragraph) => ({
+      rule: "max-paragraph-length",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: doc.source.slice(paragraph.span.start, paragraph.span.start + 80).trim(),
+      values: { count: paragraph.sentences.length, limit: options.limit, offset: paragraph.span.start },
+    }));
+
+const charsOf = (paragraph: Paragraph): number => paragraph.sentences.reduce((sum, sentence) => sum + charLength(sentence), 0);
+
+/** 段落の長さが揃いすぎている。人が書くと、言いたいことの重さで段落の長さは揺れる。 */
+export const paragraphVariance: Detector = (doc, options): Finding[] => {
+  const lengths = doc.paragraphs.map(charsOf).filter((length) => length > 0);
+  const first = doc.paragraphs[0];
+  return first === undefined ? [] : uniformity(doc, lengths, first.span, options.limit, "paragraph-length-variance");
+};
+
+const sectionChars = (section: Section): number => section.sentences.reduce((sum, sentence) => sum + charLength(sentence), 0);
+
+/** 節の長さが揃いすぎている。見出しごとに機械的に埋めた文書で起きる。 */
+export const sectionUniformity: Detector = (doc, options): Finding[] => {
+  const lengths = doc.sections.map(sectionChars).filter((length) => length > 0);
+  const first = doc.sections[0];
+  return first === undefined ? [] : uniformity(doc, lengths, first.span, options.limit, "section-length-uniformity");
+};
+
+/**
+ * 3 項目の箇条書きばかりになっている。
+ * 3 つ並べると収まりがよいので、言いたいことが 2 つでも 4 つでも 3 つにされる。
+ */
+const isThree = (list: BulletList): boolean => list.items.length === 3;
+
+export const ruleOfThree: Detector = (doc, options): Finding[] => {
+  const lists = doc.lists;
+  const threes = lists.filter(isThree);
+  const share = lists.length === 0 ? 0 : Math.round((threes.length / lists.length) * PERCENT);
+  const first = threes[0];
+  if (lists.length < 3 || first === undefined || share <= options.limit) return [];
+  return [
+    {
+      rule: "rule-of-three",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: doc.source.slice(first.span.start, first.span.start + 80).trim(),
+      values: { count: threes.length, total: lists.length, share, limit: options.limit, offset: first.span.start },
+    },
+  ];
+};
+
+/**
+ * 本題に入るまでが長い。業務文書では、読み手は結論を探しに来ている。
+ *
+ * 「本題」は最初の中見出し（深さ 2 以上）とする。表題（深さ 1）の直後から数えると、
+ * 表題しか無い文書で全文が前置きになる。中見出しが無い文書では何も言わない。
+ */
+export const preambleLength: Detector = (doc, options): Finding[] => {
+  const body = doc.sections.find((section) => section.depth >= 2);
+  if (body === undefined) return [];
+  const before = doc.paragraphs.filter((paragraph) => paragraph.span.start < body.span.start);
+  if (before.length <= options.limit) return [];
+  const first = before[0];
+  return first === undefined
+    ? []
+    : [
+        {
+          rule: "preamble-length",
+          severity: "info",
+          line: 0,
+          column: 0,
+          quote: doc.source.slice(first.span.start, first.span.start + 80).trim(),
+          values: { count: before.length, limit: options.limit, offset: first.span.start },
+        },
+      ];
+};
+
+export const wordsOf = (doc: ProseDocument): number => doc.sentences.reduce((sum, sentence) => sum + lengthOf(sentence, doc.lengthUnit), 0);

package/src/detectors/team.ts

@@ -0,0 +1,90 @@
+import { proseText } from "../measure.ts";
+import { wordsOf } from "./structure.ts";
+import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
+
+/**
+ * チームの言葉。社内でしか通じない語を、チームが chaff.yaml に自分で並べる。
+ *
+ * 何が社内用語かは組織ごとに違うので、chaff は語を持たない。並べる場所だけを用意する。
+ * 語彙表が空なら何も言わない（「用語を登録してください」とも言わない。押しつけない）。
+ */
+/**
+ * 表層でも原形でも当てる。利用者は辞書形で書く（「握る」）が、本文は活用している（「握った」）。
+ * 品詞解析があれば原形で当たり、無くても表層で当たる。要求はしない。
+ */
+const matches = (sentence: Sentence, word: string): boolean => sentence.text.includes(word) || (sentence.tokens ?? []).some((token) => token.lemma === word);
+
+export const internalJargon: Detector = (doc, options): Finding[] => {
+  const words = (options.lexicon ?? []).map((entry) => entry.pattern);
+  if (words.length === 0) return [];
+  const hits = doc.sentences.flatMap((sentence) => {
+    const matched = words.find((word) => matches(sentence, word));
+    return matched === undefined ? [] : [{ sentence, matched }];
+  });
+  if (hits.length < options.limit) return [];
+  return hits.map((hit) => ({
+    rule: "internal-jargon",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: hit.sentence.text.trim(),
+    values: { matched: hit.matched, count: hits.length, limit: options.limit, offset: hit.sentence.span.start },
+  }));
+};
+
+const has = (headings: readonly string[], wanted: string): boolean => headings.some((heading) => heading.includes(wanted));
+
+/**
+ * この種類の文書に無いと困る見出し。チームが chaff.yaml で決める。
+ *
+ * 「提案書にはリスクの節がある」のような取り決めは、組織ごとに違う。
+ * chaff は必須の見出しを持たず、**書かれた取り決めを守れているかだけ**を見る。
+ */
+export const requiredSections: Detector = (doc, options): Finding[] => {
+  const wanted = doc.requiredSections;
+  if (wanted.length === 0) return [];
+  const headings = doc.sections.map((section) => section.heading);
+  const missing = wanted.filter((name) => !has(headings, name));
+  if (missing.length < options.limit) return [];
+  return [
+    {
+      rule: "required-sections",
+      severity: "error",
+      line: 0,
+      column: 0,
+      quote: headings.filter((heading) => heading.length > 0).join(" / "),
+      values: { word: missing.join("、"), count: missing.length, limit: options.limit, offset: 0 },
+    },
+  ];
+};
+
+const PER = 1000;
+
+/** 密度を見る rule は短い文書を測らない。単位は言語で違うので床も分ける。 */
+const FLOOR = { word: 200, char: 500 };
+
+const isProperNoun = (token: Token): boolean => token.pos === "PROPN";
+
+/**
+ * 固有名詞の密度。製品名・社名・人名が続くと、知らない読者は文の骨組みを見失う。
+ *
+ * spec は未知語率としていたが、**品詞解析があれば PROPN を数えるだけで足りる**。
+ * 辞書を別に持つ必要はない。
+ */
+export const properNounDensity: Detector = (doc, options): Finding[] => {
+  const hits = doc.sentences.flatMap((sentence) => (sentence.tokens ?? []).filter(isProperNoun).map((token) => ({ sentence, token })));
+  const length = wordsOf(doc);
+  const rate = length === 0 ? 0 : Math.round((hits.length / length) * PER);
+  const first = hits[0];
+  if (length < FLOOR[doc.lengthUnit] || first === undefined || rate <= options.limit) return [];
+  return [
+    {
+      rule: "proper-noun-density",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: proseText(first.sentence),
+      values: { count: hits.length, density: rate, limit: options.limit, offset: first.token.span.start },
+    },
+  ];
+};

package/src/detectors/token-shape.ts

@@ -0,0 +1,81 @@
+import { hasParticle, isClosed, lastContent } from "../sentence-shape.ts";
+import type { Detector, Finding, Span, Token } from "../plugin.ts";
+
+/**
+ * 文末が名詞で終わる（体言止め）。箇条書きでは普通だが、本文では文が途中で切れて読める。
+ * 実文書で測ったら、指摘の 9 割が箇条書きの項目だった。箇条書きは除く。
+ */
+const NOMINAL = new Set(["NOUN", "PROPN"]);
+
+/** 非自立名詞は単独では何も指さない。「回るのか。」の「の」を体言止めと読まない。 */
+const isDependent = (token: Token): boolean => token.features?.["NounType"] === "Dependent";
+
+const inside = (span: Span, spans: readonly Span[]): boolean => spans.some((other) => span.start >= other.start && span.start < other.end);
+
+export const nounEnding: Detector = (doc, options): Finding[] => {
+  const ended = doc.sentences.filter((sentence) => {
+    if (inside(sentence.span, doc.listSpans) || !isClosed(sentence) || !hasParticle(sentence)) return false;
+    const last = lastContent(sentence);
+    return last !== undefined && NOMINAL.has(last.pos) && !isDependent(last);
+  });
+  const first = ended[0];
+  // 文書全体の数についての指摘なので、1 文ずつ出さない。13 件並べても直す順番が分からない。
+  if (first === undefined || ended.length <= options.limit) return [];
+  return [
+    {
+      rule: "taigen-dome-in-prose",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: first.text.trim(),
+      values: { count: ended.length, limit: options.limit, offset: first.span.start },
+    },
+  ];
+};
+
+/**
+ * 名詞を名詞に繋ぐ助詞が続けて出る。「弊社の新製品の販売の計画」は係りかたが読めなくなる典型。
+ *
+ * 見るのは語彙表にある助詞だけ。助詞一般を数えると、「A も B も C も」の並列と
+ * 「コピーして持っていって」の連用が当たる。どちらも何重に続いても読めるので rule が合わない。
+ *
+ * 数えるのは**節の中**だけ。読点で切らないと「サービスの運営や、ドキュメントの作成」のような
+ * 並列まで 1 つの連なりとして数える。並列は必ず読点で区切られる。
+ */
+type Run = { readonly surface: string; readonly tokens: readonly Token[] };
+
+const extend = (runs: readonly 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] }];
+};
+
+const PARTICLE = new Set(["ADP", "SCONJ", "PART", "CCONJ"]);
+
+const BREAK: Run = { surface: "", tokens: [] };
+
+/**
+ * 名詞は連なりの中身なので飛ばす。読点と、語彙表に無い助詞は連なりを切る。
+ * 「弊社のAはBの」を 2 回続いたと数えないため。「は」でいちど句が閉じている。
+ */
+const runsOf = (tokens: readonly Token[], nesting: readonly string[]): Run[] =>
+  tokens.reduce<Run[]>((acc, token) => {
+    if (nesting.includes(token.surface)) return extend(acc, token);
+    return token.pos === "PUNCT" || PARTICLE.has(token.pos) ? [...acc, BREAK] : acc;
+  }, []);
+
+export const doubledParticle: Detector = (doc, options): Finding[] => {
+  const nesting = (options.lexicon ?? []).map((entry) => entry.pattern);
+  return doc.sentences.flatMap((sentence) =>
+    runsOf(sentence.tokens ?? [], nesting)
+      .filter((run) => run.tokens.length > options.limit)
+      .map((run) => ({
+        rule: "no-doubled-joshi",
+        severity: "warning" as const,
+        line: 0,
+        column: 0,
+        quote: sentence.text.trim(),
+        values: { word: run.surface, count: run.tokens.length, limit: options.limit, offset: run.tokens[0]?.span.start ?? sentence.span.start },
+      })),
+  );
+};