chaffjs 0.20.0 → 0.22.0

package/src/detectors/numeral-opener.ts

@@ -0,0 +1,72 @@
+import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+
+/**
+ * 数字で始まる文（20 people came.）。読み手は文の頭を大文字で探すので、数字の頭は文の切れ目を見えにくくする。
+ * 数字の後ろが小文字の語のときだけ読む: 「1 Introduction」のような番号の付いた題や「9:00 Opening」のような時刻の行は文ではない。
+ * 年（2026 was a good year.）は綴れないので読まない。
+ */
+
+const OPENING_NUMERAL = /^(?<numeral>\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?%?(?=\s+\p{Ll})/u;
+const SENTENCE_END = /[.!?]["'”’)]*$/u;
+const YEAR = /^[12]\d{3}$/u;
+const HEADING_LINE = /(?:^|\n)#{1,6}\s[^\n]*$/u;
+const CLOSERS = new Set(['"', "'", "”", "’", ")"]);
+const STOP = /[.!?]$/u;
+const WORD_CHAR = /[\p{L}\p{N}.]/u;
+const DIGITS = /^\d+$/u;
+/** 前の文の終わりを探す字数。見出しの行と、終わりの語が入れば足りる。 */
+const LOOKBACK = 300;
+const PLAIN_WORD = /^\p{L}{2,}$/u;
+
+/** 文の頭の数字。年、数字の後ろが小文字の語でないもの、言い終えていない行（見出しのような）は無い。 */
+export const openingNumeral = (text: string): string | undefined => {
+  const trimmed = text.trim();
+  const match = OPENING_NUMERAL.exec(trimmed);
+  const numeral = match?.groups?.["numeral"];
+  if (match === null || numeral === undefined || YEAR.test(numeral) || !SENTENCE_END.test(trimmed)) return undefined;
+  return match[0];
+};
+
+/** text の終わりに続く、belongs を満たす字の並びの始まり（UTF-16 の位置）。 */
+const tailStart = (text: string, belongs: (char: string) => boolean): number =>
+  text.split("").reduceRight((at, char, index) => (at === index + 1 && belongs(char) ? index : at), text.length);
+
+/** 終わりの印（. ! ?）の前の語。点を含めて読む（H.R. は「H.R」）。印で終わっていなければ undefined。 */
+const lastWordBeforeStop = (text: string): string | undefined => {
+  const closed = text.slice(
+    0,
+    tailStart(text, (char) => CLOSERS.has(char)),
+  );
+  if (!STOP.test(closed)) return undefined;
+  const body = closed.slice(0, -1);
+  const start = tailStart(body, (char) => WORD_CHAR.test(char));
+  return start === body.length ? undefined : body.slice(start);
+};
+
+/**
+ * offset の前で、文がほんとうに終わっているか。文書か見出しの直後か、前の文が二字以上の語か数で言い終えているときだけ。
+ * 番号に付ける略した語（vol. 28、H.R. 5376）や、句点の無い行（Lane\n\n2 contains、HTML から移したリンクの切れ目）の後ろの数は文の頭ではない。
+ */
+export const followsSentenceEnd = (source: string, offset: number, labels: ReadonlySet<string>): boolean => {
+  const from = Math.max(0, offset - LOOKBACK);
+  const ended = source.slice(from, offset).trimEnd();
+  if ((ended === "" && from === 0) || HEADING_LINE.test(ended)) return true;
+  const word = lastWordBeforeStop(ended);
+  if (word === undefined) return false;
+  return DIGITS.test(word) || (PLAIN_WORD.test(word) && !labels.has(word.toLowerCase()));
+};
+
+const inside = (spans: readonly Span[], offset: number): boolean => spans.some((span) => span.start <= offset && offset < span.end);
+
+const leadingSpace = (sentence: Sentence): number => sentence.text.length - sentence.text.trimStart().length;
+
+export const numeralOpener: Detector = (doc): Finding[] => {
+  const labels = new Set((doc.lexicons["numeral-reference-label"] ?? []).map((entry) => entry.pattern.toLowerCase()));
+  return doc.sentences.flatMap((sentence) => {
+    const offset = sentence.span.start + leadingSpace(sentence);
+    if (sentence.embeddedLanguage !== undefined || inside(doc.listSpans, offset)) return [];
+    const numeral = openingNumeral(sentence.text);
+    if (numeral === undefined || !followsSentenceEnd(doc.source, offset, labels)) return [];
+    return [{ rule: "", severity: "warning", line: 0, column: 0, quote: sentence.text.trim(), values: { numeral, offset } }];
+  });
+};

package/src/detectors/ordinal-suffix.ts

@@ -0,0 +1,40 @@
+import type { Detector, Finding, Lexicon } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 数と序数の字が合わない所（3th、22th、11st）。どの数の終わりにどの字が付くかは語彙表 ordinal-suffix が言う。
+
+/** 合わない序数 1 つ。expected はその数に付く字（一つとは限らない）。 */
+export type OrdinalSlip = { readonly offset: number; readonly written: string; readonly number: string; readonly expected: readonly string[] };
+
+/** 数の終わりのうち、語彙表の組にある最も長いものに付く字。 */
+const suffixesFor = (digits: string, suffixes: Lexicon): string[] => {
+  const ending = suffixes
+    .map((entry) => entry.group ?? "")
+    .filter((group) => digits.endsWith(group))
+    .reduce((longest, group) => (group.length > longest.length ? group : longest), "");
+  return suffixes.filter((entry) => (entry.group ?? "") === ending).map((entry) => entry.pattern);
+};
+
+/** 文字列の中の、数と字の合わない序数。語や番号の一部（v1th、0x2nd、1-2th）は読まない。 */
+export const ordinalSlips = (text: string, suffixes: Lexicon): OrdinalSlip[] => {
+  const written = [...new Set(suffixes.map((entry) => entry.pattern))];
+  if (written.length === 0) return [];
+  const pattern = new RegExp(`(?<![\\p{L}\\p{N}_.,\\-])(?<n>\\d+(?:,\\d{3})*)(?<suffix>${written.map(escapeRegExp).join("|")})(?![\\p{L}\\p{N}_])`, "gu");
+  return [...text.matchAll(pattern)].flatMap((match) => {
+    const expected = suffixesFor((match.groups?.["n"] ?? "").replaceAll(",", ""), suffixes);
+    return expected.includes(match.groups?.["suffix"] ?? "") ? [] : [{ offset: match.index, written: match[0], number: match.groups?.["n"] ?? "", expected }];
+  });
+};
+
+export const ordinalSuffix: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return ordinalSlips(text, doc.lexicons["ordinal-suffix"] ?? []).map((slip) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, slip.offset, slip.offset + slip.written.length),
+    values: { written: slip.written, expected: `${slip.number}${slip.expected[0] ?? ""}`, offset: slip.offset },
+  }));
+};

