chaffjs 0.21.0 → 0.22.0

package/src/commands/plugin-init.ts

@@ -0,0 +1,150 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { API_VERSION } from "../api.ts";
+import { VERSION } from "../version.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+
+// chaff init --plugin <name>: a rule pack to start from, written in YAML alone. One rule, its word list in Japanese and
+// English, and a test command (chaff plugin-test) that checks each rule's example against the rule.
+
+/** A pack's own name: lowercase letters, digits and hyphens, optionally under a scope (@team/house). */
+const PACK_NAME = /^(?:(@[a-z0-9][a-z0-9._-]*)\/)?([a-z][a-z0-9-]*)$/u;
+
+export type PackName = { readonly scope: string | undefined; readonly name: string };
+
+/** The name as written after --plugin, or undefined when it cannot be a plugin's name. "chaff-plugin-" in front is allowed and dropped. */
+export const packNameOf = (written: string | undefined): PackName | undefined => {
+  const match = PACK_NAME.exec((written ?? "").replace(/(^|\/)chaff-plugin-/u, "$1"));
+  if (match === null) return undefined;
+  const [, scope, name] = match;
+  return name === undefined ? undefined : { scope, name };
+};
+
+/** The package's name and the folder it is made in: chaff-plugin-house, or @team/chaff-plugin-house in chaff-plugin-house. */
+export const packageOf = (pack: PackName): { readonly packageName: string; readonly folder: string } => ({
+  packageName: pack.scope === undefined ? `chaff-plugin-${pack.name}` : `${pack.scope}/chaff-plugin-${pack.name}`,
+  folder: `chaff-plugin-${pack.name}`,
+});
+
+const RULE = `# One rule of the pack. It is written as a rule under custom_rules in chaff.yaml is; see
+# https://isamu.github.io/lab/en/guide/adding-rules for every field.
+id: avoid-words
+type: words
+# The words come from lexicons/<language>/avoid-words.yaml, in the document's language.
+word_list: avoid-words
+name: { ja: チームで使わない言葉, en: A word the team does not use }
+why:
+  ja: このチームでは、同じものを決まった言葉で呼びます。別の言葉が混ざると、読む人は別のものかと迷います。
+  en: The team calls each thing by one word. Another word makes a reader wonder whether it is another thing.
+how_to_fix: { ja: チームの言葉に置き換えます。, en: Use the team's word. }
+message:
+  ja: 「{matched}」ではなく「{preferred}」と書きます
+  en: 'Write "{preferred}", not "{matched}"'
+level: warning
+example:
+  ja: { before: 弊社の新しい窓口をご案内します。, after: 当社の新しい窓口をご案内します。 }
+  en: { before: We utilize the new form for every request., after: We use the new form for every request. }
+rewrite:
+  depth: light
+  ja:
+    direction: 指された言葉だけを、チームの言葉に置き換えます。
+    pairs:
+      - { before: 弊社の新しい窓口をご案内します。, after: 当社の新しい窓口をご案内します。 }
+      - { before: 弊社では毎月点検しています。, after: 当社では毎月点検しています。 }
+    keep: [文のほかの部分]
+    avoid: [言葉と一緒に文の意味を変える]
+  en:
+    direction: Replace only the flagged word with the team's word.
+    pairs:
+      - { before: We utilize the new form for every request., after: We use the new form for every request. }
+      - { before: Utilize the search box first., after: Use the search box first. }
+    keep: [the rest of the sentence]
+    avoid: [changing what the sentence says along with the word]
+`;
+
+const LEXICON_JA = `# 使わない言葉（pattern）と、使う言葉（rewrite）。
+- { pattern: 弊社, rewrite: 当社 }
+`;
+
+const LEXICON_EN = `# The word not to use (pattern) and the word to use (rewrite).
+- { pattern: utilize, rewrite: use }
+`;
+
+const packageJson = (packageName: string): string =>
+  `${JSON.stringify(
+    {
+      name: packageName,
+      version: "0.1.0",
+      description: "Rules for chaff, written in YAML.",
+      files: ["rules", "lexicons", "styles"],
+      chaff: { apiVersion: API_VERSION },
+      scripts: { test: "chaffjs plugin-test ." },
+      peerDependencies: { chaffjs: `>=${VERSION}` },
+    },
+    null,
+    2,
+  )}\n`;
+
+const FILES = (packageName: string): Readonly<Record<string, string>> => ({
+  "package.json": packageJson(packageName),
+  "rules/avoid-words.yaml": RULE,
+  "lexicons/ja/avoid-words.yaml": LEXICON_JA,
+  "lexicons/en/avoid-words.yaml": LEXICON_EN,
+});
+
+const TEXT: Texts<{
+  readonly badName: (written: string) => string;
+  readonly exists: (folder: string) => string;
+  readonly made: (folder: string, packageName: string) => string;
+  readonly next: (folder: string, name: string) => readonly string[];
+}> = {
+  ja: {
+    badName: (written) => `--plugin ${written}: プラグインの名前は英小文字・数字・ハイフンで書きます（house、@team/house）`,
+    exists: (folder) => `${folder} はもうあります。上書きしないので、別の名前にするか消してから実行してください`,
+    made: (folder, packageName) => `${folder}/ に YAML だけのルールの束 ${packageName} を作りました。`,
+    next: (folder, name) => [
+      "",
+      "次に:",
+      `  cd ${folder} && npx chaffjs plugin-test .    ルールの例をルールにかけて確かめる`,
+      `  chaff.yaml に plugins: [./${folder}] と書くと、${name}/avoid-words として動きます`,
+      "",
+    ],
+  },
+  en: {
+    badName: (written) => `--plugin ${written}: a plugin's name is lowercase letters, digits and hyphens (house, @team/house)`,
+    exists: (folder) => `${folder} already exists. Nothing is overwritten; choose another name or remove it first`,
+    made: (folder, packageName) => `Made the YAML rule pack ${packageName} in ${folder}/.`,
+    next: (folder, name) => [
+      "",
+      "Next:",
+      `  cd ${folder} && npx chaffjs plugin-test .    check each rule against its own example`,
+      `  add plugins: [./${folder}] to chaff.yaml and it runs as ${name}/avoid-words`,
+      "",
+    ],
+  },
+};
+
+/** Makes the pack in dir. Lines to print, and whether it was made; nothing is written when the folder is already there. */
+export const initPlugin = (dir: string, written: string | undefined, ui: UiLanguage): { readonly ok: boolean; readonly lines: readonly string[] } => {
+  const text = TEXT[ui];
+  const pack = packNameOf(written);
+  if (pack === undefined) return { ok: false, lines: [text.badName(written ?? "")] };
+  const { packageName, folder } = packageOf(pack);
+  if (existsSync(join(dir, folder))) return { ok: false, lines: [text.exists(folder)] };
+  Object.entries(FILES(packageName)).forEach(([path, body]) => {
+    mkdirSync(dirname(join(dir, folder, path)), { recursive: true });
+    writeFileSync(join(dir, folder, path), body, "utf8");
+  });
+  const name = pack.scope === undefined ? pack.name : `${pack.scope}/${pack.name}`;
+  return {
+    ok: true,
+    lines: [text.made(folder, packageName), ...Object.keys(FILES(packageName)).map((path) => `  ${folder}/${path}`), ...text.next(folder, name)],
+  };
+};
+
+/** chaff init --plugin <name>: makes the pack in dir and says what it made, or why it did not. */
+export const runInitPlugin = (dir: string, written: string | undefined, ui: UiLanguage): number => {
+  const made = initPlugin(dir, written, ui);
+  made.lines.forEach((line) => (made.ok ? console.log(line) : console.error(line)));
+  return made.ok ? 0 : 1;
+};

