chaffjs 0.21.0 → 0.22.0

package/src/detectors/heading-end-mark.ts

@@ -0,0 +1,82 @@
+import type { Detector, Finding, MarkupHeading, ProseDocument } from "../plugin.ts";
+import { findingAt, writtenHeadings } from "./markup-finding.ts";
+import { pageTitleOf } from "./heading-case.ts";
+import { minorityWithin } from "../orthography.ts";
+
+/** A mark a heading may end with or go without: a colon or a full stop, in either width. A question mark belongs to the words. */
+const END_MARK = /[:：.。]$/u;
+
+/** An ellipsis: the full stops are the words trailing off. */
+const ELLIPSIS = /(?:\.\.\.|…)$/u;
+
+/** Emphasis closed at the very end (`## **Note:**`): the mark the reader sees is the one before it. */
+const EMPHASIS_MARKS = new Set(["*", "_"]);
+
+const withoutClosingEmphasis = (text: string): string => {
+  const kept = [...text];
+  while (EMPHASIS_MARKS.has(kept.at(-1) ?? "")) kept.pop();
+  return kept.join("");
+};
+
+const LETTER = /\p{L}/u;
+
+/** Past this share, both ways are in use on purpose, and neither is the odd one. */
+const MINORITY_PERCENT = 25;
+
+/** Fewer section headings than this, and the majority is not yet a habit. */
+const MIN_HEADINGS = 4;
+
+/** Whether the heading's last word is one that ends in a full stop of its own (etc., Inc., from the lexicon). */
+const endsWithWord = (shown: string, words: readonly string[]): boolean =>
+  words.some((word) => shown.endsWith(word) && !LETTER.test(shown.charAt(shown.length - word.length - 1)));
+
+/** The mark a heading ends with, "" for none, or undefined when its last full stop belongs to its words. */
+export const endMarkOf = (heading: string, words: readonly string[] = []): string | undefined => {
+  const shown = withoutClosingEmphasis(heading.trim()).trimEnd();
+  if (ELLIPSIS.test(shown) || endsWithWord(shown, words)) return undefined;
+  return END_MARK.exec(shown)?.[0] ?? "";
+};
+
+type Judged = { readonly heading: MarkupHeading; readonly mark: string };
+
+/** The odd ones among headings of one depth, each with the usual side's first heading and count. */
+const oddAtDepth = (doc: ProseDocument, judged: readonly Judged[]): Finding[] => {
+  if (judged.length < MIN_HEADINGS) return [];
+  const odd = minorityWithin(judged, (entry) => entry.mark !== "", MINORITY_PERCENT);
+  const usual = judged.filter((entry) => !odd.includes(entry));
+  const example = usual[0]?.heading.text.trim() ?? "";
+  return odd.map((entry) =>
+    findingAt(
+      doc,
+      entry.heading,
+      { heading: entry.heading.text.trim(), mark: entry.mark, example, count: usual.length },
+      entry.mark === "" ? "bare" : "marked",
+    ),
+  );
+};
+
+/**
+ * Headings that end with a colon or a full stop where most headings of the same depth do not, or the other way round. Headings
+ * of one depth are one kind of heading; a depth of labels ("Optional:") is its own way. The page title (one top-level heading
+ * that opens the document) is a name and is not compared.
+ */
+export const headingEndMark: Detector = (doc, options): Finding[] => {
+  const words = (options.lexicon ?? []).map((entry) => entry.pattern);
+  const headings = writtenHeadings(doc);
+  const title = pageTitleOf(headings);
+  const judged = headings
+    .filter((heading) => heading !== title)
+    .flatMap((heading): Judged[] => {
+      const mark = endMarkOf(heading.text, words);
+      return mark === undefined ? [] : [{ heading, mark }];
+    });
+  const depths = [...new Set(judged.map((entry) => entry.heading.depth))];
+  return depths
+    .flatMap((depth) =>
+      oddAtDepth(
+        doc,
+        judged.filter((entry) => entry.heading.depth === depth),
+      ),
+    )
+    .toSorted((left, right) => Number(left.values["offset"]) - Number(right.values["offset"]));
+};

package/src/detectors/list-marker.ts

