chaffjs 0.18.0 → 0.20.0

package/src/detectors/abstract-length.ts

@@ -0,0 +1,126 @@
+// An abstract longer than the limit, or a paper with sections and no abstract. Pure. What labels an abstract (要旨,
+// Abstract) and what names a paper's section (はじめに, Methods) come from the language's abstract-heading and
+// paper-section-heading lexicons. An abstract in the other language (the English Abstract of a Japanese paper) is
+// measured in that language's unit and against its limit.
+import { lengthOf } from "../measure.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, DetectorOptions, Finding, LengthUnit, ProseDocument, Sentence, Span } from "../plugin.ts";
+
+/** A paper with this many section headings (Introduction, Methods, …) is expected to have an abstract. */
+const MIN_SECTIONS = 2;
+
+/** The marks around a label: a heading's number, 【】, a colon or a full stop after it, emphasis. */
+const LABEL_MARKS = new Set(" \t\n\u3000.．#*_【[（():：】])）0123456789");
+/** Where a label at a paragraph's head ends: "Abstract: We …", "【要旨】本研究は…", "Abstract.We …". */
+const LABEL_ENDS = ["】", ":", "：", ".", "．"];
+/** A label at a paragraph's head is a word or two: past this many characters the colon belongs to a sentence. */
+const MAX_LABEL = 24;
+
+export const labelOf = (text: string): string => {
+  const chars = [...text];
+  const first = chars.findIndex((char) => !LABEL_MARKS.has(char));
+  const last = chars.findLastIndex((char) => !LABEL_MARKS.has(char));
+  return first === -1
+    ? ""
+    : chars
+        .slice(first, last + 1)
+        .join("")
+        .toLowerCase();
+};
+
+/** The label at a paragraph's head and how long it is with the spaces after it, or undefined. */
+export const headLabel = (text: string): { readonly label: string; readonly length: number } | undefined => {
+  const head = text.slice(0, MAX_LABEL);
+  const end = LABEL_ENDS.map((mark) => head.indexOf(mark))
+    .filter((index) => index > 0)
+    .toSorted((left, right) => left - right)[0];
+  if (end === undefined) return undefined;
+  const rest = text.slice(end + 1);
+  return { label: labelOf(head.slice(0, end + 1)), length: end + 1 + rest.length - rest.trimStart().length };
+};
+
+export type AbstractSpan = { readonly label: number; readonly body: Span };
+
+type Words = { readonly abstracts: ReadonlySet<string>; readonly sections: ReadonlySet<string> };
+
+const wordsOf = (doc: ProseDocument): Words => {
+  const set = (id: string): ReadonlySet<string> => new Set((doc.lexicons[id] ?? []).map((entry) => entry.pattern.toLowerCase()));
+  return { abstracts: set("abstract-heading"), sections: set("paper-section-heading") };
+};
+
+/** Abstracts under a heading of their own: the text up to the next heading. */
+const underHeadings = (doc: ProseDocument, words: Words): AbstractSpan[] => {
+  const headings = doc.markup?.headings ?? [];
+  return headings.flatMap((heading, index): AbstractSpan[] =>
+    words.abstracts.has(labelOf(heading.text))
+      ? [{ label: heading.start, body: { start: heading.end, end: headings[index + 1]?.start ?? doc.source.length } }]
+      : [],
+  );
+};
+
+/** Abstracts labelled in a paragraph: the label alone on its line (the next paragraph is the abstract) or at its head. */
+const inParagraphs = (doc: ProseDocument, words: Words): AbstractSpan[] =>
+  doc.paragraphs.flatMap((paragraph, index): AbstractSpan[] => {
+    const text = doc.source.slice(paragraph.span.start, paragraph.span.end);
+    const next = doc.paragraphs[index + 1];
+    if (words.abstracts.has(labelOf(text))) return next === undefined ? [] : [{ label: paragraph.span.start, body: next.span }];
+    const head = headLabel(text);
+    if (head === undefined || !words.abstracts.has(head.label)) return [];
+    return [{ label: paragraph.span.start, body: { start: paragraph.span.start + head.length, end: paragraph.span.end } }];
+  });
+
+export const abstractsOf = (doc: ProseDocument): AbstractSpan[] => {
+  const words = wordsOf(doc);
+  const found = [...underHeadings(doc, words), ...inParagraphs(doc, words)].toSorted((left, right) => left.label - right.label);
+  return found.filter((abstract, index) => found.findIndex((other) => other.label === abstract.label) === index);
+};
+
+/** The first heading that names a paper's section, when there are MIN_SECTIONS of them; undefined otherwise. */
+export const firstSectionHeading = (doc: ProseDocument): number | undefined => {
+  const words = wordsOf(doc);
+  const sections = (doc.markup?.headings ?? []).filter((heading) => words.sections.has(labelOf(heading.text)));
+  return sections.length >= MIN_SECTIONS ? sections[0]?.start : undefined;
+};
+
+type Measure = { readonly size: number; readonly limit: number | undefined; readonly unit: LengthUnit };
+
+/** The part of a sentence inside the span: a label at the head of the abstract's paragraph is not counted. */
+const clipped = (sentence: Sentence, body: Span): Sentence => {
+  const from = Math.max(0, body.start - sentence.span.start);
+  return from === 0 ? sentence : { ...sentence, text: sentence.text.slice(from), span: { start: sentence.span.start + from, end: sentence.span.end } };
+};
+
+/** The abstract's length, in the unit of the language most of its sentences are in, and that language's limit. */
+export const measureAbstract = (doc: ProseDocument, body: Span, options: DetectorOptions): Measure => {
+  const sentences = doc.sentences
+    .filter((sentence) => sentence.span.end > body.start && sentence.span.start < body.end)
+    .map((sentence) => clipped(sentence, body));
+  const embedded = sentences.filter((sentence) => sentence.embeddedLanguage !== undefined);
+  const other = embedded.length * 2 > sentences.length ? embedded[0]?.embeddedLanguage : undefined;
+  const unit = other?.lengthUnit ?? doc.lengthUnit;
+  const limit = other === undefined ? options.limit : options.embeddedLimits?.[other.id];
+  return { size: sentences.reduce((sum, sentence) => sum + lengthOf(sentence, unit), 0), limit, unit };
+};
+
+const finding = (doc: ProseDocument, offset: number, variant: string, values: Readonly<Record<string, number>>): Finding => ({
+  rule: "abstract-length",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, offset),
+  values: { ...values, offset },
+  variant,
+});
+
+export const abstractLength: Detector = (doc, options): Finding[] => {
+  const abstracts = abstractsOf(doc);
+  if (abstracts.length === 0) {
+    const section = firstSectionHeading(doc);
+    return section === undefined ? [] : [finding(doc, section, "missing", {})];
+  }
+  return abstracts.flatMap((found) => {
+    const measure = measureAbstract(doc, found.body, options);
+    if (measure.limit === undefined || measure.size <= measure.limit) return [];
+    return [finding(doc, found.label, measure.unit === "word" ? "words" : "chars", { count: measure.size, limit: measure.limit })];
+  });
+};