package/src/commands/plugin-test.ts

@@ -0,0 +1,111 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { EMPTY, type Config } from "../config/load.ts";
+import { withExtensions } from "../extension/load.ts";
+import { extensionProblems } from "../extension/problem-text.ts";
+import { loadGenres } from "../genre-load.ts";
+import type { RuleDefinition } from "../plugin.ts";
+import type { Skipped } from "../run.ts";
+import type { Texts, UiLanguage } from "../ui.ts";
+import type { Checked } from "./feedback.ts";
+
+// chaff plugin-test [folder]: loads a plugin as chaff.yaml would, then runs each of its rules on the rule's own example,
+// in every language the example is written in. The before must give the rule a finding and the after must give it
+// none. A rule that does not run there (no word list for the language) fails, with the reason.
+
+export type PluginTestContext = {
+  readonly ui: UiLanguage;
+  /** Lints one file with these settings, as chaff on the command line does. */
+  readonly check: (path: string, config: Config, argv: readonly string[]) => Promise<Pick<Checked, "findings" | "skipped">>;
+};
+
+type Outcome = { readonly rule: string; readonly language: string; readonly failure: string | undefined };
+
+const TEXT: Texts<{
+  readonly noRules: (dir: string) => string;
+  readonly beforeQuiet: string;
+  readonly afterFlagged: (count: number) => string;
+  readonly notRun: (why: string) => string;
+  readonly noExample: string;
+  readonly summary: (passed: number, total: number) => string;
+}> = {
+  ja: {
+    noRules: (dir) => `${dir} にルールがありません。`,
+    beforeQuiet: "例の before で指摘が出ません",
+    afterFlagged: (count) => `例の after で指摘が ${String(count)} 件出ます`,
+    notRun: (why) => `動きません（${why}）`,
+    noExample: "例がありません",
+    summary: (passed, total) => `${String(total)} 件のうち ${String(passed)} 件が通りました。`,
+  },
+  en: {
+    noRules: (dir) => `${dir} has no rules.`,
+    beforeQuiet: "the example's before gets no finding",
+    afterFlagged: (count) => `the example's after gets ${String(count)} ${count === 1 ? "finding" : "findings"}`,
+    notRun: (why) => `it does not run (${why})`,
+    noExample: "it has no example",
+    summary: (passed, total) => `${String(passed)} of ${String(total)} passed.`,
+  },
+};
+
+/** The first genre the rule is for: the example runs where the rule does. */
+const genreFor = (rule: RuleDefinition): string => {
+  const genres = loadGenres().genres.map((genre) => genre.id);
+  return genres.find((genre) => rule.use_for.some((target) => genre === target || genre.startsWith(`${target}/`))) ?? genres[0] ?? "business/report";
+};
+
+const skippedWhy = (skipped: readonly Skipped[], rule: string): string | undefined => skipped.find((entry) => entry.rule === rule)?.why;
+
+/** One rule in one language: before flagged, after clean. */
+const testExample = async (rule: RuleDefinition, language: string, config: Config, context: PluginTestContext): Promise<Outcome> => {
+  const text = TEXT[context.ui];
+  const example = rule.guide?.examples[language];
+  if (example === undefined) return { rule: rule.id, language, failure: text.noExample };
+  const dir = mkdtempSync(join(tmpdir(), "chaff-plugin-test-"));
+  const argv = ["--language", language, "--genre", genreFor(rule)];
+  const run = async (name: string, body: string): Promise<Pick<Checked, "findings" | "skipped">> => {
+    writeFileSync(join(dir, name), `${body.trimEnd()}\n`, "utf8");
+    return context.check(join(dir, name), config, argv);
+  };
+  const before = await run("before.md", example.before);
+  const why = skippedWhy(before.skipped, rule.id);
+  if (why !== undefined) return { rule: rule.id, language, failure: text.notRun(why) };
+  if (!before.findings.some((finding) => finding.rule === rule.id)) return { rule: rule.id, language, failure: text.beforeQuiet };
+  const after = (await run("after.md", example.after)).findings.filter((finding) => finding.rule === rule.id).length;
+  return { rule: rule.id, language, failure: after === 0 ? undefined : text.afterFlagged(after) };
+};
+
+const lineOf = (outcome: Outcome): string =>
+  outcome.failure === undefined ? `  ✓ ${outcome.rule} (${outcome.language})` : `  ✗ ${outcome.rule} (${outcome.language}): ${outcome.failure}`;
+
+/** The languages a rule's example is written in, or the rule's languages when it has none, so a missing example is said. */
+const languagesOf = (rule: RuleDefinition): readonly string[] => {
+  const written = Object.keys(rule.guide?.examples ?? {});
+  return written.length > 0 ? written : (rule.languages ?? ["ja", "en"]);
+};
+
+/** Exit 0 when every rule passes on every example; 1 when the plugin cannot be loaded or a rule fails. */
+export const runPluginTest = async (folder: string | undefined, context: PluginTestContext): Promise<number> => {
+  const text = TEXT[context.ui];
+  const dir = resolve(folder ?? ".");
+  const config = await withExtensions({ ...EMPTY, plugins: [dir], baseDir: dir, path: dir });
+  const problems = extensionProblems(config, context.ui);
+  if (problems.length > 0) {
+    problems.forEach((problem) => console.error(problem));
+    return 1;
+  }
+  const rules = config.extensions?.rules ?? [];
+  if (rules.length === 0) {
+    console.error(text.noRules(dir));
+    return 1;
+  }
+  const cases = rules.flatMap((rule) => languagesOf(rule).map((language) => ({ rule, language })));
+  const outcomes = await cases.reduce<Promise<Outcome[]>>(
+    async (done, entry) => [...(await done), await testExample(entry.rule, entry.language, config, context)],
+    Promise.resolve([]),
+  );
+  outcomes.map(lineOf).forEach((line) => console.log(line));
+  const passed = outcomes.filter((outcome) => outcome.failure === undefined).length;
+  console.log(`\n${text.summary(passed, outcomes.length)}`);
+  return passed === outcomes.length ? 0 : 1;
+};