@@ -0,0 +1,60 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { findingAt, markupOf } from "./markup-finding.ts";
+import { readMarkdown } from "../markdown-read.ts";
+import { readLists, type ListMark } from "../list-marks.ts";
+
+/** Fewer lists than this at one depth, and the majority bullet is not yet a habit. */
+const MIN_LISTS = 3;
+
+/** Past this share, the document uses both bullets on purpose. */
+const MINORITY_PERCENT = 25;
+
+const PERCENT = 100;
+
+/** The length of the bullet quoted: the bullet itself. */
+const BULLET_LENGTH = 1;
+
+const at = (doc: ProseDocument, start: number, values: Readonly<Record<string, string | number>>, variant: string): Finding =>
+  findingAt(doc, { start, end: start + BULLET_LENGTH }, values, variant);
+
+/** The bullet most lists use; undefined on a tie. */
+const majorityOf = (lists: readonly ListMark[]): { readonly mark: string; readonly count: number } | undefined => {
+  const counts = [...lists.reduce((acc, list) => acc.set(list.mark, (acc.get(list.mark) ?? 0) + 1), new Map<string, number>())].toSorted(
+    ([, left], [, right]) => right - left,
+  );
+  const [first, second] = counts;
+  return first === undefined || second?.[1] === first[1] ? undefined : { mark: first[0], count: first[1] };
+};
+
+/** Lists whose bullet differs from the one most lists of the same depth use, while those are the few. */
+const minorityAt = (doc: ProseDocument, lists: readonly ListMark[]): Finding[] => {
+  const majority = lists.length < MIN_LISTS ? undefined : majorityOf(lists);
+  if (majority === undefined) return [];
+  const odd = lists.filter((list) => list.mark !== majority.mark);
+  if (odd.length * PERCENT > MINORITY_PERCENT * lists.length) return [];
+  return odd.map((list) => at(doc, list.start, { mark: list.mark, usual: majority.mark, count: majority.count }, "document"));
+};
+
+/** A list written right after another in the same place with another bullet: Markdown starts a new list where the bullet changes. */
+const splitAt = (doc: ProseDocument, list: ListMark): Finding[] =>
+  list.previous === undefined || list.previous === list.mark ? [] : [at(doc, list.start, { mark: list.mark, usual: list.previous }, "split")];
+
+/**
+ * Bullets mixed in one list or one document: a list that changes bullet partway (`-` then `*`, which Markdown splits in two),
+ * a `・` line inside a list item (Markdown joins it to the item), and a list whose bullet differs from most lists at its depth.
+ */
+export const listMarkerMix: Detector = (doc): Finding[] => {
+  if (markupOf(doc) === undefined) return [];
+  const { lists, foldedTyped } = readLists(doc.source, readMarkdown(doc.source).root);
+  const split = lists.flatMap((list) => splitAt(doc, list));
+  const folded = foldedTyped.map((start) => at(doc, start, { mark: "・" }, "folded"));
+  const reported = new Set(split.map((finding) => finding.values["offset"]));
+  const byDepth = new Map<number, ListMark[]>();
+  lists.forEach((list) => {
+    const same = byDepth.get(list.depth) ?? [];
+    same.push(list);
+    byDepth.set(list.depth, same);
+  });
+  const minority = [...byDepth.values()].flatMap((same) => minorityAt(doc, same)).filter((finding) => !reported.has(finding.values["offset"]));
+  return [...split, ...folded, ...minority].toSorted((left, right) => Number(left.values["offset"]) - Number(right.values["offset"]));
+};

package/src/detectors/markdown-slip.ts

