chaffjs 0.20.0 → 0.22.0

package/src/detectors/impossible-time.ts

@@ -0,0 +1,151 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 時計に無い時刻（午後13時、13 PM、10:75、9時75分）。午前・午後が付けば時は 12 まで、分と秒は 59 まで。
+// 午前・午後の語とその置き場所は語彙表 clock-meridiem、時・分・秒の単位は date-time-unit（大きい順の四つ目から）が言う。
+// 午前・午後の無い「25:00」は、深夜の番組表のように 24 を超えて数える書き方があるので言わない。
+
+/** 時刻を読むのに要る語。before は時刻の前に書く午前・午後、after は後ろに書く AM・PM、units は時・分・秒の単位。 */
+export type ClockWords = { readonly before: readonly string[]; readonly after: readonly string[]; readonly units: readonly string[] };
+
+/** 時計に無い時刻 1 つ。reason は、午前・午後の付いた時が 12 を超える（hour）か、分か秒が 59 を超える（minute）か。 */
+export type ImpossibleTime = { readonly offset: number; readonly written: string; readonly reason: "hour" | "minute" };
+
+const DIGIT = "[0-9０-９]";
+const COLON = "[:：]";
+/** 数の前後に来ない字。英字の語や番号の中（abc10:75、v10:75）は時刻ではない。日本語の字のすぐ後ろ（会議は10:75）は読む。 */
+const NOT_AFTER_CLOCK = "(?<![A-Za-z0-9０-９_:：.])";
+const NOT_BEFORE_CLOCK = "(?![A-Za-z0-9０-９_:：])";
+const HALF_DAY = 12;
+const MINUTES_IN_HOUR = 60;
+/** 午前・午後の付いた時で、時刻の書き損じと読む上限。50 pm（ピコメートル）のような量を時刻と読まない。 */
+const HOURS_IN_DAY = 24;
+const FULLWIDTH_OFFSET = 0xfee0;
+
+const halfWidth = (text: string): string => text.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET));
+
+type Groups = Readonly<Record<string, string | undefined>>;
+
+const numberIn = (groups: Groups, name: string): number | undefined => {
+  const written = groups[name];
+  return written === undefined ? undefined : Number(halfWidth(written));
+};
+
+/** 分か秒が 59 を超えるか。 */
+const isPastMinute = (groups: Groups): boolean =>
+  ["m", "colonMinute", "s"].some((name) => {
+    const value = numberIn(groups, name);
+    return value !== undefined && value >= MINUTES_IN_HOUR;
+  });
+
+/** 午前・午後の付いた時が 12 を超えるか（24 まで）。 */
+const isPastHalfDay = (groups: Groups): boolean => {
+  const hour = numberIn(groups, "h") ?? 0;
+  return hour > HALF_DAY && hour <= HOURS_IN_DAY;
+};
+
+/** 時刻の書き方と、その中の書き損じの見分け方。 */
+type Shape = { readonly pattern: RegExp; readonly problem: (groups: Groups, text: string, at: number) => ImpossibleTime["reason"] | undefined };
+
+const withMeridiem = (groups: Groups): ImpossibleTime["reason"] | undefined => {
+  if (isPastHalfDay(groups)) return "hour";
+  return isPastMinute(groups) ? "minute" : undefined;
+};
+
+const minutesOnly = (groups: Groups): ImpossibleTime["reason"] | undefined => (isPastMinute(groups) ? "minute" : undefined);
+
+/** 「Genesis 24:67」「Science, 12:75」のような章と節、巻と頁は時刻ではない。頭が大文字の語や区切りの印のすぐ後ろは読まない。 */
+const isCitationBefore = (before: string): boolean => {
+  const trimmed = before.trimEnd();
+  if ([",", ";", "."].includes(trimmed.slice(-1))) return true;
+  const lastWord = trimmed.split(/\s/u).at(-1) ?? "";
+  return /^\p{Lu}/u.test(lastWord);
+};
+
+/** 時を 2 以上か 0 埋め（09:75）で書いた、時と分だけの時刻。1:75 は縮尺や比。 */
+const bareClock = (groups: Groups, text: string, at: number): ImpossibleTime["reason"] | undefined => {
+  const hourText = groups["h"] ?? "";
+  const hour = Number(halfWidth(hourText));
+  const looksLikeClock = hour <= HOURS_IN_DAY && (hour >= 2 || /^[0０]/u.test(hourText));
+  if (!looksLikeClock || isCitationBefore(text.slice(Math.max(0, at - HALF_DAY), at))) return undefined;
+  return minutesOnly(groups);
+};
+
+const alternation = (words: readonly string[]): string => words.map(escapeRegExp).join("|");
+
+const meridiemShapes = (words: ClockWords): Shape[] => {
+  const [hourUnit, minuteUnit] = words.units.map(escapeRegExp);
+  const before = alternation(words.before);
+  const after = alternation(words.after);
+  const minuteTail = minuteUnit === undefined ? "" : `(?:\\s?(?<m>${DIGIT}{1,2})${minuteUnit})?`;
+  const unitTail = hourUnit === undefined ? "" : `${hourUnit}${minuteTail}|`;
+  return [
+    ...(after === ""
+      ? []
+      : [
+          {
+            pattern: new RegExp(`${NOT_AFTER_CLOCK}(?<![,])(?<h>${DIGIT}{1,2})(?:${COLON}(?<m>${DIGIT}{2}))?\\s?(?:${after})(?![\\p{L}\\p{N}])`, "gu"),
+            problem: withMeridiem,
+          },
+        ]),
+    ...(before === ""
+      ? []
+      : [{ pattern: new RegExp(`(?:${before})\\s?(?<h>${DIGIT}{1,2})(?:${unitTail}[:：](?<colonMinute>${DIGIT}{2}))`, "gu"), problem: withMeridiem }]),
+  ];
+};
+
+const unitShapes = (words: ClockWords): Shape[] => {
+  const [hourUnit, minuteUnit, secondUnit] = words.units.map(escapeRegExp);
+  if (hourUnit === undefined || minuteUnit === undefined) return [];
+  const seconds = secondUnit === undefined ? "" : `(?:\\s?(?<s>${DIGIT}{1,2})${secondUnit})?`;
+  return [{ pattern: new RegExp(`(?<!${DIGIT})(?<h>${DIGIT}{1,2})${hourUnit}\\s?(?<m>${DIGIT}{1,2})${minuteUnit}${seconds}`, "gu"), problem: minutesOnly }];
+};
+
+const shapesOf = (words: ClockWords): Shape[] => [
+  ...meridiemShapes(words),
+  ...unitShapes(words),
+  {
+    pattern: new RegExp(`${NOT_AFTER_CLOCK}(?<h>${DIGIT}{1,3})${COLON}(?<m>${DIGIT}{2})${COLON}(?<s>${DIGIT}{2})${NOT_BEFORE_CLOCK}`, "gu"),
+    problem: minutesOnly,
+  },
+  { pattern: new RegExp(`${NOT_AFTER_CLOCK}(?<![,/])(?<h>${DIGIT}{1,2})${COLON}(?<m>${DIGIT}{2})${NOT_BEFORE_CLOCK}`, "gu"), problem: bareClock },
+];
+
+const impossibleIn = (text: string, shape: Shape): ImpossibleTime[] =>
+  [...text.matchAll(shape.pattern)].flatMap((match) => {
+    const reason = shape.problem(match.groups ?? {}, text, match.index);
+    return reason === undefined ? [] : [{ offset: match.index, written: match[0].trim(), reason }];
+  });
+
+const overlaps = (left: ImpossibleTime, right: ImpossibleTime): boolean =>
+  left.offset < right.offset + right.written.length && right.offset < left.offset + left.written.length;
+
+/** 文字列の中の、時計に無い時刻。重なる所に二つの形が当たれば、先の形（午前・午後の付いたもの）だけ。 */
+export const impossibleTimes = (text: string, words: ClockWords): ImpossibleTime[] =>
+  shapesOf(words)
+    .flatMap((shape) => impossibleIn(text, shape))
+    .reduce<ImpossibleTime[]>((kept, found) => (kept.some((earlier) => overlaps(earlier, found)) ? kept : [...kept, found]), [])
+    .toSorted((left, right) => left.offset - right.offset);
+
+const meridiemOf = (doc: ProseDocument, position: "before" | "after"): string[] =>
+  (doc.lexicons["clock-meridiem"] ?? []).filter((entry) => entry.position === position).map((entry) => entry.pattern);
+
+export const clockWordsOf = (doc: ProseDocument): ClockWords => ({
+  before: meridiemOf(doc, "before"),
+  after: meridiemOf(doc, "after"),
+  units: (doc.lexicons["date-time-unit"] ?? []).map((entry) => entry.pattern).slice(3),
+});
+
+export const impossibleTime: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return impossibleTimes(text, clockWordsOf(doc)).map((found) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, found.offset, found.offset + found.written.length),
+    values: { written: found.written, offset: found.offset },
+    variant: found.reason,
+  }));
+};

