chaffjs 0.19.0 → 0.20.0

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

package/src/detectors/cross-link.ts

@@ -0,0 +1,82 @@
+import { dirname, extname, join, normalize, sep } from "node:path";
+import type { CrossDetector, DocumentFinding, MarkupLink, ProseDocument } from "../plugin.ts";
+import { anchorsOf, reachesAnchor } from "./broken-link.ts";
+import { findingAt, markupOf, quoteOf } from "./markup-finding.ts";
+
+// A relative link from one file of a run to another (`[Fees](./pricing.md#monthly-fee)`) whose file is not in the run,
+// or whose heading is not in that file. A link to a URL, to a site-absolute path, or within the page is not this rule's.
+
+const SCHEME = /^[a-z][a-z0-9+.-]*:/iu;
+const MARKDOWN = [".md", ".markdown", ".mdx"];
+/** The page a folder link opens, as docs sites and code hosts serve it. */
+const FOLDER_PAGES = ["index.md", "index.mdx", "README.md"];
+
+/** A link's file part, resolved against the linking file's folder, and its fragment (without #). */
+export type LinkTarget = { readonly file: string; readonly folder: boolean; readonly fragment: string | undefined };
+
+const decoded = (text: string): string => {
+  try {
+    return decodeURIComponent(text);
+  } catch {
+    return text;
+  }
+};
+
+/**
+ * Where a destination leads, from the file at `from`. undefined when it is not a relative link to a page: a URL, a path
+ * from the site's root, a link within the page, or a file that is not Markdown (an image, a script).
+ */
+export const linkTarget = (from: string, destination: string): LinkTarget | undefined => {
+  const written = destination.trim();
+  if (written === "" || written.startsWith("#") || written.startsWith("/") || written.startsWith("\\") || SCHEME.test(written)) return undefined;
+  const hashAt = written.indexOf("#");
+  const pathPart = decoded((hashAt === -1 ? written : written.slice(0, hashAt)).split("?")[0] ?? "");
+  const extension = extname(pathPart).toLowerCase();
+  if (extension !== "" && !MARKDOWN.includes(extension)) return undefined;
+  const fragment = hashAt === -1 ? undefined : decoded(written.slice(hashAt + 1));
+  return { file: normalize(join(dirname(from), pathPart)), folder: pathPart.endsWith("/") || pathPart === "", fragment };
+};
+
+/** The paths a target may name: itself with an extension, a page of that name, or the page a folder opens. */
+const candidatesOf = (target: LinkTarget): string[] => {
+  if (extname(target.file) !== "") return [target.file];
+  return [...MARKDOWN.map((extension) => `${target.file}${extension}`), ...FOLDER_PAGES.map((page) => join(target.file, page))];
+};
+
+/** The run's files by normalized path, and the folders they sit in. */
+type Run = { readonly byPath: ReadonlyMap<string, ProseDocument>; readonly folders: ReadonlySet<string> };
+
+const runOf = (docs: readonly ProseDocument[]): Run => ({
+  byPath: new Map(docs.map((doc) => [normalize(doc.path), doc])),
+  folders: new Set(docs.map((doc) => normalize(dirname(doc.path)))),
+});
+
+/** Whether a missing target is one the run would hold: in a folder the run's files are in, and not a folder the run has files under. */
+const runCovers = (target: LinkTarget, run: Run): boolean => {
+  if (target.folder || !run.folders.has(normalize(dirname(target.file)))) return false;
+  const under = `${target.file}${sep}`;
+  return ![...run.byPath.keys()].some((path) => path.startsWith(under));
+};
+
+const findingOf = (doc: ProseDocument, link: MarkupLink, variant: "file" | "anchor"): DocumentFinding => ({
+  path: doc.path,
+  finding: findingAt(doc, link, { link: quoteOf(doc.source, link), target: link.destination.trim() }, variant),
+});
+
+const brokenIn = (doc: ProseDocument, link: MarkupLink, run: Run): DocumentFinding | undefined => {
+  const target = linkTarget(doc.path, link.destination);
+  if (target === undefined) return undefined;
+  const found = candidatesOf(target)
+    .map((path) => run.byPath.get(path))
+    .find((candidate) => candidate !== undefined);
+  if (found === undefined) return runCovers(target, run) ? findingOf(doc, link, "file") : undefined;
+  const markup = markupOf(found);
+  if (target.fragment === undefined || target.fragment === "" || markup === undefined) return undefined;
+  return reachesAnchor(`#${target.fragment}`, anchorsOf(markup)) ? undefined : findingOf(doc, link, "anchor");
+};
+
+/** Relative links between the run's Markdown files that lead to a file the run does not have, or to a heading its file does not have. */
+export const crossDocBrokenLink: CrossDetector = (docs) => {
+  const run = runOf(docs);
+  return docs.flatMap((doc) => (markupOf(doc)?.links ?? []).flatMap((link) => brokenIn(doc, link, run) ?? []));
+};