package/src/custom/problems.ts

@@ -5,7 +5,7 @@ import { customRulesOf } from "./load.ts";
 import { MAX_PATTERN_LENGTH, MAX_REPEATS, type RegexRefusal } from "./regex-safety.ts";
 import { POS_WRITTEN_NAMES } from "./token-pattern.ts";
 import type { ModulePathRefusal } from "./module-path.ts";
-import { fieldProblemSentence, type FieldKind, type FieldProblem } from "../rule-fields.ts";
+import { FIELD_KINDS, fieldProblemSentence, type FieldKind, type FieldProblem } from "../rule-fields.ts";
 
 /** Each problem's sentence, with {at}, {written}, {field}, {index}, {refusal} and {names} filled in from the problem. */
 type Text = {
@@ -111,8 +111,6 @@ const valuesOf = (problem: CustomProblem, text: Text, scope: string): Readonly<R
   names: POS_WRITTEN_NAMES.join(" / "),
 });
 
-const FIELD_KINDS: ReadonlySet<string> = new Set<FieldKind>(["bad-depth", "bad-group", "bad-use-for", "bad-summary", "bad-example"]);
-
 const isFieldProblem = (problem: CustomProblem): problem is FieldProblem & { readonly at: string } => FIELD_KINDS.has(problem.kind);
 
 /** One problem as a sentence. scope names the list the rule is in: custom_rules, or a plugin's rules. */

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

