chaffjs 0.21.0 → 0.23.0

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/ellipsis.ts

@@ -0,0 +1,74 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { formMinority } from "./form-minority.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// One document writing an ellipsis two ways ("..." and "…", "……" and "・・・"). Neither is called right; the less common is
+// reported. The forms come from each language's lexicon "ellipsis".
+
+/** One ellipsis as written. form is the lexicon's pattern it matched. */
+export type WrittenEllipsis = { readonly offset: number; readonly form: string };
+
+/** Characters an ellipsis is made of. A longer run ("....", "…・") is not read, since its form is unclear. */
+const ELLIPSIS_PART = "[.．…・‥]";
+
+/** A digit or a slash beside the dots: a range (1...10), a path (docs/.../index.md) or a page number after a leader (第1章・・・3). */
+const NOT_PROSE_BESIDE = /[\p{N}/]/u;
+/** The rest of a line after a leader in a table of contents ("Intro ... 12"). */
+const PAGE_NUMBER_LINE = /^\s*\p{N}+\s*(?:\n|$)/u;
+/** A word holding a scheme or a slash around the dots is an address (https://example.com/a...b). */
+const ADDRESS_WORD = /:\/\/|\//u;
+
+const SPACE = /\s/u;
+
+/** The run of non-space characters holding the dots. */
+const wordAround = (text: string, start: number, end: number): string => {
+  const from =
+    text
+      .slice(0, start)
+      .split("")
+      .findLastIndex((char) => SPACE.test(char)) + 1;
+  const after = text
+    .slice(end)
+    .split("")
+    .findIndex((char) => SPACE.test(char));
+  return text.slice(from, after === -1 ? text.length : end + after);
+};
+
+/** Dots that are not an ellipsis in running text: a range, a path or address, a table of contents leader. */
+const isNotProse = (text: string, start: number, end: number): boolean =>
+  NOT_PROSE_BESIDE.test(text.charAt(start - 1)) ||
+  NOT_PROSE_BESIDE.test(text.charAt(end)) ||
+  PAGE_NUMBER_LINE.test(text.slice(end)) ||
+  ADDRESS_WORD.test(wordAround(text, start, end));
+
+/** The ellipses in a text, matched longest form first, standing alone (not part of a longer run of dots). */
+export const ellipsesIn = (text: string, forms: readonly string[]): WrittenEllipsis[] => {
+  if (forms.length === 0) return [];
+  const alternatives = forms
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+  const pattern = new RegExp(`(?<!${ELLIPSIS_PART})(?:${alternatives})(?!${ELLIPSIS_PART})`, "gu");
+  return [...text.matchAll(pattern)].flatMap((match) =>
+    isNotProse(text, match.index, match.index + match[0].length) ? [] : [{ offset: match.index, form: match[0] }],
+  );
+};
+
+export const ellipsisConsistency: Detector = (doc, options): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const ellipses = ellipsesIn(
+    text,
+    (doc.lexicons["ellipsis"] ?? []).map((entry) => entry.pattern),
+  );
+  const minority = formMinority(ellipses, options.limit);
+  if (minority === undefined) return [];
+  return minority.odd.map((ellipsis) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, ellipsis.offset, ellipsis.offset + ellipsis.form.length),
+    values: { written: ellipsis.form, usual: minority.usual.form, count: minority.odd.length, of: ellipses.length, offset: ellipsis.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 };
+};

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) }),
+    );
+  });
+};