package/src/detectors/cross-registry/cross-doc-broken-link.ts

@@ -0,0 +1,4 @@
+import type { CrossDetector } from "../../plugin.ts";
+import { crossDocBrokenLink } from "../cross-link.ts";
+
+export const detector: CrossDetector = crossDocBrokenLink;

package/src/detectors/cross-registry/cross-doc-term-variant.ts

@@ -0,0 +1,4 @@
+import type { CrossDetector } from "../../plugin.ts";
+import { crossDocTermVariant } from "../cross-variant.ts";
+
+export const detector: CrossDetector = crossDocTermVariant;

package/src/detectors/cross-variant.ts

@@ -0,0 +1,77 @@
+import type { CrossDetector, DocumentFinding, ProseDocument } from "../plugin.ts";
+import { oddSpellings, type DocumentWords, type KeyedWord, type OddSpelling } from "../cross-variants.ts";
+import { stemMorae, stemOf } from "../long-vowel.ts";
+import { DEFAULT_MIN_MORAE, distinctWordsOf, exemptStems, kanaWordsOf } from "./long-vowel.ts";
+import { spelledWordsIn, spellingsOf } from "./spelling-variety.ts";
+import { isWithinAny, quotedIn } from "../quoted-span.ts";
+
+// The words read for cross-doc-term-variant, each with the key both its spellings share. Three ways of spelling one word
+// that chaff already reads in one document: the final ー of a katakana word (katakana-long-vowel), British and American
+// spellings (spelling-consistency's word lists), and a Latin word written with and without a hyphen (e-mail, email).
+
+/**
+ * Katakana nouns as the language package split them, keyed by the word without its final ー. Short words keep their ー.
+ * A word in 「」 is named, not used (「サーバ」ではなく「サーバー」と書く), and does not count.
+ */
+const kanaWords = (doc: ProseDocument): KeyedWord[] => {
+  const exempt = exemptStems(distinctWordsOf(doc));
+  return doc.sentences.flatMap((sentence) => {
+    const quoted = quotedIn(sentence);
+    return kanaWordsOf(sentence, doc.names ?? [], exempt)
+      .filter((word) => stemMorae(word.surface) >= DEFAULT_MIN_MORAE)
+      .filter((word) => !isWithinAny(quoted, { start: word.offset, end: word.offset + word.surface.length }))
+      .map((word) => ({ key: `kana:${stemOf(word.surface)}`, form: word.surface, offset: word.offset }));
+  });
+};
+
+/** Words of the language's spelling lists (colour / color), keyed by the pair. */
+const listedWords = (doc: ProseDocument): KeyedWord[] => {
+  const spellings = spellingsOf(doc.lexicons);
+  return doc.sentences.flatMap((sentence) =>
+    spelledWordsIn(sentence, spellings).map((word) => {
+      const pair = [word.written.toLowerCase(), word.spelling.other.toLowerCase()].toSorted((left, right) => left.localeCompare(right, "en")).join("/");
+      return { key: `listed:${pair}`, form: word.written.toLowerCase(), offset: word.offset };
+    }),
+  );
+};
+
+const LATIN_WORD = /(?<![\p{L}\p{N}_-])\p{Script=Latin}+(?:-\p{Script=Latin}+)*(?![\p{L}\p{N}_-])/gu;
+const HYPHEN = "-";
+
+/** A Latin word's key: lower case, hyphens out. e-mail and Email share it with email. */
+const latinKey = (word: string): string => `latin:${word.toLowerCase().replaceAll(HYPHEN, "")}`;
+
+const latinWordsOf = (doc: ProseDocument): KeyedWord[] =>
+  doc.sentences.flatMap((sentence) =>
+    [...sentence.text.matchAll(LATIN_WORD)].map((match) => ({
+      key: latinKey(match[0]),
+      form: match[0].toLowerCase(),
+      offset: sentence.span.start + match.index,
+    })),
+  );
+
+/** The Latin words of every document whose key some document of the run writes with a hyphen. Other words are not variants. */
+const hyphenWords = (docs: readonly ProseDocument[]): readonly KeyedWord[][] => {
+  const words = docs.map(latinWordsOf);
+  const hyphenated = new Set(words.flat().flatMap((word) => (word.form.includes(HYPHEN) ? [word.key] : [])));
+  return words.map((ofDoc) => ofDoc.filter((word) => hyphenated.has(word.key)));
+};
+
+const quoteAt = (doc: ProseDocument, offset: number): string =>
+  doc.sentences.find((sentence) => sentence.span.start <= offset && offset < sentence.span.end)?.text.trim() ?? "";
+
+const findingOf = (byPath: ReadonlyMap<string, ProseDocument>, odd: OddSpelling): DocumentFinding[] => {
+  const doc = byPath.get(odd.path);
+  if (doc === undefined) return [];
+  const matched = doc.source.slice(odd.word.offset, odd.word.offset + odd.word.form.length);
+  const values = { matched, preferred: odd.usual, count: odd.files, other: odd.example, offset: odd.word.offset };
+  return [{ path: odd.path, finding: { rule: "", severity: "warning", line: 0, column: 0, quote: quoteAt(doc, odd.word.offset), values } }];
+};
+
+/** A word spelled one way in some files of the run and another way in the rest: reported in the files of the fewer way. */
+export const crossDocTermVariant: CrossDetector = (docs) => {
+  const latin = hyphenWords(docs);
+  const words: DocumentWords[] = docs.map((doc, index) => ({ path: doc.path, words: [...kanaWords(doc), ...listedWords(doc), ...(latin[index] ?? [])] }));
+  const byPath = new Map(docs.map((doc) => [doc.path, doc]));
+  return oddSpellings(words).flatMap((odd) => findingOf(byPath, odd));
+};