@@ -0,0 +1,90 @@
+import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+import { endsNounPhrase } from "./agreement-slip.ts";
+import { isPartOfLongerWord } from "./doubled-word.ts";
+
+/**
+ * 量を言う語を、数えられる名詞の複数に付けた所（less errors、less customer complaints）。語は語彙表 amount-quantifier が言う。
+ * 前が名詞か数なら「引く」の less（revenue less costs、$500 less fees）なので読まない。
+ */
+
+export type AmountLists = {
+  /** 量を言う語（less）と、数を言う語（fewer, rewrite）。 */
+  readonly quantifiers: Lexicon;
+  /** 複数の形でも数えない名詞。単数と複数が同じ綴りの語（series）と、金額を言う複数（earnings）。 */
+  readonly uncounted: ReadonlySet<string>;
+  /** 名詞にならない be / have の形。名詞句がそこで終わる。 */
+  readonly finite: ReadonlySet<string>;
+};
+
+export type AmountSlip = { readonly quantifier: Token; readonly noun: Token; readonly rewrite: string };
+
+const UPPER_START = /^\p{Lu}/u;
+
+/** 前に立てば、量の語が限定詞として読める品詞。名詞・数・記号の後ろは「引く」の less。 */
+const OPENS_PHRASE = new Set(["VERB", "AUX", "ADP", "CCONJ", "SCONJ", "ADV", "PART"]);
+const OPENING_MARK = new Set(["(", "[", "{", '"', "'", "“", "‘"]);
+
+const lower = (token: Token): string => token.surface.toLowerCase();
+
+/** 解析器は三人称の動詞を複数の名詞と読むことがある（The parser reports less errors の reports）。 */
+const mayBeVerb = (token: Token): boolean => token.pos === "NOUN" && token.features?.["AlsoVerb"] === "Yes" && token.features["Number"] === "Plur";
+
+const opensPhrase = (previous: Token | undefined): boolean =>
+  previous === undefined || OPENS_PHRASE.has(previous.pos) || OPENING_MARK.has(previous.surface) || mayBeVerb(previous);
+
+const isCommonNoun = (token: Token | undefined): token is Token =>
+  token?.pos === "NOUN" && token.features?.["Guess"] !== "Yes" && !UPPER_START.test(token.surface);
+
+const isPlural = (token: Token): boolean => token.features?.["Number"] === "Plur";
+
+/** 複数の形がはっきりした、数えられる普通名詞。形から当てた語（stimuli）と、数えない語は読まない。 */
+const isCountedPlural = (noun: Token | undefined, uncounted: ReadonlySet<string>): noun is Token =>
+  isCommonNoun(noun) && isPlural(noun) && !uncounted.has(lower(noun));
+
+/** less の後ろの名詞の頭。単数の名詞を一つ重ねた語（less customer complaints）は、その後ろの語。 */
+const headAt = (tokens: readonly Token[], at: number): number => {
+  const next = tokens[at + 1];
+  return isCommonNoun(next) && !isPlural(next) ? at + 2 : at + 1;
+};
+
+const slipAt = (source: string, tokens: readonly Token[], at: number, lists: AmountLists): AmountSlip | undefined => {
+  const quantifier = tokens[at];
+  const entry = quantifier === undefined ? undefined : lists.quantifiers.find((candidate) => candidate.pattern.toLowerCase() === lower(quantifier));
+  if (quantifier?.pos !== "ADJ" || entry === undefined || !opensPhrase(tokens[at - 1])) return undefined;
+  const head = headAt(tokens, at);
+  const noun = tokens[head];
+  if (!isCountedPlural(noun, lists.uncounted) || !endsNounPhrase(tokens[head + 1], lists.finite) || isPartOfLongerWord(source, quantifier, noun))
+    return undefined;
+  return { quantifier, noun, rewrite: entry.rewrite ?? "" };
+};
+
+export const amountSlipsIn = (source: string, tokens: readonly Token[], lists: AmountLists): AmountSlip[] =>
+  tokens.flatMap((_, at) => slipAt(source, tokens, at, lists) ?? []);
+
+const patternsOf = (lexicon: Lexicon): string[] => lexicon.map((entry) => entry.pattern.toLowerCase());
+
+const listsOf = (lexicons: Readonly<Record<string, Lexicon>>): AmountLists => {
+  const words = lexicons["amount-quantifier"] ?? [];
+  return {
+    quantifiers: words.filter((entry) => entry.group === "quantifier"),
+    uncounted: new Set([...patternsOf(lexicons["invariant-noun"] ?? []), ...patternsOf(words.filter((entry) => entry.group === "amount"))]),
+    finite: new Set(patternsOf(lexicons["finite-auxiliary"] ?? [])),
+  };
+};
+
+export const amountForCount: Detector = (doc): Finding[] => {
+  const lists = listsOf(doc.lexicons);
+  return doc.sentences.flatMap((sentence) =>
+    amountSlipsIn(doc.source, sentence.tokens ?? [], lists).map((slip): Finding => {
+      const rest = doc.source.slice(slip.quantifier.span.end, slip.noun.span.end).replace(/\s+/gu, " ");
+      return {
+        rule: "",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: sentence.text.trim(),
+        values: { word: `${slip.quantifier.surface}${rest}`, suggestion: `${slip.rewrite}${rest}`, offset: slip.quantifier.span.start },
+      };
+    }),
+  );
+};

