chaffjs 0.19.0 → 0.21.0

package/src/detectors/blank-structure.ts

@@ -0,0 +1,155 @@
+// 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, foldPostOrder } 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"]);
+
+/** What a leaf shows on its own; undefined for a node whose children decide. */
+const leafShows = (node: MarkdownNode): boolean | undefined => {
+  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 undefined;
+};
+
+/** 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 =>
+  foldPostOrder<MarkdownNode, boolean>(
+    node,
+    (each) => each.children ?? [],
+    (each, children) => leafShows(each) ?? children.some((child) => child),
+  );
+
+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/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,
+  }));
+};

package/src/detectors/citation-marks.ts

@@ -0,0 +1,205 @@
+// In-text citations and reference-list entries, read by shape. Pure. The shapes are the ones papers print ([3],
+// (Smith, 2020), 〔3〕, …である3)。, a Markdown footnote); the words between authors (et al., ら) come from the
+// language's citation-author-joiner lexicon, and the words that look like an author but are not (March 2020) from
+// citation-not-author.
+import { escapeRegExp } from "../orthography.ts";
+import { referenceListSpans } from "../reference-lists.ts";
+import type { ProseDocument, Span } from "../plugin.ts";
+
+export type CitationStyle = "numeric" | "footnote" | "author-year" | "kikko" | "paren-number";
+
+export type AuthorYear = { readonly author: string; readonly year: string };
+
+export type CitationMark = {
+  readonly start: number;
+  readonly end: number;
+  readonly style: CitationStyle;
+  readonly written: string;
+  /** The reference numbers it cites, ranges spread out (numeric, 〔〕 and paren-number styles). */
+  readonly numbers: readonly number[];
+  /** The authors and years it cites (author-year style); the first author's surname, lower-cased. */
+  readonly authorYears: readonly AuthorYear[];
+};
+
+export type ReferenceEntry = { readonly start: number; readonly number?: number; readonly authorYear?: AuthorYear };
+
+export type CitationWords = {
+  /** Words that join two authors (and, &, ・). */
+  readonly pairs: readonly string[];
+  /** Words after the first author that stand for the rest (et al., ら). */
+  readonly others: readonly string[];
+  /** Capitalised words that take a year after them but are no author (months, seasons). Lower-cased. */
+  readonly notAuthors: ReadonlySet<string>;
+  /** The headings of a reference list (参考文献, References). */
+  readonly referenceHeadings: readonly string[];
+};
+
+/** A range wider than this is not a citation range ([1990-2020] is years). */
+const MAX_RANGE = 50;
+/** Text inside a parenthetical citation: wide enough for three authors and years, short enough to stay one citation. */
+const MAX_PAREN = 200;
+
+const LATIN_NAME = "\\p{Lu}[\\p{L}’'\\-]+";
+const JA_NAME = "[\\p{Script=Han}\\p{Script=Katakana}ー]{1,8}";
+const YEAR = "(?:1[89]|20)\\d{2}[a-z]?";
+
+const NUMBER_LIST = "\\d{1,3}(?:\\s*[,，、–—\\-]\\s*\\d{1,3})*";
+const NUMERIC = new RegExp(`\\[(${NUMBER_LIST})\\](?!:)`, "gu");
+const FOOTNOTE = /\[\^[^\]\s]{1,20}\](?!:)/gu;
+const KIKKO = new RegExp(`〔(${NUMBER_LIST})〕`, "gu");
+/** …である3)。: a number and a closing parenthesis straight after Japanese text, before punctuation or the line's end. */
+const PAREN_NUMBER = /(?<=[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー」』）])(\d{1,3}(?:[,，、–—-]\d{1,3})*)\)(?=[、。，．\s]|$)/gmu;
+const PARENTHETICAL = new RegExp(`[(（]([^()（）\\n]{4,${String(MAX_PAREN)}})[)）]`, "gu");
+/** The start of a line, up to a list marker: a number there numbers an item, it cites nothing. */
+const LINE_HEAD = /^[ \t]*(?:[-*+][ \t]+)?$/u;
+const ENTRY_NUMBER = /^[ \t]{0,3}(?:[-*+][ \t]+)?(?:\[(\d{1,4})\]|(\d{1,4})[.)）]|〔(\d{1,4})〕)/u;
+
+const alternation = (words: readonly string[]): string =>
+  words
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+/** One author as cited: a surname, maybe a second joined by and or ・, maybe "et al." or ら. */
+const authorPattern = (words: CitationWords): string => {
+  const name = `(?:${LATIN_NAME}|${JA_NAME})`;
+  const pair = words.pairs.length === 0 ? "" : `(?:\\s?(?:${alternation(words.pairs)})\\s?${name})?`;
+  const others = words.others.length === 0 ? "" : `(?:\\s?(?:${alternation(words.others)}))?`;
+  return `${name}${pair}${others}`;
+};
+
+/** "1, 3-5" as [1, 3, 4, 5]. A range that runs backwards or wider than MAX_RANGE is no citation, and gives []. */
+export const numbersIn = (list: string): number[] => {
+  const parts = list.split(/[,，、]/u).map((part) => part.split(/[–—-]/u).map((bound) => Number(bound.trim())));
+  const spread = parts.map(([from = 0, to]) => {
+    if (to === undefined) return [from];
+    return to < from || to - from > MAX_RANGE ? undefined : Array.from({ length: to - from + 1 }, (_, index) => from + index);
+  });
+  return spread.some((part) => part === undefined) ? [] : spread.flatMap((part) => part ?? []);
+};
+
+const lineBefore = (text: string, offset: number): string => text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset);
+
+const isInside = (spans: readonly Span[], offset: number): boolean => spans.some((span) => span.start <= offset && offset < span.end);
+
+/** [1] after a link's text ([manual][1]) is the link's label, not a citation; [1][2] is two citations. */
+const isLinkLabel = (text: string, offset: number): boolean =>
+  text[offset - 1] === "]" && !/\[[\d\s,，、–—-]+\]$/u.test(text.slice(Math.max(0, offset - 40), offset));
+
+const depthChange = (char: string): number => {
+  if ("(（".includes(char)) return 1;
+  return ")）".includes(char) ? -1 : 0;
+};
+
+const opensParenthesis = (line: string): boolean => [...line].reduce((depth, char) => depth + depthChange(char), 0) > 0;
+
+const numberedMarks = (text: string, pattern: RegExp, style: CitationStyle): CitationMark[] =>
+  [...text.matchAll(pattern)].flatMap((match): CitationMark[] => {
+    const numbers = numbersIn(match[1] ?? "");
+    const line = lineBefore(text, match.index);
+    if (numbers.length === 0 || LINE_HEAD.test(line)) return [];
+    if (style === "numeric" && isLinkLabel(text, match.index)) return [];
+    if (style === "paren-number" && opensParenthesis(line)) return [];
+    return [{ start: match.index, end: match.index + match[0].length, style, written: match[0], numbers, authorYears: [] }];
+  });
+
+const footnoteMarks = (text: string): CitationMark[] =>
+  [...text.matchAll(FOOTNOTE)]
+    .filter((match) => !LINE_HEAD.test(lineBefore(text, match.index)))
+    .map((match) => ({ start: match.index, end: match.index + match[0].length, style: "footnote", written: match[0], numbers: [], authorYears: [] }));
+
+/** The first author's surname, lower-cased, without a word for the rest (山田ら is 山田). */
+export const authorKey = (author: string, others: readonly string[]): string => {
+  const first = author.split(/[\s・,，、]/u)[0] ?? author;
+  const other = others.find((word) => first.length > word.length && first.endsWith(word));
+  return (other === undefined ? first : first.slice(0, -other.length)).toLowerCase();
+};
+
+const authorYearOf = (author: string, year: string, others: readonly string[]): AuthorYear => ({ author: authorKey(author, others), year: year.slice(0, 4) });
+
+const LATIN = /[a-z]/u;
+
+/** A month or a season before a year is no author; in Japanese, an author holding 年度 or 調査 is not one either. */
+const isNotAuthor = (author: string, words: CitationWords): boolean =>
+  words.notAuthors.has(author) || [...words.notAuthors].some((word) => !LATIN.test(word) && author.includes(word));
+
+/** The authors and years of one parenthetical: every part between semicolons must read as authors and years. */
+const parentheticalCitations = (inner: string, words: CitationWords): AuthorYear[] | undefined => {
+  const one = new RegExp(`^(?:[a-z.]+,?\\s){0,3}(${authorPattern(words)})[,，、]?\\s?(${YEAR})(?:[,，]\\s?${YEAR})*$`, "u");
+  const parts = inner.split(/[;；]/u).map((part) => one.exec(part.trim()));
+  if (parts.some((part) => part === null)) return undefined;
+  const cited = parts.flatMap((part) => (part === null ? [] : [authorYearOf(part[1] ?? "", part[2] ?? "", words.others)]));
+  return cited.some((entry) => isNotAuthor(entry.author, words)) ? undefined : cited;
+};
+
+const authorYearMark = (match: RegExpMatchArray, authorYears: readonly AuthorYear[]): CitationMark => {
+  const start = match.index ?? 0;
+  return { start, end: start + match[0].length, style: "author-year", written: match[0], numbers: [], authorYears };
+};
+
+const authorYearMarks = (text: string, words: CitationWords): CitationMark[] => {
+  const parenthetical = [...text.matchAll(PARENTHETICAL)].flatMap((match): CitationMark[] => {
+    const authorYears = parentheticalCitations(match[1] ?? "", words);
+    return authorYears === undefined ? [] : [authorYearMark(match, authorYears)];
+  });
+  const narrative = new RegExp(`(?<![\\p{Script=Han}\\p{Script=Katakana}A-Za-z])(${authorPattern(words)})\\s?[(（](${YEAR})[)）]`, "gu");
+  const narratives = [...text.matchAll(narrative)].flatMap((match): CitationMark[] => {
+    const cited = authorYearOf(match[1] ?? "", match[2] ?? "", words.others);
+    return isNotAuthor(cited.author, words) ? [] : [authorYearMark(match, [cited])];
+  });
+  return [...parenthetical, ...narratives.filter((mark) => !parenthetical.some((other) => other.start <= mark.start && mark.start < other.end))];
+};
+
+/** The document's in-text citations, outside its reference lists, in document order. text has code masked (doc.prose). */
+export const citationMarks = (text: string, referenceLists: readonly Span[], words: CitationWords): CitationMark[] =>
+  [
+    ...numberedMarks(text, NUMERIC, "numeric"),
+    ...numberedMarks(text, KIKKO, "kikko"),
+    ...numberedMarks(text, PAREN_NUMBER, "paren-number"),
+    ...footnoteMarks(text),
+    ...authorYearMarks(text, words),
+  ]
+    .filter((mark) => !isInside(referenceLists, mark.start))
+    .toSorted((left, right) => left.start - right.start);
+
+const LIST_MARKER = /^[ \t]{0,3}[-*+][ \t]/u;
+/** An unbulleted entry that follows another without a blank line: "Smith, A. (2020)." at the start of the line, not a wrapped line. */
+const SURNAME_INITIAL = /^\p{Lu}[\p{L}’'-]+, \p{Lu}\./u;
+const YEAR_IN = new RegExp(`(?<!\\d)(${YEAR})(?!\\d)`, "u");
+const ENTRY_AUTHOR = new RegExp(`^[ \\t]{0,3}(?:[-*+][ \\t]+)?(${LATIN_NAME}|${JA_NAME})`, "u");
+
+/** One line of a reference list as an entry: a numbered one, or one that opens an item or a paragraph with an author and gives a year. */
+const entryOf = (line: string, previous: string | undefined, start: number): ReferenceEntry | undefined => {
+  const numbered = ENTRY_NUMBER.exec(line);
+  if (numbered !== null) return { start, number: Number(numbered[1] ?? numbered[2] ?? numbered[3]) };
+  if (previous?.trim() !== "" && !LIST_MARKER.test(line) && !SURNAME_INITIAL.test(line)) return undefined;
+  const author = ENTRY_AUTHOR.exec(line)?.[1];
+  const year = YEAR_IN.exec(line)?.[1];
+  return author === undefined || year === undefined ? undefined : { start, authorYear: authorYearOf(author, year, []) };
+};
+
+/** Each entry of the reference lists: its number, or the first author's surname and the year. The first line is the heading. */
+export const referenceEntries = (text: string, referenceLists: readonly Span[]): ReferenceEntry[] =>
+  referenceLists.flatMap((list) => {
+    const lines = text.slice(list.start, list.end).split("\n");
+    const starts = lines.reduce<number[]>((offsets, line) => [...offsets, (offsets.at(-1) ?? list.start) + line.length + 1], [list.start]);
+    return lines.flatMap((line, index) => {
+      const entry = index === 0 ? undefined : entryOf(line, lines[index - 1], starts[index] ?? 0);
+      return entry === undefined ? [] : [entry];
+    });
+  });
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+export const citationWordsOf = (doc: ProseDocument): CitationWords => {
+  const joiners = doc.lexicons["citation-author-joiner"] ?? [];
+  return {
+    pairs: joiners.filter((entry) => entry.group === "pair").map((entry) => entry.pattern),
+    others: joiners.filter((entry) => entry.group !== "pair").map((entry) => entry.pattern),
+    notAuthors: new Set(patternsOf(doc, "citation-not-author").map((word) => word.toLowerCase())),
+    referenceHeadings: patternsOf(doc, "reference-list-heading"),
+  };
+};
+
+/** The reference lists of the document, found by their headings. */
+export const referenceListsOf = (doc: ProseDocument, words: CitationWords): Span[] => referenceListSpans(doc.source, words.referenceHeadings);

package/src/detectors/citation-style.ts

@@ -0,0 +1,46 @@
+// One paper citing in two styles ([3] here, (Smith, 2020) there, 〔3〕 or 3) elsewhere): the minority is reported. Pure.
+// A Markdown footnote counts as a citation only when its note carries a year, so a footnote that remarks is not a style.
+import { citationMarks, citationWordsOf, referenceListsOf, type CitationMark, type CitationStyle } from "./citation-marks.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding } from "../plugin.ts";
+
+const FOOTNOTE_NOTE = /^\[\^([^\]\s]{1,20})\]:(.*)$/gmu;
+const YEAR = /(?<!\d)(?:1[89]|20)\d{2}(?!\d)/u;
+
+/** The footnote labels whose note reads as a reference: it gives a year. */
+export const citingFootnotes = (text: string): ReadonlySet<string> =>
+  new Set([...text.matchAll(FOOTNOTE_NOTE)].filter((match) => YEAR.test(match[2] ?? "")).map((match) => `[^${match[1] ?? ""}]`));
+
+type StyleCount = { readonly style: CitationStyle; readonly marks: readonly CitationMark[] };
+
+/** The styles in use, the most used first; a tie goes to the style used first. */
+const stylesOf = (marks: readonly CitationMark[]): StyleCount[] => {
+  const styles = [...new Set(marks.map((mark) => mark.style))];
+  return styles
+    .map((style) => ({ style, marks: marks.filter((mark) => mark.style === style) }))
+    .toSorted((left, right) => right.marks.length - left.marks.length);
+};
+
+/** The citations in a minority style: a style other than the most used one, used at most limit times while the most used is used more. */
+export const minorityCitations = (marks: readonly CitationMark[], limit: number): { readonly mark: CitationMark; readonly majority: StyleCount }[] => {
+  const [majority, ...others] = stylesOf(marks);
+  if (majority === undefined) return [];
+  return others
+    .filter((other) => other.marks.length <= limit && other.marks.length < majority.marks.length)
+    .flatMap((other) => other.marks.map((mark) => ({ mark, majority })));
+};
+
+export const citationStyle: Detector = (doc, options): Finding[] => {
+  const words = citationWordsOf(doc);
+  const text = doc.prose ?? doc.source;
+  const footnotes = citingFootnotes(doc.source);
+  const marks = citationMarks(text, referenceListsOf(doc, words), words).filter((mark) => mark.style !== "footnote" || footnotes.has(mark.written));
+  return minorityCitations(marks, options.limit).map(({ mark, majority }) => ({
+    rule: "citation-style-mix",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, mark.start),
+    values: { citation: mark.written, majority: majority.marks[0]?.written ?? "", count: majority.marks.length, offset: mark.start },
+  }));
+};