package/src/detectors/range-notation.ts

@@ -0,0 +1,76 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { formMinority } from "./form-minority.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 一つの文書で、数の範囲を二通りの記号で書いた所（10〜20 と 10-20、10–20 と 10-20）。どちらが正しいかは決めず、少ないほうを指す。
+// 範囲の記号は語彙表 range-notation が言う。
+
+/** 数の範囲 1 つ。form は二つの数のあいだの記号。 */
+export type WrittenRange = { readonly offset: number; readonly written: string; readonly form: string };
+
+const FULLWIDTH_OFFSET = 0xfee0;
+const NUMBER = "[0-9０-９]+(?:[.．][0-9０-９]+)?";
+
+/** 範囲のすぐ後ろ（空白一つまで）の単位や語。番号にも使う記号（ハイフン）は、これが続くときだけ範囲と読む。 */
+const UNIT_AFTER = /^\s?[\p{L}%％]/u;
+
+/** 行の頭（見出しや箇条書きの印の後ろ）の「1-2」は節の番号、閉じ括弧のすぐ後ろの「(703) 292-7827」は電話番号。 */
+const LABEL_BEFORE = /(?:^\s*[#>*+|-][\s#>*+|-]*|\)\s?)$/u;
+
+/** 番号の前の札。語彙表の札の語（図、Section）か、頭が大文字の英語の語（NSF）。 */
+const isNumberLabel = (lineBefore: string, labels: readonly string[]): boolean => {
+  const trimmed = lineBefore.trimEnd();
+  if (labels.some((label) => trimmed.endsWith(label))) return true;
+  return /^\p{Lu}/u.test(trimmed.split(/\s/u).at(-1) ?? "");
+};
+
+const halfWidth = (text: string): string => text.replace(/[０-９．]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+/**
+ * 文字列の中の数の範囲。前後にさらに数が続く並び（日付 2026-10-02、電話番号、時刻 10:00、版 1.2-3）は範囲ではない。
+ * 終わりが始まりより小さいもの（郵便番号 100-0001、試合の 3-2）も範囲ではない。ambiguous の記号は、後ろに単位や語が続き、
+ * 前が番号の札（図 2-1、Section 1-2、NSF 13-542）でないときだけ。
+ */
+export const rangesIn = (text: string, marks: readonly string[], ambiguous: readonly string[] = [], labels: readonly string[] = []): WrittenRange[] => {
+  if (marks.length === 0) return [];
+  const joiner = marks
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+  const pattern = new RegExp(
+    `(?<![\\w０-９.．,:：/\\-－–〜～~])(?<from>${NUMBER})\\s?(?<mark>${joiner})\\s?(?<to>${NUMBER})(?![\\w０-９]|[.．,:：/\\-－–〜～~][0-9０-９])`,
+    "gu",
+  );
+  return [...text.matchAll(pattern)].flatMap((match) => {
+    const from = Number(halfWidth(match.groups?.["from"] ?? ""));
+    const to = Number(halfWidth(match.groups?.["to"] ?? ""));
+    const mark = match.groups?.["mark"] ?? "";
+    const unitFollows = UNIT_AFTER.test(text.slice(match.index + match[0].length));
+    const lineBefore = text.slice(text.lastIndexOf("\n", match.index - 1) + 1, match.index);
+    return to > from && !LABEL_BEFORE.test(lineBefore) && (!ambiguous.includes(mark) || (unitFollows && !isNumberLabel(lineBefore, labels)))
+      ? [{ offset: match.index, written: match[0], form: mark }]
+      : [];
+  });
+};
+
+export const rangeNotation: Detector = (doc, options): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const entries = doc.lexicons["range-notation"] ?? [];
+  const ranges = rangesIn(
+    text,
+    entries.map((entry) => entry.pattern),
+    entries.filter((entry) => entry.group === "ambiguous").map((entry) => entry.pattern),
+    ["figure-label", "numbered-division", "numbered-label"].flatMap((id) => (doc.lexicons[id] ?? []).map((entry) => entry.pattern)),
+  );
+  const minority = formMinority(ranges, options.limit);
+  if (minority === undefined) return [];
+  return minority.odd.map((range) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, range.offset, range.offset + range.written.length),
+    values: { written: range.written, mark: range.form, usual: minority.usual.written, count: minority.odd.length, of: ranges.length, offset: range.offset },
+  }));
+};