package/src/detectors/currency-notation.ts

@@ -0,0 +1,90 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { formMinority } from "./form-minority.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 一つの文書で、同じ通貨の金額を二通りに書いた所（1,000円 と ¥1,000、$20 と 20 dollars）。どちらが正しいかは決めず、少ないほうを指す。
+// 通貨の書き方、それを金額のどちら側に書くか、どの通貨か（group）は語彙表 currency-notation、桁の語は amount-multiplier が言う。
+
+export type CurrencyForm = { readonly pattern: string; readonly position: "before" | "after"; readonly currency: string };
+
+/** 金額 1 つ。form は書き方（側と記号）、currency はその通貨。 */
+export type WrittenAmount = { readonly offset: number; readonly written: string; readonly form: string; readonly currency: string };
+
+/** 少ないほうの書き方の金額と、多いほうの書き方の例、その通貨の金額の数。 */
+export type CurrencyMinority = { readonly odd: WrittenAmount; readonly usual: string; readonly count: number; readonly of: number };
+
+const AMOUNT = "[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?";
+
+const alternation = (words: readonly string[]): string => words.map(escapeRegExp).join("|");
+
+/** 記号が英字で始まる・終わるなら、語の中（USDT、dollarsign）を読まないよう英字の切れ目を求める。 */
+const latinEdge = (pattern: string, side: "start" | "end"): string => {
+  const edge = side === "start" ? pattern.charAt(0) : pattern.charAt(pattern.length - 1);
+  if (!/[A-Za-z]/u.test(edge)) return "";
+  return side === "start" ? "(?<![A-Za-z])" : "(?![A-Za-z])";
+};
+
+const amountPattern = (form: CurrencyForm, multipliers: readonly string[]): RegExp => {
+  const mark = escapeRegExp(form.pattern);
+  const multiplier = multipliers.length === 0 ? "" : `(?:\\s?(?:${alternation(multipliers)}))?`;
+  return form.position === "before"
+    ? new RegExp(`${latinEdge(form.pattern, "start")}${mark}\\s?${AMOUNT}${multiplier}(?![A-Za-z0-9０-９])`, "gu")
+    : new RegExp(`(?<![\\w.,，０-９])${AMOUNT}${multiplier}\\s?${mark}${latinEdge(form.pattern, "end")}`, "gu");
+};
+
+const overlaps = (left: WrittenAmount, right: WrittenAmount): boolean =>
+  left.offset < right.offset + right.written.length && right.offset < left.offset + left.written.length;
+
+/** 文字列の中の金額と、その書き方。重なる所に二つの書き方が当たれば、記号の長いほう（US$ と $ なら US$、米ドル と ドル なら 米ドル）。 */
+export const amountsIn = (text: string, forms: readonly CurrencyForm[], multipliers: readonly string[]): WrittenAmount[] =>
+  forms
+    .toSorted((left, right) => right.pattern.length - left.pattern.length)
+    .flatMap((form) =>
+      [...text.matchAll(amountPattern(form, multipliers))].map((match) => ({
+        offset: match.index,
+        written: match[0],
+        form: `${form.position}:${form.pattern}`,
+        currency: form.currency,
+      })),
+    )
+    .reduce<WrittenAmount[]>((kept, amount) => (kept.some((other) => overlaps(other, amount)) ? kept : [...kept, amount]), [])
+    .toSorted((left, right) => left.offset - right.offset);
+
+const minorityOf = (ofCurrency: readonly WrittenAmount[], limit: number): CurrencyMinority[] => {
+  const minority = formMinority(ofCurrency, limit);
+  if (minority === undefined) return [];
+  return minority.odd.map((amount) => ({ odd: amount, usual: minority.usual.written, count: minority.odd.length, of: ofCurrency.length }));
+};
+
+/**
+ * 通貨ごとに、多いほうと違う書き方の金額。少ないほうが limit パーセントを超えれば、使い分けている文書と読んで言わない。
+ * いちばん多い書き方が同じ数で並べば、どちらにも立たない。
+ */
+export const currencyMinorities = (amounts: readonly WrittenAmount[], limit: number): CurrencyMinority[] =>
+  [...new Set(amounts.map((amount) => amount.currency))]
+    .flatMap((currency) =>
+      minorityOf(
+        amounts.filter((amount) => amount.currency === currency),
+        limit,
+      ),
+    )
+    .toSorted((left, right) => left.odd.offset - right.odd.offset);
+
+const formsOf = (doc: ProseDocument): CurrencyForm[] =>
+  (doc.lexicons["currency-notation"] ?? []).flatMap((entry) =>
+    entry.position === undefined || entry.group === undefined ? [] : [{ pattern: entry.pattern, position: entry.position, currency: entry.group }],
+  );
+
+export const currencyNotation: Detector = (doc, options): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const multipliers = (doc.lexicons["amount-multiplier"] ?? []).map((entry) => entry.pattern);
+  return currencyMinorities(amountsIn(text, formsOf(doc), multipliers), options.limit).map(({ odd, usual, count, of }) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, odd.offset, odd.offset + odd.written.length),
+    values: { written: odd.written.trim(), usual: usual.trim(), count, of, offset: odd.offset },
+  }));
+};