package/src/detectors/date-format.ts

@@ -0,0 +1,29 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { dateGroups, dateMinority, datesIn, type DateMinority } from "../date-format.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/**
+ * 一つの文書で、日付を二通り以上の書き方で書いた所（2026-10-02 と 2026年10月2日、Oct 2, 2026 と 10/2/2026）。少ないほうを指す。
+ * 行の頭の日付（予定表の行）と文の中の日付は別に比べる。月の名前は語彙表 month-name、元号は calendar-era が言う。コードの中の日付は読まない。
+ */
+const findingsOf = (doc: ProseDocument, minority: DateMinority): Finding[] =>
+  minority.odd.map((date) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, date.offset),
+    values: { written: date.written, example: minority.majority.written, count: minority.count, total: minority.total, offset: date.offset },
+  }));
+
+export const dateFormat: Detector = (doc, options): Finding[] => {
+  const words = {
+    months: (doc.lexicons["month-name"] ?? []).map((entry) => entry.pattern),
+    eras: (doc.lexicons["calendar-era"] ?? []).map((entry) => entry.pattern),
+  };
+  const text = doc.prose ?? doc.source;
+  return dateGroups(text, datesIn(text, words)).flatMap((group) => {
+    const minority = dateMinority(group, options.limit);
+    return minority === undefined ? [] : findingsOf(doc, minority);
+  });
+};

package/src/detectors/date-year.ts