package/src/detectors/registry/adverb-polarity.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { adverbPolarity } from "../clause-shape.ts";
+
+export const detector: Detector = adverbPolarity;

package/src/detectors/registry/amount-for-count.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { amountForCount } from "../amount-for-count.ts";
+
+export const detector: Detector = amountForCount;

package/src/detectors/registry/attachment-missing.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { attachmentMissing } from "../email-letter.ts";
+
+export const detector: Detector = attachmentMissing;

package/src/detectors/registry/bare-url-mix.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { bareUrlMix } from "../link-shape.ts";
+
+export const detector: Detector = bareUrlMix;

package/src/detectors/registry/caps-shouting.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { capsShouting } from "../mark-shape.ts";
+
+export const detector: Detector = capsShouting;

package/src/detectors/registry/code-fence-language.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { codeFenceLanguage } from "../technical-docs.ts";
+
+export const detector: Detector = codeFenceLanguage;

package/src/detectors/registry/currency-notation.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { currencyNotation } from "../currency-notation.ts";
+
+export const detector: Detector = currencyNotation;

package/src/detectors/registry/dangling-opener.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { danglingOpener } from "../dangling-opener.ts";
+
+export const detector: Detector = danglingOpener;

package/src/detectors/registry/defined-name-repeated.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { definedNameRepeated } from "../defined-term-form.ts";
+
+export const detector: Detector = definedNameRepeated;

package/src/detectors/registry/defined-term-form.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { definedTermForm } from "../defined-term-form.ts";
+
+export const detector: Detector = definedTermForm;

package/src/detectors/registry/email-frame.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { emailFrame } from "../email-letter.ts";
+
+export const detector: Detector = emailFrame;

package/src/detectors/registry/email-subject.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { emailSubject } from "../email-letter.ts";
+
+export const detector: Detector = emailSubject;

package/src/detectors/registry/ending-run.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { endingRun } from "../clause-shape.ts";
+
+export const detector: Detector = endingRun;

package/src/detectors/registry/footnote-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { footnoteMismatch } from "../footnote-mismatch.ts";
+
+export const detector: Detector = footnoteMismatch;

package/src/detectors/registry/heading-command.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { headingCommand } from "../technical-docs.ts";
+
+export const detector: Detector = headingCommand;

package/src/detectors/registry/heading-end-punctuation.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { headingEndMark } from "../heading-end-mark.ts";
+
+export const detector: Detector = headingEndMark;