package/src/detectors/dangling-opener.ts

@@ -0,0 +1,74 @@
+import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+
+/**
+ * 分詞で始めた句の後ろの主語が、形だけの it か there の文（Having reviewed the code, it is ready.）。
+ * 分詞の動作をしたのは書き手か読み手で、it ではない。読むのはこの形だけに絞り、主語が名詞の文は読まない。
+ * 読むのは -ing の分詞だけ。決まった言い方として読まれる分詞（Given, Based on, Generally speaking）は語彙表 dangling-participle の exempt が言う。
+ */
+
+export type DanglingOpener = { readonly opener: string; readonly subject: Token; readonly offset: number };
+
+/** 分詞の句として読む語の数の上限。長い句は読点の位置が当てにならない。 */
+const MAX_OPENER_TOKENS = 12;
+const BE = "be";
+const HAVE = "have";
+/** be の後ろで読点が来たら、it is … は挿入句（Testing the integration, it is worth noting, requires …）。 */
+const PARENTHETICAL_REACH = 4;
+
+const lower = (token: Token | undefined): string => token?.surface.toLowerCase() ?? "";
+
+/** -ing の分詞だけ。過去分詞の句（Configured with SSO, it is ready.）は it そのものを言うことが多い。 */
+const isPresentParticiple = (token: Token | undefined): boolean => token?.pos === "VERB" && token.features?.["VerbForm"] === "Ger";
+
+const lemmaOf = (token: Token | undefined): string => token?.lemma?.toLowerCase() ?? "";
+
+/** 文の頭が決まった言い方か。語彙表の語は空白で区切って、頭の語と順に比べる。 */
+const opensWithExempt = (tokens: readonly Token[], exempt: readonly string[]): boolean =>
+  exempt.some((phrase) => phrase.split(/\s+/u).every((word, at) => lower(tokens[at]) === word));
+
+/** 形だけの主語の後ろの be（it is / there are）、助動詞と be（it can be）、have と been（it has been）。 */
+const isBeAfter = (tokens: readonly Token[], at: number): boolean => {
+  const verb = tokens[at];
+  if (lemmaOf(verb) === BE) return true;
+  return (verb?.pos === "AUX" || lemmaOf(verb) === HAVE) && lemmaOf(tokens[at + 1]) === BE;
+};
+
+const isParenthetical = (tokens: readonly Token[], at: number): boolean => tokens.slice(at, at + PARENTHETICAL_REACH).some((token) => token.surface === ",");
+
+export const danglingOpenerIn = (
+  source: string,
+  tokens: readonly Token[],
+  subjects: ReadonlySet<string>,
+  exempt: readonly string[],
+): DanglingOpener | undefined => {
+  const [first] = tokens;
+  if (first === undefined || !isPresentParticiple(first) || opensWithExempt(tokens, exempt)) return undefined;
+  const comma = tokens.findIndex((token, at) => at > 0 && token.surface === ",");
+  const subject = tokens[comma + 1];
+  if (comma === -1 || comma > MAX_OPENER_TOKENS || subject === undefined || !subjects.has(lower(subject)) || !isBeAfter(tokens, comma + 2)) return undefined;
+  if (isParenthetical(tokens, comma + 3)) return undefined;
+  const last = tokens[comma - 1] ?? first;
+  return { opener: source.slice(first.span.start, last.span.end), subject, offset: first.span.start };
+};
+
+const patternsIn = (lexicon: Lexicon, group: string): string[] => lexicon.filter((entry) => entry.group === group).map((entry) => entry.pattern.toLowerCase());
+
+export const danglingOpener: Detector = (doc): Finding[] => {
+  const words = doc.lexicons["dangling-participle"] ?? [];
+  const subjects = new Set(patternsIn(words, "subject"));
+  const exempt = patternsIn(words, "exempt");
+  return doc.sentences.flatMap((sentence) => {
+    const found = sentence.embeddedLanguage === undefined ? danglingOpenerIn(doc.source, sentence.tokens ?? [], subjects, exempt) : undefined;
+    if (found === undefined) return [];
+    return [
+      {
+        rule: "",
+        severity: "info",
+        line: 0,
+        column: 0,
+        quote: sentence.text.trim(),
+        values: { opener: found.opener, subject: found.subject.surface, offset: found.offset },
+      },
+    ];
+  });
+};