package/src/detectors/ai-phrasing.ts

@@ -29,7 +29,7 @@ const findingOf = (hit: Hit, values: Readonly<Record<string, number>>): Finding
 });
 
 /** 1000 語（日本語は 1000 字）あたりの数が上限を超えたら、当たった文をすべて言う。短い文書は密度が暴れるので測らない。 */
-const densityFindings = (doc: ProseDocument, hits: readonly Hit[], limit: number): Finding[] => {
+export const densityFindings = (doc: ProseDocument, hits: readonly Hit[], limit: number): Finding[] => {
   const length = wordsOf(doc);
   if (hits.length < PILE || length < MIN_DOCUMENT_LENGTH[doc.lengthUnit]) return [];
   const density = Math.round((hits.length / length) * PER * TENTHS) / TENTHS;
@@ -73,9 +73,13 @@ export const openerPile: Detector = (doc, options): Finding[] => {
   return hits.length === 0 || hits.length < options.limit ? [] : hits.map((hit) => findingOf(hit, { count: hits.length, limit: options.limit }));
 };
 
-/** コロンで箇条書きへ渡す文（以下の通りです：）。1 つなら案内だが、節ごとに続くと説明が箇条書きの前置きだけになる。 */
+/**
+ * コロンで箇条書きへ渡す文（以下の通りです：）。1 つなら案内だが、節ごとに続くと説明が箇条書きの前置きだけになる。
+ * 数えるのは文書の言語の文だけ。和文の中の英文（Examples include:）は、英語ではふつうの書き方なので数えない。
+ */
 export const colonLeadIn: Detector = (doc, options): Finding[] => {
-  const hits = colonLeadIns(doc.sentences, doc.lists, doc.listSpans, doc.source).map((sentence) => ({ sentence, matched: sentence.text.trim() }));
+  const inDocumentLanguage = doc.sentences.filter((sentence) => sentence.embeddedLanguage === undefined);
+  const hits = colonLeadIns(inDocumentLanguage, doc.lists, doc.listSpans, doc.source).map((sentence) => ({ sentence, matched: sentence.text.trim() }));
   return densityFindings(doc, hits, options.limit);
 };
 
@@ -122,16 +126,14 @@ export const assistantResidue: Detector = (doc, options): Finding[] => {
   return tally.hits.map((hit) => findingOf(hit, { count: tally.counted.size, density: score, limit: options.limit }));
 };
 
-/** 埋め忘れた雛形の空欄（[Your Name]、【会社名】）。limit は指摘に要る数。 */
-export const unfilledPlaceholder: Detector = (doc, options): Finding[] => {
-  const words = options.lexicon ?? [];
-  const blanks = doc.sentences.flatMap((sentence) =>
-    placeholderSpans(sentence.text, words).map((span) => ({
-      sentence,
-      matched: sentence.text.slice(span.start, span.end),
-      offset: sentence.span.start + span.start,
-    })),
-  );
-  if (blanks.length === 0 || blanks.length < options.limit) return [];
-  return blanks.map((blank) => findingOf(blank, { count: blanks.length, limit: options.limit }));
-};
+/** 埋め忘れた雛形の空欄（[Your Name]、【会社名】、TBD: …）。1 つでも埋め忘れなので、段は数ではなく指摘の重さを決める。 */
+export const unfilledPlaceholder: Detector = (doc, options): Finding[] =>
+  doc.sentences
+    .flatMap((sentence) =>
+      placeholderSpans(sentence.text, options.lexicon ?? []).map((span) => ({
+        sentence,
+        matched: sentence.text.slice(span.start, span.end),
+        offset: sentence.span.start + span.start,
+      })),
+    )
+    .map((blank) => findingOf(blank, {}));

package/src/detectors/ai-structure.ts

@@ -0,0 +1,26 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { uiLanguageOf } from "../ui.ts";
+import { STRUCTURE_TEXT } from "../outline/structure-text.ts";
+import { structureOf } from "../structure-shape/of-document.ts";
+
+/**
+ * The document's outline is past the human articles on several structure measures at once (chaff outline's structure
+ * block): many headings, three-way splits, bold labels, uniform sections. One alone is ordinary; the limit is how many.
+ */
+export const aiStructure: Detector = (doc, options): Finding[] => {
+  const scored = structureOf(doc);
+  if (scored.score < options.limit) return [];
+  const text = STRUCTURE_TEXT[uiLanguageOf(doc.language)];
+  const names = scored.placements.filter((placement) => placement.beyond).map((placement) => text.features[placement.feature.id].name);
+  const heading = (doc.markup?.headings ?? []).find((entry) => entry.depth > 1) ?? doc.markup?.headings[0];
+  return [
+    {
+      rule: "ai-structure",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: heading?.text ?? "",
+      values: { word: names.join(text.listSeparator), count: scored.score, limit: options.limit, offset: heading?.start ?? 0 },
+    },
+  ];
+};

package/src/detectors/blank-structure.ts

@@ -0,0 +1,147 @@
+// Blanks in a Markdown document's structure: a table cell left empty in a column every other row fills, and a list
+// item with nothing in it or only a label (担当：) where its siblings give one a value. 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 { eachPreOrder } from "../tree-walk.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** Fewer body rows than this, and one blank is as likely a choice as a gap. */
+const MIN_BODY_ROWS = 3;
+
+/** Where a blank is, and what names it: the column's header, or the item's label. */
+export type Blank = { readonly offset: number; readonly name: string };
+
+/** The longest label an item can hold before the colon (「担当：」 "Owner:"); longer, or with a sentence mark, and it is a sentence. */
+const LABEL = /^([^:：\n。．！？!?]{1,30})[:：]$/u;
+const LABEL_WITH_VALUE = /^[^:：\n。．！？!?]{1,30}[:：][^\S\n]*\S/u;
+/** An unchecked or checked box with nothing after it: GFM task lists are not parsed, so `[ ]` is the item's text. */
+const BARE_BOX = /^\[[ xX]?\]$/u;
+const EMPHASIS = /[*_]/gu;
+const COMMENT = /^<!--[\s\S]*-->$/u;
+const VISIBLE_LEAVES = new Set(["inlineCode", "image", "imageReference"]);
+
+/** Whether a node shows the reader anything: text that is not blank, code, an image, or HTML that is not a comment. */
+const shows = (node: MarkdownNode): boolean => {
+  if (node.type === "text") return (node.value ?? "").replace(EMPHASIS, "").trim() !== "";
+  if (node.type === "html") return !COMMENT.test((node.value ?? "").trim());
+  if (VISIBLE_LEAVES.has(node.type)) return true;
+  return (node.children ?? []).some(shows);
+};
+
+const sourceOf = (source: string, node: MarkdownNode | undefined): string => {
+  const span = node === undefined ? undefined : spanOf(node);
+  return span === undefined ? "" : source.slice(span.start, span.end).replace(/\|/gu, "").trim();
+};
+
+const nodesOfType = (root: MarkdownNode, type: string): MarkdownNode[] => {
+  const found: MarkdownNode[] = [];
+  eachPreOrder(root, (node) => {
+    if (node.type === type) found.push(node);
+  });
+  return found;
+};
+
+const outside = (spans: readonly Span[], node: MarkdownNode): boolean => {
+  const span = spanOf(node);
+  return span !== undefined && !spans.some((quoted) => span.start >= quoted.start && span.start < quoted.end);
+};
+
+/** Where a blank cell is: the cell itself, or the end of a row that stops before reaching the column. */
+const cellOffset = (cell: MarkdownNode | undefined, row: MarkdownNode | undefined): number | undefined => {
+  if (cell !== undefined) return spanOf(cell)?.start;
+  return row === undefined ? undefined : spanOf(row)?.end;
+};
+
+/** The one blank body cell of a column whose other body rows are all filled. */
+const columnBlank = (source: string, header: MarkdownNode, body: readonly MarkdownNode[], column: number): Blank[] => {
+  const cells = body.map((row) => row.children?.[column]);
+  const blanks = cells.flatMap((cell, index) => (cell === undefined || !shows(cell) ? [index] : []));
+  const at = blanks[0];
+  if (blanks.length !== 1 || at === undefined) return [];
+  const offset = cellOffset(cells[at], body[at]);
+  const name = sourceOf(source, header.children?.[column]);
+  return offset === undefined || name === "" ? [] : [{ offset, name }];
+};
+
+/** The first column is skipped: a blank there often means "same as above". */
+const tableBlanksOf = (source: string, table: MarkdownNode): Blank[] => {
+  const [header, ...body] = table.children ?? [];
+  if (header === undefined || body.length < MIN_BODY_ROWS) return [];
+  const columns = header.children?.length ?? 0;
+  return Array.from({ length: columns }, (_unused, column) => column)
+    .slice(1)
+    .flatMap((column) => columnBlank(source, header, body, column));
+};
+
+/** Quoted material is someone else's: email replies the document model found, and every Markdown blockquote. */
+const quotedSpans = (root: MarkdownNode, replies: readonly Span[]): Span[] => [
+  ...replies,
+  ...nodesOfType(root, "blockquote").flatMap((quote) => spanOf(quote) ?? []),
+];
+
+const blocksOutsideQuotes = (source: string, type: string, replies: readonly Span[]): MarkdownNode[] => {
+  const root = readMarkdown(source).root;
+  const quoted = quotedSpans(root, replies);
+  return nodesOfType(root, type).filter((node) => outside(quoted, node));
+};
+
+/** Blank cells in every table outside quotes. */
+export const tableBlanks = (source: string, replies: readonly Span[] = []): Blank[] =>
+  blocksOutsideQuotes(source, "table", replies).flatMap((table) => tableBlanksOf(source, table));
+
+type Item = { readonly node: MarkdownNode; readonly text: string | undefined; readonly empty: boolean };
+
+/** An item's own words, emphasis marks dropped; undefined when a nested list or block follows a lead-in. */
+const itemOf = (source: string, node: MarkdownNode): Item => {
+  const children = node.children ?? [];
+  const text = children.length > 1 ? undefined : sourceOf(source, children[0]).replace(EMPHASIS, "").trim();
+  return { node, text, empty: !children.some(shows) || BARE_BOX.test(text ?? "") };
+};
+
+const isLabelled = (item: Item): boolean => item.text !== undefined && (LABEL.test(item.text) || LABEL_WITH_VALUE.test(item.text));
+
+/**
+ * A label-only item counts as a gap only in a list of labelled items (more than half of them "label: value" or "label:", at least
+ * one with a value). In a list of sentences, a label-only item is a lead-in to what follows (「次の手順で進めます：」).
+ */
+const isFieldList = (items: readonly Item[]): boolean => {
+  const labelled = items.filter(isLabelled);
+  return labelled.length * 2 > items.length && labelled.some((item) => LABEL_WITH_VALUE.test(item.text ?? ""));
+};
+
+const itemBlank = (item: Item, fields: boolean, filledSibling: boolean): Blank[] => {
+  const offset = spanOf(item.node)?.start;
+  if (offset === undefined || item.text === undefined) return [];
+  if (item.empty) return filledSibling ? [{ offset, name: "" }] : [];
+  const label = LABEL.exec(item.text)?.[1];
+  return label !== undefined && fields ? [{ offset, name: label.trim() }] : [];
+};
+
+/** An empty item is reported only beside a filled one: a list of one empty item is a numbering left over (「40.」). */
+const listBlanksOf = (source: string, list: MarkdownNode): Blank[] => {
+  const items = (list.children ?? []).filter((child) => child.type === "listItem").map((node) => itemOf(source, node));
+  const fields = isFieldList(items);
+  const filledSibling = items.some((item) => !item.empty);
+  return items.flatMap((item) => itemBlank(item, fields, filledSibling));
+};
+
+/** Empty items, and label-only items in a list of labelled fields, outside quotes. */
+export const listBlanks = (source: string, replies: readonly Span[] = []): Blank[] =>
+  blocksOutsideQuotes(source, "list", replies).flatMap((list) => listBlanksOf(source, list));
+
+const findingsOf =
+  (rule: string, blanksOf: (source: string, replies: readonly Span[]) => Blank[]): Detector =>
+  (doc: ProseDocument): Finding[] =>
+    blanksOf(doc.source, doc.replyQuotes ?? []).map((blank) => ({
+      rule,
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, blank.offset),
+      ...(blank.name === "" ? { variant: "empty" } : {}),
+      values: { name: blank.name, offset: blank.offset },
+    }));
+
+export const emptyTableCell: Detector = findingsOf("empty-table-cell", tableBlanks);
+export const emptyListItem: Detector = findingsOf("empty-list-item", listBlanks);

package/src/detectors/bold-label.ts

@@ -0,0 +1,55 @@
+import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
+
+/** A bold run longer than this is a bold sentence, not a label. */
+const MAX_LABEL_CHARS = 40;
+
+/** The bullet or number that opens a list item. */
+const ITEM_MARKER = /^[ \t]*(?:[-*+]|\d{1,9}[.)])[ \t]+/u;
+
+/** A task box, after the marker or at the start of an item whose marker was already cut. */
+const TASK_BOX = /^\[[ xX]\][ \t]+/u;
+
+/** `**Label**: text` or `**Label:** text`. The label holds no delimiter, so `**a** and **b**: text` is not one label. */
+const BOLD_LABEL = new RegExp(String.raw`^(\*\*|__)(?!\s)((?:(?!\1)[^\n]){1,${MAX_LABEL_CHARS}}?)(?:\1[ \t]*[:：]|[:：]\1)[ \t]*\S`, "u");
+
+/** A label that is only code (`--flag`, `timeout_ms`) names an option or a field: the way reference documentation lists them. */
+const CODE_SPAN = /^`[^`]+`$/u;
+
+/** A link around the whole label: inline, reference, collapsed or shortcut. Its text is what the reader sees. */
+const WHOLE_LINK = /^\[([^\]\n]+)\](?:\([^)\s]*\)|\[[^\]\n]*\])?$/u;
+
+const isCodeOnly = (label: string): boolean => CODE_SPAN.test(label.replace(WHOLE_LINK, "$1"));
+
+/** The label a list item opens with in bold before a colon and more text, or undefined. `item` is the item as written, marker and all. */
+export const boldLabelOf = (item: string): string | undefined => {
+  const label = BOLD_LABEL.exec(item.replace(ITEM_MARKER, "").replace(TASK_BOX, ""))?.[2]?.trim();
+  return label === undefined || isCodeOnly(label) ? undefined : label;
+};
+
+/** Whether the line holding `offset` is quoted (`> - **a**：…`): someone else's words, not the writer's to fix. */
+export const isQuotedAt = (source: string, offset: number): boolean => source.slice(source.lastIndexOf("\n", offset - 1) + 1, offset).includes(">");
+
+/** The list items, in document order, that open with a bold label and are not quoted. */
+export const boldLabelItems = (doc: ProseDocument): Span[] =>
+  doc.lists
+    .flatMap((list) => list.itemSpans)
+    .filter((span) => !isQuotedAt(doc.source, span.start) && boldLabelOf(doc.source.slice(span.start, span.end)) !== undefined)
+    .toSorted((left, right) => left.start - right.start);
+
+/** A count, not a density: a person writes one or two labels even in a long article. */
+export const boldLabelList: Detector = (doc, options): Finding[] => {
+  const items = boldLabelItems(doc);
+  const first = items[0];
+  if (first === undefined || items.length < options.limit) return [];
+  const written = doc.source.slice(first.start, first.end);
+  return [
+    {
+      rule: "bold-label-list",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: (written.split("\n")[0] ?? "").trim(),
+      values: { label: boldLabelOf(written) ?? "", count: items.length, limit: options.limit, offset: first.start },
+    },
+  ];
+};

package/src/detectors/chat-citation.ts

@@ -0,0 +1,50 @@
+import type { Detector, Finding, Lexicon, ProseDocument, Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { findingAt, markupOf } from "./markup-finding.ts";
+
+/** One marker a chat interface leaves when its answer is pasted: where it is and what was written. */
+export type ChatMarker = { readonly matched: string; readonly span: Span };
+
+/** Every place a lexicon pattern is written in `text`, case and all, in the order they appear. */
+export const markersIn = (text: string, lexicon: Lexicon): ChatMarker[] =>
+  lexicon
+    .filter((entry) => entry.pattern !== "")
+    .flatMap((entry) =>
+      [...text.matchAll(new RegExp(escapeRegExp(entry.pattern), "gu"))].map((match) => ({
+        matched: entry.pattern,
+        span: { start: match.index, end: match.index + entry.pattern.length },
+      })),
+    )
+    .toSorted((left, right) => left.span.start - right.span.start);
+
+const within = (outer: readonly Span[], span: Span): boolean => outer.some((range) => range.start <= span.start && span.end <= range.end);
+
+/** Whether any of the span is left as prose: code, HTML and quotes are blanked out of `prose`, so a marker there shows nothing. */
+export const showsInProse = (prose: string, span: Span): boolean => prose.slice(span.start, span.end).trim() !== "";
+
+/**
+ * The destination part of a link or an image as written: after `](` for `[text](url)`, after `]:` for a definition, and
+ * the whole of an autolink. The label is left out, so code in a link's text stays code.
+ */
+export const destinationOf = (source: string, span: Span): Span => {
+  const written = source.slice(span.start, span.end);
+  const inline = written.lastIndexOf("](");
+  if (inline !== -1) return { start: span.start + inline + "](".length, end: span.end };
+  const defined = written.indexOf("]:");
+  return defined === -1 ? span : { start: span.start + defined + "]:".length, end: span.end };
+};
+
+/** Where a marker reaches the reader: the prose (a marker may straddle Markdown's nodes), the visible text (a bare URL), or a link's or an image's destination. */
+const reachesReader = (doc: ProseDocument, span: Span): boolean => {
+  const markup = markupOf(doc);
+  if (markup === undefined || doc.prose === undefined) return true;
+  const destinations = [...markup.links, ...markup.images].map((target) => destinationOf(doc.source, target));
+  return showsInProse(doc.prose, span) || within([...markup.texts, ...destinations], span);
+};
+
+/** Each marker is a leftover in its own right, so each is reported, from the first. */
+export const chatCitationResidue: Detector = (doc, options): Finding[] => {
+  const markers = markersIn(doc.source, options.lexicon ?? []).filter((marker) => reachesReader(doc, marker.span));
+  if (markers.length === 0 || markers.length < options.limit) return [];
+  return markers.map((marker) => findingAt(doc, marker.span, { matched: marker.matched, count: markers.length, limit: options.limit }));
+};

package/src/detectors/citation-entry.ts

@@ -0,0 +1,94 @@
+// A citation with no entry in the reference list, or an entry never cited. Pure. Checked only where both sides are
+// read mechanically: numbered entries against numbered citations, author-year entries against author-year citations.
+// An entry is reported as never cited only when most entries are cited, so a paper whose citations chaff cannot read
+// (superscripts lost in a copy) is not reported entry by entry.
+import {
+  citationMarks,
+  citationWordsOf,
+  referenceEntries,
+  referenceListsOf,
+  type AuthorYear,
+  type CitationMark,
+  type ReferenceEntry,
+} from "./citation-marks.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding } from "../plugin.ts";
+
+/** A reference list needs this many entries of one kind to be read as numbered or as author-year. */
+const MIN_ENTRIES = 2;
+
+export type CitationSlip =
+  | { readonly variant: "missing"; readonly offset: number; readonly citation: string; readonly key: string }
+  | { readonly variant: "uncited"; readonly offset: number; readonly key: string };
+
+type Keyed = { readonly key: string; readonly start: number };
+
+/** One kind of citation and its entries, and whether an entry's key is what a citation's key names. */
+type Side = {
+  readonly entries: readonly Keyed[];
+  readonly citations: readonly { readonly mark: CitationMark; readonly keys: readonly string[] }[];
+  readonly names: (entryKey: string, citedKey: string) => boolean;
+};
+
+const NUMBERED_STYLES = new Set(["numeric", "kikko", "paren-number"]);
+const LATIN = /[a-z]/u;
+
+const keyOf = (cited: AuthorYear): string => `${cited.year} ${cited.author}`;
+
+/** A cited Japanese surname this long or longer may be the head of an entry's full name; a shorter one (林) must match whole. */
+const MIN_PREFIX_SURNAME = 2;
+
+/** The same year, and the same surname; a Japanese entry gives the full name (山田太郎) where the text cites the surname (山田). */
+export const namesEntry = (entryKey: string, citedKey: string): boolean => {
+  if (entryKey === citedKey) return true;
+  const surname = citedKey.slice(citedKey.indexOf(" ") + 1);
+  return !LATIN.test(citedKey) && [...surname].length >= MIN_PREFIX_SURNAME && entryKey.startsWith(citedKey);
+};
+
+const numberedSide = (entries: readonly ReferenceEntry[], marks: readonly CitationMark[]): Side => ({
+  entries: entries.flatMap((entry) => (entry.number === undefined ? [] : [{ key: String(entry.number), start: entry.start }])),
+  citations: marks.filter((mark) => NUMBERED_STYLES.has(mark.style)).map((mark) => ({ mark, keys: mark.numbers.map(String) })),
+  names: (entryKey, citedKey) => entryKey === citedKey,
+});
+
+const authorYearSide = (entries: readonly ReferenceEntry[], marks: readonly CitationMark[]): Side => ({
+  entries: entries.flatMap((entry) => (entry.authorYear === undefined ? [] : [{ key: keyOf(entry.authorYear), start: entry.start }])),
+  citations: marks.filter((mark) => mark.style === "author-year").map((mark) => ({ mark, keys: mark.authorYears.map(keyOf) })),
+  names: namesEntry,
+});
+
+export const sideSlips = (side: Side): CitationSlip[] => {
+  if (side.entries.length < MIN_ENTRIES || side.citations.length === 0) return [];
+  const citedKeys = [...new Set(side.citations.flatMap((citation) => citation.keys))];
+  const isCited = (entry: Keyed): boolean => citedKeys.some((key) => side.names(entry.key, key));
+  const missing = side.citations.flatMap((citation) =>
+    citation.keys
+      .filter((key) => !side.entries.some((entry) => side.names(entry.key, key)))
+      .map((key): CitationSlip => ({ variant: "missing", offset: citation.mark.start, citation: citation.mark.written, key })),
+  );
+  const uncitedEntries = side.entries.filter((entry) => !isCited(entry));
+  // Most entries cited: the citations are read, so an entry none of them names is really never cited.
+  const uncited =
+    uncitedEntries.length * 2 <= side.entries.length
+      ? uncitedEntries.map((entry): CitationSlip => ({ variant: "uncited", offset: entry.start, key: entry.key }))
+      : [];
+  return [...missing, ...uncited];
+};
+
+export const citationSlips = (entries: readonly ReferenceEntry[], marks: readonly CitationMark[]): CitationSlip[] =>
+  [...sideSlips(numberedSide(entries, marks)), ...sideSlips(authorYearSide(entries, marks))].toSorted((left, right) => left.offset - right.offset);
+
+export const citationEntry: Detector = (doc): Finding[] => {
+  const words = citationWordsOf(doc);
+  const lists = referenceListsOf(doc, words);
+  if (lists.length === 0) return [];
+  return citationSlips(referenceEntries(doc.source, lists), citationMarks(doc.prose ?? doc.source, lists, words)).map((slip) => ({
+    rule: "citation-reference-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.offset),
+    values: { citation: slip.variant === "missing" ? slip.citation : "", key: slip.key.split(" ").toReversed().join(" "), offset: slip.offset },
+    variant: slip.variant,
+  }));
+};