package/src/detectors/link-shape.ts

@@ -0,0 +1,70 @@
+import type { Detector, Finding, Markup, ProseDocument, Span } from "../plugin.ts";
+import { findingAt, markupOf, quoteOf } from "./markup-finding.ts";
+import { linkTextOf } from "../link-text.ts";
+import { bareUrls } from "../bare-url.ts";
+import { isFileNameAlt, isUrlText, mismatchedHost } from "../link-shape.ts";
+import { minorityWithin } from "../orthography.ts";
+import { readMarkdown, spansOfType } from "../markdown-read.ts";
+
+/** A bare URL is reported only while bare URLs are at most this share of the document's links; past it, bare is a style. */
+const BARE_SHARE_PERCENT = 25;
+
+/** The link text, or undefined for an autolink, a definition or a link whose text is itself an address. */
+const wordedText = (source: string, link: Span): string | undefined => {
+  const text = linkTextOf(source.slice(link.start, link.end));
+  return text === undefined || text.trim() === "" || isUrlText(text) ? undefined : text;
+};
+
+/** An inline link the reader clicks on words (`[text](url)`). A reference definition's span does not show the words used with it, so it is not counted. */
+const isWorded = (source: string, link: Span): boolean => wordedText(source, link) !== undefined;
+
+/** A link destination the parser gave up on (`[a](https://…/{{ page }})`, a space in it): what is left is a link, not a bare URL. */
+const FAILED_DESTINATION = "](";
+
+const inside = (span: Span, regions: readonly Span[]): boolean => regions.some((region) => span.start >= region.start && span.start < region.end);
+
+/**
+ * The bare URLs the reader sees as text (outside links, code and quotations). A URL in a table cell is a value the table lists
+ * (an example request, a field's content), not a link the prose points to, so tables are left out.
+ */
+const bareUrlSpans = (source: string, markup: Markup): Span[] => {
+  const tables = spansOfType(readMarkdown(source).root, "table");
+  return markup.texts.flatMap((text) =>
+    bareUrls(source.slice(text.start, text.end))
+      .map((url) => ({ start: text.start + url.start, end: text.start + url.end }))
+      .filter((url) => !source.startsWith(FAILED_DESTINATION, url.start - FAILED_DESTINATION.length) && !inside(url, tables)),
+  );
+};
+
+type Address = Span & { readonly bare: boolean };
+
+/**
+ * A URL written bare (`https://…`) in a document whose other links are words (`[the guide](https://…)`). Reported only when the
+ * document has at least `limit` worded links and the bare ones are the few; a document that writes its URLs bare throughout is not.
+ */
+export const bareUrlMix: Detector = (doc: ProseDocument, options): Finding[] => {
+  const markup = markupOf(doc);
+  if (markup === undefined) return [];
+  const worded: Address[] = markup.links.filter((link) => isWorded(doc.source, link)).map((link) => ({ ...link, bare: false }));
+  if (worded.length < options.limit) return [];
+  const bare: Address[] = bareUrlSpans(doc.source, markup).map((url) => ({ ...url, bare: true }));
+  return minorityWithin([...worded, ...bare], (address) => address.bare, BARE_SHARE_PERCENT)
+    .filter((address) => address.bare)
+    .map((address) => findingAt(doc, address, { url: quoteOf(doc.source, address), count: worded.length }));
+};
+
+/** A link whose text is an address on one host and whose destination is on another (`[https://a.example](https://b.example)`). */
+export const linkTextUrlMismatch: Detector = (doc): Finding[] =>
+  (markupOf(doc)?.links ?? []).flatMap((link) => {
+    const text = linkTextOf(doc.source.slice(link.start, link.end));
+    const hosts = text === undefined ? undefined : mismatchedHost(text, link.destination);
+    return hosts === undefined ? [] : [findingAt(doc, link, hosts)];
+  });
+
+/** An image whose alt text is its file's name (`IMG_1234.png`, `Screenshot 2026-04-01`). The name prefixes come from the lexicon. */
+export const imageFileNameAlt: Detector = (doc, options): Finding[] => {
+  const prefixes = (options.lexicon ?? []).map((entry) => entry.pattern);
+  return (markupOf(doc)?.images ?? []).flatMap((image) =>
+    image.alt !== undefined && isFileNameAlt(image.alt, prefixes) ? [findingAt(doc, image, { alt: image.alt.trim() })] : [],
+  );
+};

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/mark-shape.ts