package/src/detectors/footnote-mismatch.ts

@@ -0,0 +1,72 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 注の無い注の印と、本文が一度も付けない注。Markdown の脚注（[^1] と行頭の [^1]:）と、語彙表 note-mark の印（※1 と行頭の ※1）を読む。
+
+/** 合わない注 1 つ。missing は印に注が無い、unused は注に印が無い。label は書いたままの印（[^1]、※1）。 */
+export type NoteSlip = { readonly offset: number; readonly label: string; readonly reason: "missing" | "unused" };
+
+/** 印 1 つ。kind は印の種類（markdown か note-mark の語）、key は番号、note は行の頭の注そのものか。 */
+type NoteMark = { readonly offset: number; readonly label: string; readonly kind: string; readonly key: string; readonly note: boolean };
+
+const MARKDOWN = "markdown";
+const FULLWIDTH_OFFSET = 0xfee0;
+/** 行の頭から印までに来てよいもの（字下げ、箇条書きの印、開き括弧）。 */
+const NOTE_LINE_HEAD = /^[ \t]*(?:[-*+][ \t]+)?[（(]?$/u;
+
+const halfWidth = (text: string): string => text.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+const lineHeadOf = (text: string, offset: number): string => text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset);
+
+/** Markdown の脚注。名前は大文字と小文字を区別しない（CommonMark の参照と同じ）。 */
+const markdownMarks = (text: string): NoteMark[] =>
+  [...text.matchAll(/\[\^(?<key>[^\]\s]+)\](?<colon>:)?/gu)].map((match) => {
+    const note = match.groups?.["colon"] !== undefined && /^[ \t]{0,3}$/u.test(lineHeadOf(text, match.index));
+    return { offset: match.index, label: `[^${match.groups?.["key"] ?? ""}]`, kind: MARKDOWN, key: (match.groups?.["key"] ?? "").toLowerCase(), note };
+  });
+
+/** 印と一桁か二桁の番号。後ろに数字や小数が続けば年や数（※2018年度、※1.2倍）で、注の番号ではない。 */
+const wordMarks = (text: string, mark: string): NoteMark[] =>
+  [...text.matchAll(new RegExp(`${escapeRegExp(mark)}(?<key>[0-9０-９]{1,2})(?![0-9０-９]|[.．,，][0-9０-９])`, "gu"))].map((match) => ({
+    offset: match.index,
+    label: match[0],
+    kind: mark,
+    key: halfWidth(match.groups?.["key"] ?? ""),
+    note: NOTE_LINE_HEAD.test(lineHeadOf(text, match.index)),
+  }));
+
+/** 一つの種類の印のうち、合わないもの。印の語（※）は、その種類の注が一つも無ければ注を別に置いた文書と読んで言わない。 */
+const slipsOfKind = (marks: readonly NoteMark[], kind: string): NoteSlip[] => {
+  const ofKind = marks.filter((mark) => mark.kind === kind);
+  const notes = new Set(ofKind.filter((mark) => mark.note).map((mark) => mark.key));
+  const referenced = new Set(ofKind.filter((mark) => !mark.note).map((mark) => mark.key));
+  if (notes.size === 0 && kind !== MARKDOWN) return [];
+  const missing = ofKind
+    .filter((mark) => !mark.note && !notes.has(mark.key))
+    .map((mark): NoteSlip => ({ offset: mark.offset, label: mark.label, reason: "missing" }));
+  const unused = ofKind
+    .filter((mark) => mark.note && !referenced.has(mark.key))
+    .map((mark): NoteSlip => ({ offset: mark.offset, label: mark.label, reason: "unused" }));
+  return [...missing, ...unused];
+};
+
+/** 文字列の中の、注の無い印と印の無い注。 */
+export const noteSlips = (text: string, words: readonly string[]): NoteSlip[] => {
+  const marks = [...markdownMarks(text), ...words.flatMap((word) => wordMarks(text, word))];
+  return [...new Set(marks.map((mark) => mark.kind))].flatMap((kind) => slipsOfKind(marks, kind)).toSorted((left, right) => left.offset - right.offset);
+};
+
+export const footnoteMismatch: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const words = (doc.lexicons["note-mark"] ?? []).map((entry) => entry.pattern);
+  return noteSlips(text, words).map((slip) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, slip.offset, slip.offset + slip.label.length),
+    values: { label: slip.label, offset: slip.offset },
+    variant: slip.reason,
+  }));
+};