package/src/detectors/registry/hyphen-dash.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { hyphenDash } from "../mark-shape.ts";
+
+export const detector: Detector = hyphenDash;

package/src/detectors/registry/image-file-name-alt.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { imageFileNameAlt } from "../link-shape.ts";
+
+export const detector: Detector = imageFileNameAlt;

package/src/detectors/registry/impossible-date.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { impossibleDate } from "../impossible-date.ts";
+
+export const detector: Detector = impossibleDate;

package/src/detectors/registry/impossible-time.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { impossibleTime } from "../impossible-time.ts";
+
+export const detector: Detector = impossibleTime;

package/src/detectors/registry/latin-abbreviation.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { latinAbbreviation } from "../mark-shape.ts";
+
+export const detector: Detector = latinAbbreviation;

package/src/detectors/registry/link-text-url-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { linkTextUrlMismatch } from "../link-shape.ts";
+
+export const detector: Detector = linkTextUrlMismatch;

package/src/detectors/registry/list-marker.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { listMarkerMix } from "../list-marker.ts";
+
+export const detector: Detector = listMarkerMix;

package/src/detectors/registry/mark-consistency.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { markConsistency } from "../mark-shape.ts";
+
+export const detector: Detector = markConsistency;

package/src/detectors/registry/numeral-opener.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { numeralOpener } from "../numeral-opener.ts";
+
+export const detector: Detector = numeralOpener;

package/src/detectors/registry/ordinal-suffix.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { ordinalSuffix } from "../ordinal-suffix.ts";
+
+export const detector: Detector = ordinalSuffix;

package/src/detectors/registry/origin-particle.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { originParticle } from "../clause-shape.ts";
+
+export const detector: Detector = originParticle;

package/src/detectors/registry/range-notation.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { rangeNotation } from "../range-notation.ts";
+
+export const detector: Detector = rangeNotation;

package/src/detectors/registry/relative-pronoun-mix.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { relativePronounMix } from "../relative-pronoun-mix.ts";
+
+export const detector: Detector = relativePronounMix;

package/src/detectors/registry/request-without-deadline.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { requestWithoutDeadline } from "../request-owner.ts";
+
+export const detector: Detector = requestWithoutDeadline;

package/src/detectors/registry/sentence-spacing.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { sentenceSpacing } from "../mark-shape.ts";
+
+export const detector: Detector = sentenceSpacing;

package/src/detectors/registry/share-over-hundred.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { shareOverHundred } from "../share-over-hundred.ts";
+
+export const detector: Detector = shareOverHundred;

package/src/detectors/registry/shell-prompt.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { shellPrompt } from "../technical-docs.ts";
+
+export const detector: Detector = shellPrompt;

package/src/detectors/registry/step-reference.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { stepReference } from "../step-reference.ts";
+
+export const detector: Detector = stepReference;

package/src/detectors/registry/step-statement.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { stepStatement } from "../technical-docs.ts";
+
+export const detector: Detector = stepStatement;

package/src/detectors/registry/table-row-overflow.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { tableRowOverflow } from "../markdown-slip.ts";
+
+export const detector: Detector = tableRowOverflow;

package/src/detectors/registry/toc-heading.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { tocHeading } from "../toc-heading.ts";
+
+export const detector: Detector = tocHeading;

package/src/detectors/registry/unclosed-code-fence.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { unclosedCodeFence } from "../markdown-slip.ts";
+
+export const detector: Detector = unclosedCodeFence;

package/src/detectors/registry/unpaired-parallel.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { unpairedParallel } from "../clause-shape.ts";
+
+export const detector: Detector = unpairedParallel;

package/src/detectors/registry/unrendered-emphasis.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { unrenderedEmphasis } from "../markdown-slip.ts";
+
+export const detector: Detector = unrenderedEmphasis;

package/src/detectors/relative-pronoun-mix.ts