@@ -0,0 +1,91 @@
+// A date written without its year where the document's other dates carry one, or where the year cannot be read off
+// because the document's dates cross the turn of a year. Pure; reads the date nodes of the structure tree.
+import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** A date as the tree reads it: "2026-10-14" with its year, "10-14" without. */
+export type DatePoint = { readonly offset: number; readonly end: number; readonly value: string };
+
+export type YearGap = { readonly point: DatePoint; readonly kind: "minority" | "boundary"; readonly dated: number };
+
+/** The words just before a date that give its year in words (その年の, 同年, 毎年): the date has a year, or means every year. */
+export const YEAR_REFERENCE_LEXICON = "year-reference";
+
+const FULL = /^\d{4}-(\d{2})-\d{2}$/u;
+const MONTH_DAY = /^(\d{2})-\d{2}$/u;
+
+/** How far before a date a year word may stand (「同年12月」「その年の12月」). */
+const YEAR_WORD_REACH = 6;
+
+/** The months at the end and the start of a year: a date in one, written beside a dated one in the other, could be either year. */
+const YEAR_END = new Set([11, 12]);
+const YEAR_START = new Set([1, 2]);
+
+const monthOf = (pattern: RegExp, value: string): number | undefined => {
+  const month = pattern.exec(value)?.[1];
+  return month === undefined ? undefined : Number(month);
+};
+
+const sideOf = (month: number | undefined): "end" | "start" | undefined => {
+  if (month === undefined) return undefined;
+  if (YEAR_END.has(month)) return "end";
+  return YEAR_START.has(month) ? "start" : undefined;
+};
+
+/** A yearless date at one turn of the year while a dated one sits at the other: 1月15日 beside 2026年12月1日. */
+const crossesYear = (point: DatePoint, datedSides: ReadonlySet<string>): boolean => {
+  const side = sideOf(monthOf(MONTH_DAY, point.value));
+  return side !== undefined && datedSides.has(side === "end" ? "start" : "end");
+};
+
+const lineStart = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
+
+const hasYearWord = (point: DatePoint, source: string, yearWords: readonly string[]): boolean => {
+  const before = source.slice(Math.max(lineStart(source, point.offset), point.offset - YEAR_WORD_REACH), point.offset);
+  return yearWords.some((word) => word !== "" && before.includes(word));
+};
+
+/**
+ * A yearless date whose year the text gives anyway: a year word just before it (「同年12月28日」「その年の12月31日」), or,
+ * earlier on the same line, a date with a year or with a year word (「2026年9月25日から10月7日まで」「その年の1月1日から12月31日まで」).
+ */
+const yearGiven = (point: DatePoint, anchors: readonly DatePoint[], source: string, yearWords: readonly string[]): boolean => {
+  const start = lineStart(source, point.offset);
+  return hasYearWord(point, source, yearWords) || anchors.some((other) => other.offset >= start && other.offset < point.offset);
+};
+
+/**
+ * The yearless dates to report. Where most dates carry a year (at least two, and more than the yearless ones), every yearless
+ * one is the odd one out. Otherwise writing the year once is the document's style, and only a date across the turn of a
+ * year is reported. A date whose year the text gives in words or earlier on its line is never reported, nor counted.
+ */
+export const yearGaps = (points: readonly DatePoint[], source = "", yearWords: readonly string[] = []): YearGap[] => {
+  const dated = points.filter((point) => FULL.test(point.value));
+  const anchors = [...dated, ...points.filter((point) => hasYearWord(point, source, yearWords))];
+  const yearless = points.filter((point) => MONTH_DAY.test(point.value) && !yearGiven(point, anchors, source, yearWords));
+  const minority = dated.length >= 2 && yearless.length < dated.length;
+  const datedSides = new Set(dated.flatMap((point) => sideOf(monthOf(FULL, point.value)) ?? []));
+  return yearless.flatMap((point): YearGap[] => {
+    if (minority) return [{ point, kind: "minority", dated: dated.length }];
+    return crossesYear(point, datedSides) ? [{ point, kind: "boundary", dated: dated.length }] : [];
+  });
+};
+
+export const datePoints = (tree: StructureNode): DatePoint[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+
+const yearWordsOf = (doc: ProseDocument): string[] => (doc.lexicons[YEAR_REFERENCE_LEXICON] ?? []).map((entry) => entry.pattern);
+
+export const dateWithoutYear: Detector = (doc: ProseDocument): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : yearGaps(datePoints(doc.structure), doc.source, yearWordsOf(doc)).map((gap) => ({
+        rule: "date-without-year",
+        severity: "warning",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, gap.point.offset),
+        ...(gap.kind === "boundary" ? { variant: "boundary" } : {}),
+        values: { date: doc.source.slice(gap.point.offset, gap.point.end), count: gap.dated, offset: gap.point.offset },
+      }));