package/src/detectors/form-minority.ts

@@ -0,0 +1,21 @@
+// 一つの文書の中で、同じものを何通りかに書いたときの少ないほう。どの書き方が正しいかは決めない。
+
+/** 少ないほうの書き方のものと、いちばん多い書き方の例。 */
+export type FormMinority<T> = { readonly odd: readonly T[]; readonly usual: T };
+
+const PERCENT = 100;
+
+/**
+ * いちばん多い書き方と違うもの。少ないほうが limit パーセントを超えれば使い分けている文書と読んで言わない。
+ * いちばん多い書き方が同じ数で並べば、どちらにも立たない。
+ */
+export const formMinority = <T extends { readonly form: string }>(items: readonly T[], limit: number): FormMinority<T> | undefined => {
+  const counts = new Map<string, number>();
+  items.forEach((item) => counts.set(item.form, (counts.get(item.form) ?? 0) + 1));
+  const [top, second] = [...counts].toSorted((left, right) => right[1] - left[1]);
+  if (top === undefined || second === undefined || top[1] === second[1]) return undefined;
+  const odd = items.filter((item) => item.form !== top[0]);
+  const usual = items.find((item) => item.form === top[0]);
+  if (usual === undefined || odd.length * PERCENT > items.length * limit) return undefined;
+  return { odd, usual };
+};