@@ -0,0 +1,79 @@
+import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+import { minorityOf } from "./technical-docs.ts";
+import { isWithinAny, quotedIn, QUOTATION_MARKS } from "../quoted-span.ts";
+
+/**
+ * 限定の関係節を which で書く所と that で書く所が、一つの文書に混ざっている所（the file which contains / the file that contains）。
+ * どちらが正しいかは決めず、少ないほうを指す。読むのは「名詞 + which|that + 動詞」の、読点を挟まない形だけ。
+ * that の後ろに主語が来る形（the fact that it works）は、関係節か同格の節か語の並びで決まらないので数えない。
+ */
+
+export type RelativeUse = { readonly word: Token; readonly kind: string };
+
+/** 多いほうの書き方が、文書の書き方と言えるだけの数。 */
+const MIN_USUAL = 3;
+const VERBAL = new Set(["VERB", "AUX"]);
+
+/** 解析器は三人称の動詞を複数の名詞と読むことがある（the script that checks links の checks）。 */
+const isThirdPersonVerb = (token: Token): boolean => token.pos === "NOUN" && token.features?.["AlsoVerb"] === "Yes" && token.features["Number"] === "Plur";
+
+const isTaggedFiniteVerb = (token: Token | undefined): boolean =>
+  token !== undefined && VERBAL.has(token.pos) && token.features?.["VerbForm"] !== "Part" && token.features?.["VerbForm"] !== "Ger";
+
+/**
+ * 動詞と読める語。名詞と読まれた三人称の動詞は、後ろに動詞が無いときだけ（the idea that results matter の results は主語）。
+ */
+const isFiniteVerb = (token: Token | undefined, next: Token | undefined): boolean =>
+  isTaggedFiniteVerb(token) || (token !== undefined && isThirdPersonVerb(token) && !isTaggedFiniteVerb(next));
+
+const isBaseForm = (verb: Token): boolean => verb.pos === "VERB" && verb.lemma?.toLowerCase() === verb.surface.toLowerCase();
+
+/**
+ * 名詞の後ろの関係節の動詞。原形の動詞は複数の名詞にだけ続く（resources which set）。単数の名詞の後ろの原形は、
+ * 関係節ではなく「どの」の which（tells the command which file to use）。
+ */
+const opensRelative = (noun: Token | undefined, verb: Token | undefined, next: Token | undefined): boolean =>
+  noun?.pos === "NOUN" && verb !== undefined && isFiniteVerb(verb, next) && (!isBaseForm(verb) || noun.features?.["Number"] === "Plur");
+
+/** which / that の後ろの、副詞を飛ばした最初の語（the file which usually stores の stores）。 */
+const verbAfter = (tokens: readonly Token[], at: number): number => {
+  const found = tokens.findIndex((token, index) => index > at && token.pos !== "ADV");
+  return found === -1 ? tokens.length : found;
+};
+
+/** 語彙表の組（which / that）で、tokens の中の限定の関係節の頭。 */
+export const relativeUses = (tokens: readonly Token[], kinds: Lexicon): RelativeUse[] =>
+  tokens.flatMap((word, at) => {
+    const entry = kinds.find((candidate) => candidate.pattern.toLowerCase() === word.surface.toLowerCase());
+    const verb = verbAfter(tokens, at);
+    if (entry?.group === undefined || !opensRelative(tokens[at - 1], tokens[verb], tokens[verb + 1])) return [];
+    return [{ word, kind: entry.group }];
+  });
+
+/** 二通りの書き方のうち少ないほう。多いほうが MIN_USUAL に満たなければ、文書の書き方と言えないので空。 */
+export const oddRelatives = (uses: readonly RelativeUse[], limit: number): { readonly odd: readonly RelativeUse[]; readonly usual: string } => {
+  const kinds = [...new Set(uses.map((use) => use.kind))];
+  const [first, second] = kinds.map((kind) => uses.filter((use) => use.kind === kind));
+  if (kinds.length !== 2 || first === undefined || second === undefined) return { odd: [], usual: "" };
+  const odd = minorityOf(first, second, limit);
+  const usual = odd === first ? second : first;
+  return usual.length < MIN_USUAL ? { odd: [], usual: "" } : { odd, usual: usual[0]?.word.surface.toLowerCase() ?? "" };
+};
+
+export const relativePronounMix: Detector = (doc, options): Finding[] => {
+  const kinds = doc.lexicons["restrictive-relative"] ?? [];
+  const uses = doc.sentences.flatMap((sentence) => {
+    if (sentence.embeddedLanguage !== undefined) return [];
+    const quoted = quotedIn(sentence, QUOTATION_MARKS);
+    return relativeUses(sentence.tokens ?? [], kinds).filter((use) => !isWithinAny(quoted, use.word.span));
+  });
+  const { odd, usual } = oddRelatives(uses, options.limit);
+  return odd.map((use) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: doc.sentences.find((sentence) => sentence.span.start <= use.word.span.start && use.word.span.start < sentence.span.end)?.text.trim() ?? "",
+    values: { word: use.word.surface, usual, count: odd.length, limit: options.limit, offset: use.word.span.start },
+  }));
+};