@@ -0,0 +1,202 @@
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { minorityReport } from "../spacing-minority.ts";
+import { isWithinAny, quotedSpans } from "../quoted-span.ts";
+
+/** The letters a mark must touch to count as part of the document's text, by language. */
+const SCRIPT: Readonly<Record<string, RegExp>> = {
+  ja: /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー々]/u,
+  en: /\p{Script=Latin}/u,
+};
+
+/** One way of writing a mark: its kind, which of the two ways it is (side), and how the other way writes it. */
+type Form = { readonly kind: string; readonly side: boolean; readonly other: string };
+
+/**
+ * The two ways of writing each kind of mark, from the lexicon: pattern is one way, instead_of the other, group the kind.
+ * Two patterns may share one instead_of (“ and ” both against "), so the other way of a shared mark is both patterns.
+ */
+export const formsOf = (lexicon: Lexicon): ReadonlyMap<string, Form> => {
+  const forms = new Map<string, Form>();
+  lexicon.forEach((entry) => {
+    const kind = entry.group ?? entry.pattern;
+    const shared = entry.instead_of ?? "";
+    forms.set(entry.pattern, { kind, side: true, other: shared });
+    const known = forms.get(shared);
+    forms.set(shared, { kind, side: false, other: `${known?.side === false ? known.other : ""}${entry.pattern}` });
+  });
+  return forms;
+};
+
+export type Mark = { readonly sentence: Sentence; readonly char: string; readonly form: Form; readonly offset: number; readonly spaced: boolean };
+
+/** Punctuation that may stand between a closing or opening mark and the word it belongs to ("draft." and “draft”.). */
+const BETWEEN = /[.,;:!?。、]/u;
+
+/** The letter beside a mark on one side (step -1 or 1), past one punctuation mark. */
+const besideLetter = (text: string, at: number, step: number, script: RegExp): boolean => {
+  const next = text.charAt(at + step);
+  return script.test(next) || (BETWEEN.test(next) && script.test(text.charAt(at + step * 2)));
+};
+
+const touchesScript = (text: string, at: number, script: RegExp): boolean => besideLetter(text, at, -1, script) || besideLetter(text, at, 1, script);
+
+/** The marks in a sentence that touch a letter of the document's script, outside 「」『』 quotations. spaced is the lexicon's pattern side. */
+export const marksIn = (sentence: Sentence, forms: ReadonlyMap<string, Form>, script: RegExp): Mark[] => {
+  const quoted = quotedSpans(sentence.text);
+  return sentence.text.split("").flatMap((char, at) => {
+    const form = forms.get(char);
+    if (form === undefined || !touchesScript(sentence.text, at, script)) return [];
+    if (isWithinAny(quoted, { start: at, end: at })) return [];
+    return [{ sentence, char, form, offset: sentence.span.start + at, spaced: form.side }];
+  });
+};
+
+/** Something written one of two ways (spaced is which), at a place in a sentence. */
+type Sided = { readonly sentence: Sentence; readonly offset: number; readonly spaced: boolean };
+
+const sidedFinding = (item: Sided, values: Finding["values"], variant?: string): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: item.sentence.text.trim(),
+  ...(variant === undefined ? {} : { variant }),
+  values: { ...values, offset: item.offset },
+});
+
+/** The less common way, one finding each, or one finding for a document written both ways (spacing-minority.ts). */
+const minorityFindings = <T extends Sided>(items: readonly T[], limit: number, valuesOf: (item: T) => Finding["values"]): Finding[] => {
+  const report = minorityReport(items, limit);
+  if (report === undefined) return [];
+  if (report.mode === "mixed") {
+    const { first, odd, spaced, touching } = report;
+    return [sidedFinding(first, { ...valuesOf(first), spaced, touching, count: odd, of: items.length, limit }, "mixed")];
+  }
+  return report.odd.map((item) => sidedFinding(item, { ...valuesOf(item), count: report.odd.length, of: items.length, limit }));
+};
+
+/** Sentences written in the document's own language; a quoted sentence in another language follows its own marks. */
+const ownSentences = (doc: ProseDocument): readonly Sentence[] => doc.sentences.filter((sentence) => sentence.embeddedLanguage === undefined);
+
+/**
+ * A mark written two ways in one document (（ and (, “ and "), the less common way reported. The two ways come from the
+ * lexicon; neither is called right. Only marks next to a letter of the document's script count, so a bracket in code-like
+ * text (f(x)) or an English aside in a Japanese document does not.
+ */
+export const markConsistency: Detector = (doc, options): Finding[] => {
+  const script = SCRIPT[doc.language];
+  if (script === undefined) return [];
+  const forms = formsOf(options.lexicon ?? []);
+  const marks = ownSentences(doc).flatMap((sentence) => marksIn(sentence, forms, script));
+  const kinds = [...new Set(marks.map((mark) => mark.form.kind))];
+  return kinds.flatMap((kind) =>
+    minorityFindings(
+      marks.filter((mark) => mark.form.kind === kind),
+      options.limit,
+      (mark) => ({ mark: mark.char, usual: mark.form.other }),
+    ),
+  );
+};
+
+/**
+ * A sentence that surely ends: a lower-case word of two letters or more, then the mark. A number ("11.1."), an abbreviation
+ * ("Req.", "e.g.") or a capital ("U.S.") may be a split the adapter made inside a sentence, where one space is usual.
+ */
+const SENTENCE_END = /(?<![\p{L}\d.])\p{Ll}{2,}[.!?]["'”’)\]]?$/u;
+/** The next sentence starts with a capital, past an opening quote: not a citation ("[ISO99]") or an aside in brackets. */
+const SENTENCE_START = /^["'“‘]?\p{Lu}/u;
+const ONE_SPACE = " ";
+const TWO_SPACES = "  ";
+
+/** The space between two sentences on one line, when the first ends with a period, question or exclamation mark. spaced is two spaces. */
+export const sentenceGaps = (doc: ProseDocument): Sided[] =>
+  ownSentences(doc).flatMap((sentence, at, sentences) => {
+    const next = sentences[at + 1];
+    if (next === undefined || !SENTENCE_END.test(sentence.text) || !SENTENCE_START.test(next.text)) return [];
+    const gap = doc.source.slice(sentence.span.end, next.span.start);
+    if (gap !== ONE_SPACE && gap !== TWO_SPACES) return [];
+    return [{ sentence: next, spaced: gap === TWO_SPACES, offset: sentence.span.end }];
+  });
+
+/** One space between sentences and two, mixed in one document: the less common is reported. */
+export const sentenceSpacing: Detector = (doc, options): Finding[] =>
+  minorityFindings(sentenceGaps(doc), options.limit, (gap) => ({
+    spaces: gap.spaced ? TWO_SPACES.length : ONE_SPACE.length,
+    usual: gap.spaced ? ONE_SPACE.length : TWO_SPACES.length,
+  }));
+
+type Hit = { readonly sentence: Sentence; readonly matched: string; readonly offset: number };
+
+const hitFinding = (hit: Hit, count: number, limit: number): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: hit.sentence.text.trim(),
+  values: { matched: hit.matched, count, limit, offset: hit.offset },
+});
+
+const hitsOf = (sentences: readonly Sentence[], pattern: RegExp): Hit[] =>
+  sentences.flatMap((sentence) =>
+    [...sentence.text.matchAll(pattern)].map((match) => ({ sentence, matched: match[0].trim(), offset: sentence.span.start + match.index })),
+  );
+
+const reportFrom = (hits: readonly Hit[], limit: number): Finding[] => (hits.length < limit ? [] : hits.map((hit) => hitFinding(hit, hits.length, limit)));
+
+/** A spaced hyphen or a double hyphen between words, standing for a dash ("late - very late", "late--very late"). */
+const HYPHEN_DASH = /(?<=[\p{L},;)]) -{1,2} (?=[\p{L}(])|(?<=\p{L})--(?=\p{L})/gu;
+
+export const hyphenDash: Detector = (doc, options): Finding[] => reportFrom(hitsOf(ownSentences(doc), HYPHEN_DASH), options.limit);
+
+/** Every way of writing an abbreviation with some of its periods dropped but not all (e.g. → e.g, eg.). */
+export const partialForms = (abbreviation: string): string[] => {
+  const dots = [...abbreviation].flatMap((char, at) => (char === "." ? [at] : []));
+  const subsets = Array.from({ length: 2 ** dots.length }, (_unused, mask) => dots.filter((_dot, bit) => (mask >> bit) % 2 === 1));
+  return subsets
+    .filter((dropped) => dropped.length > 0 && dropped.length < dots.length)
+    .map((dropped) => [...abbreviation].filter((_char, at) => !dropped.includes(at)).join(""));
+};
+
+/** One partial form as a pattern: its first letter in either case, not inside a word, not followed by a period or letter. */
+const partialPattern = (form: string): string =>
+  `(?<![\\p{L}.])[${form.charAt(0).toLowerCase()}${form.charAt(0).toUpperCase()}]${escapeRegExp(form.slice(1))}(?![\\p{L}.])`;
+
+/** Latin abbreviations from the lexicon (e.g., i.e.) written with only some of their periods (e.g, eg.). */
+export const latinAbbreviation: Detector = (doc, options): Finding[] => {
+  const forms = (options.lexicon ?? []).flatMap((entry) => partialForms(entry.pattern));
+  if (forms.length === 0) return [];
+  const pattern = new RegExp(forms.map(partialPattern).join("|"), "gu");
+  return reportFrom(hitsOf(ownSentences(doc), pattern), options.limit);
+};
+
+/** How many all-capital words in a row read as shouting rather than a run of acronyms. */
+const SHOUT_WORDS = 3;
+const CAPS_RUN = new RegExp(`\\b[A-Z][A-Z']*(?:,? [A-Z][A-Z']*){${String(SHOUT_WORDS - 1)},}\\b`, "gu");
+/** One-letter words (I, A) may sit in a run, but a run of them alone ("A B C") is a list of labels. */
+const MIN_LONG_WORDS = 2;
+
+const LATIN_WORD = /[A-Za-z][A-Za-z']*/gu;
+
+/** The words a source writes at least once not wholly in capitals (do, Do), in lower case: words, not acronyms. */
+export const lowerCaseWords = (source: string): ReadonlySet<string> =>
+  new Set((source.match(LATIN_WORD) ?? []).filter((word) => word !== word.toUpperCase()).map((word) => word.toLowerCase()));
+
+/**
+ * Whether more than half the words of a capital run are also written elsewhere in lower case. Words the lexicon lists as
+ * written in capitals by convention (MUST NOT in a specification) count like acronyms.
+ */
+export const isShouting = (run: string, known: ReadonlySet<string>, conventional: ReadonlySet<string>): boolean => {
+  const words = run.split(/,? /u);
+  const ordinary = words.filter((word) => !conventional.has(word) && known.has(word.toLowerCase()));
+  const long = words.filter((word) => word.length > 1);
+  return long.length >= MIN_LONG_WORDS && ordinary.length * 2 > words.length;
+};
+
+/** Runs of three or more all-capital words that are ordinary words, not acronyms ("DO NOT DELETE THIS"). */
+export const capsShouting: Detector = (doc, options): Finding[] => {
+  const known = lowerCaseWords(doc.prose ?? doc.source);
+  const conventional = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
+  const hits = hitsOf(ownSentences(doc), CAPS_RUN).filter((hit) => isShouting(hit.matched, known, conventional));
+  return reportFrom(hits, options.limit);
+};

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