@@ -0,0 +1,140 @@
+// Markdown that does not render the way it was written: a table row with more cells than its header (GFM drops the
+// extra ones), a code fence that is never closed (the rest of the document becomes code), and strong-emphasis marks
+// (`**`) that Markdown cannot pair and shows as they are. Pure; reads the source's Markdown tree.
+import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
+import { readMarkdown } from "../markdown-read.ts";
+import { spanOf, type MarkdownNode } from "../markdown-node.ts";
+import { findingAt, markupOf } from "./markup-finding.ts";
+
+/** Quotations are someone else's text, and their markup is theirs. */
+const QUOTED = "blockquote";
+
+/** Nodes of one type outside quotations, in source order. Walks with its own stack: Markdown nests without limit. */
+const nodesOf = (root: MarkdownNode, type: string): MarkdownNode[] => {
+  const found: MarkdownNode[] = [];
+  const pending: MarkdownNode[] = [root];
+  for (let node = pending.pop(); node !== undefined; node = pending.pop()) {
+    if (node.type === QUOTED) continue;
+    if (node.type === type) found.push(node);
+    (node.children ?? []).toReversed().forEach((child) => pending.push(child));
+  }
+  return found;
+};
+
+const markdownRoot = (doc: ProseDocument): MarkdownNode | undefined => (markupOf(doc) === undefined ? undefined : readMarkdown(doc.source).root);
+
+/** An HTML comment: a cell holding only one shows the reader nothing, and losing it loses nothing. */
+const COMMENT = /<!--[\s\S]*?-->/gu;
+
+/** Whether a cell shows the reader anything: its source without the bars, comments and spaces. */
+const cellShows = (source: string, cell: MarkdownNode): boolean => {
+  const span = spanOf(cell);
+  return span !== undefined && source.slice(span.start, span.end).replaceAll("|", "").replace(COMMENT, "").trim() !== "";
+};
+
+/**
+ * A body row with more cells than the header: GFM shows only as many cells as the header has, and drops the rest. Extra cells
+ * that are empty or hold only a comment lose nothing and are not reported.
+ */
+export const tableRowOverflow: Detector = (doc): Finding[] => {
+  const root = markdownRoot(doc);
+  if (root === undefined) return [];
+  return nodesOf(root, "table").flatMap((table) => {
+    const [header, ...body] = table.children ?? [];
+    const columns = header?.children?.length ?? 0;
+    return body.flatMap((row) => {
+      const cells = row.children ?? [];
+      const span = spanOf(row);
+      const lost = cells.slice(columns).some((cell) => cellShows(doc.source, cell));
+      return lost && span !== undefined ? [findingAt(doc, span, { cells: cells.length, columns })] : [];
+    });
+  });
+};
+
+/** A fence opening a code block: three or more backticks or tildes, after up to three spaces. */
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/u;
+
+/** A closing fence may sit at most this many columns further in than the container's text; four in, it is code. */
+const MAX_FENCE_INDENT = 3;
+
+const TAB_WIDTH = 4;
+
+const indentOf = (line: string): number =>
+  Array.from(line.slice(0, line.length - line.trimStart().length)).reduce((width, char) => width + (char === "\t" ? TAB_WIDTH : 1), 0);
+
+/** Whether a line closes a fence: not indented past the limit, the same character, at least as many, and nothing after but spaces. */
+const closes = (line: string, fence: string, maxIndent: number): boolean => {
+  const trimmed = line.trim();
+  const mark = fence.charAt(0);
+  return indentOf(line) <= maxIndent && trimmed.length >= fence.length && [...trimmed].every((char) => char === mark);
+};
+
+/** The opening fence of a code block that is never closed; undefined for a closed or an indented block. */
+const unclosedFenceOf = (source: string, span: Span): Span | undefined => {
+  const lines = source.slice(span.start, span.end).split("\n");
+  const first = lines[0] ?? "";
+  const fence = FENCE_OPEN.exec(first)?.[1];
+  if (fence === undefined) return undefined;
+  const column = span.start - (source.lastIndexOf("\n", span.start - 1) + 1);
+  const last = lines.length > 1 ? (lines.at(-1) ?? "") : "";
+  return closes(last, fence, column + MAX_FENCE_INDENT) ? undefined : { start: span.start, end: span.start + first.trimEnd().length };
+};
+
+/**
+ * A fenced code block with no closing fence. Markdown runs it to the end of the document (or of the list item it is in), so
+ * everything after the opening fence shows as code. Reported at the opening fence.
+ */
+export const unclosedCodeFence: Detector = (doc): Finding[] => {
+  const root = markdownRoot(doc);
+  if (root === undefined) return [];
+  return nodesOf(root, "code").flatMap((code) => {
+    const span = spanOf(code);
+    const open = span === undefined ? undefined : unclosedFenceOf(doc.source, span);
+    return open === undefined ? [] : [findingAt(doc, open, { fence: doc.source.slice(open.start, open.end).trim() })];
+  });
+};
+
+/** `**` or `__` left in text: Markdown would have made it strong emphasis if it could pair it. Longer runs are rules or blanks to fill. */
+const STRONG_RUN = /(?<![*_])(?:\*\*|__)(?![*_])/gu;
+
+/** A run with Latin letters or digits on both sides (`2**10`, `snake__case`) is part of the word. Japanese has no spaces, so 「は**金」 is a mark. */
+const WORD_CHAR = /[A-Za-z0-9]/u;
+
+const isSpace = (char: string): boolean => char === "" || /\s/u.test(char);
+
+/** Python's dunder names (`__init__`) written outside code. */
+const DUNDER = /__\w+__/u;
+
+const dunderAround = (text: string, run: Span): boolean => {
+  const start = text.lastIndexOf(" ", run.start) + 1;
+  const end = text.indexOf(" ", run.end);
+  return DUNDER.test(text.slice(start, end === -1 ? text.length : end));
+};
+
+/** The strong-emphasis runs in one text node that Markdown left as text. */
+export const strayStrongRuns = (text: string): Span[] =>
+  [...text.matchAll(STRONG_RUN)].flatMap((match) => {
+    const run = { start: match.index, end: match.index + match[0].length };
+    const before = text.charAt(run.start - 1);
+    const after = text.charAt(run.end);
+    if (before === "\\" || (WORD_CHAR.test(before) && WORD_CHAR.test(after))) return [];
+    if (isSpace(before) && isSpace(after)) return [];
+    return dunderAround(text, run) ? [] : [run];
+  });
+
+/**
+ * `**` or `__` that Markdown shows as it is: strong emphasis left open (`**bold`), or one CommonMark cannot close because a
+ * bracket or a quotation mark touches the mark from inside while a letter touches it from outside (`**「重要」**です`).
+ */
+export const unrenderedEmphasis: Detector = (doc): Finding[] => {
+  const root = markdownRoot(doc);
+  if (root === undefined) return [];
+  return nodesOf(root, "text").flatMap((node) => {
+    const span = spanOf(node);
+    if (span === undefined) return [];
+    const written = doc.source.slice(span.start, span.end);
+    return strayStrongRuns(written).map((run) =>
+      findingAt(doc, { start: span.start + run.start, end: span.start + run.end }, { mark: written.slice(run.start, run.end) }),
+    );
+  });
+};

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/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/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/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-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/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/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/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/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/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/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/unrendered-emphasis.ts

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