chaffjs 0.23.0 → 0.25.0

package/src/detectors/definition-use.ts

@@ -1,11 +1,17 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText } from "../structure/definition-use.ts";
+import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText, type Mentioned } from "../structure/definition-use.ts";
 import { expansionConflicts, expansionsIn } from "../acronym-expansions.ts";
 import { linesOf, lineNumberAt } from "../structure/lines.ts";
+import { isQuotedAlone } from "../quoted-span.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 const bodyOf = (doc: ProseDocument): BodyText[] => doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
 
+const mentionedIn =
+  (doc: ProseDocument): Mentioned =>
+  (start, end) =>
+    isQuotedAlone(doc.source, { start, end });
+
 const findingAt = (doc: ProseDocument, offset: number, values: Readonly<Record<string, string | number>>): Finding => ({
   rule: "",
   severity: "warning",
@@ -19,13 +25,17 @@ const findingAt = (doc: ProseDocument, offset: number, values: Readonly<Record<s
 export const unusedDefinition: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : unusedDefinitions(definedTerms(doc.structure), bodyOf(doc)).map((defined) => findingAt(doc, defined.span.start, { term: defined.term }));
+    : unusedDefinitions(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc)).map((defined) =>
+        findingAt(doc, defined.span.start, { term: defined.term }),
+      );
 
 /** 文の途中で括弧に入れて定義した語を、定義より前で使っている所。 */
 export const useBeforeDefinition: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc)).map((use) => findingAt(doc, use.offset, { term: use.term.term, defined: use.term.line }));
+    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc)).map((use) =>
+        findingAt(doc, use.offset, { term: use.term.term, defined: use.term.line }),
+      );
 
 /** 同じ略語を、文書の中で二通りに展開している所。 */
 export const acronymExpansionConflict: Detector = (doc): Finding[] => {

package/src/detectors/generic-heading.ts

@@ -0,0 +1,30 @@
+import type { Detector, Finding, Lexicon, MarkupHeading, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { findingAt, writtenHeadings } from "./markup-finding.ts";
+
+/**
+ * 札と番号だけの見出し（メリット1、ポイント2、Benefit 3）。目次を見ても、節に何が書いてあるかが分からない。
+ * 札は語彙表 generic-heading-label が言う。題を足した見出し（メリット1：設定が要らない）は読まない。
+ */
+
+/** 番号の書き方。数字、丸数字、漢数字。前に「その」や「#」、後ろに区切りの記号が付いてもよい。 */
+const NUMBER = String.raw`(?:その)?\s*#?\s*[(（]?\s*(?:[0-9０-９]+|[①-⑳]|[一二三四五六七八九十]+)\s*(?:つ目)?\s*[:：.．。)）]?`;
+
+/** 札のどれかと番号だけで書いた見出しの形。札が無ければ undefined。 */
+export const bareLabelPattern = (labels: Lexicon): RegExp | undefined => {
+  const words = labels.map((entry) => escapeRegExp(entry.pattern)).filter((word) => word !== "");
+  return words.length === 0 ? undefined : new RegExp(`^(?:${words.join("|")})\\s*${NUMBER}$`, "iu");
+};
+
+/** 札と番号だけの見出し。 */
+export const bareLabelHeadings = (doc: ProseDocument): MarkupHeading[] => {
+  const pattern = bareLabelPattern(doc.lexicons["generic-heading-label"] ?? []);
+  return pattern === undefined ? [] : writtenHeadings(doc).filter((heading) => pattern.test(heading.text.trim()));
+};
+
+/** 数で見る。一つなら書き手の選び方、並べば型をなぞった見出し。 */
+export const genericHeading: Detector = (doc, options): Finding[] => {
+  const bare = bareLabelHeadings(doc);
+  if (bare.length === 0 || bare.length < options.limit) return [];
+  return bare.map((heading) => findingAt(doc, heading, { heading: heading.text.trim(), count: bare.length, limit: options.limit }));
+};

package/src/detectors/ime-residue.ts

@@ -0,0 +1,37 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// A single Latin letter left inside a Japanese word by the input method (おもしrおい, 対応sた): a key pressed and not converted.
+
+/** One stray letter, and where it is in the text. */
+export type StrayLetter = { readonly offset: number; readonly letter: string };
+
+// Hiragana or kanji before (after katakana a letter is a label: サイズm, プランb), kana after.
+const STRAY = /(?<=[\p{Script=Hiragana}\p{Script=Han}々])[a-z](?=[\p{Script=Hiragana}\p{Script=Katakana}ー])/gu;
+/** Marks that make the run around the letter a path, an address or an assignment (/docs/あaい, a=b). */
+const PATH_MARK = /[/\\=@#]/u;
+
+const runBefore = (text: string, offset: number): string => text.slice(0, offset).split(/\s/u).at(-1) ?? "";
+
+/**
+ * One lower-case letter between Japanese: hiragana or kanji before, kana after. A letter followed by a particle names
+ * something (変数xが, まずxを, をxで), so it is left alone; the particles come from the lexicon.
+ */
+export const strayLettersIn = (text: string, particles: readonly string[]): StrayLetter[] =>
+  [...text.matchAll(STRAY)].flatMap((match) => {
+    const namesSomething = particles.some((particle) => text.startsWith(particle, match.index + 1));
+    return namesSomething || PATH_MARK.test(runBefore(text, match.index)) ? [] : [{ offset: match.index, letter: match[0] }];
+  });
+
+export const imeResidue: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const particles = (doc.lexicons["case-particle"] ?? []).map((entry) => entry.pattern);
+  return strayLettersIn(text, particles).map((stray) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, stray.offset, stray.offset + 1),
+    values: { letter: stray.letter, offset: stray.offset },
+  }));
+};

package/src/detectors/lexicon.ts

@@ -212,15 +212,24 @@ export const repeatedConjunction: Detector = (doc, options): Finding[] => {
     });
 };
 
+/**
+ * 書き手が書いた語。引用符の中だけの語（words such as "delves" and "pivotal"）は、例に挙げたか人の言葉を引いたもの。
+ * 品詞があれば当たった語の並びごとに見る（活用した形も原形で当たる）。無ければ字で照らす。
+ */
+const writtenIn = (sentence: Sentence, entry: LexiconEntry): boolean =>
+  sentence.tokens === undefined || entry.tokens === undefined || entry.tokens.length === 0
+    ? entryIn(sentence, entry) && !onlyQuoted(sentence, entry)
+    : entryRanges(sentence, entry).some((range) => !quotedRange(sentence, range));
+
 /**
  * AI 生成の signal。1 つでは何も言えないので、重みを足し合わせて文書の点にする。
  * 単独で断じない。§20.2 の複合シグナルの入口で、これだけで「AI が書いた」とは言わない。
  */
 export const aiTell: Detector = (doc, options): Finding[] => {
   const entries = [...new Map((options.lexicon ?? []).map((entry) => [entry.pattern.toLowerCase(), entry])).values()];
-  const found = entries.filter((entry) => doc.sentences.some((sentence) => entryIn(sentence, entry)));
+  const found = entries.filter((entry) => doc.sentences.some((sentence) => writtenIn(sentence, entry)));
   const score = Math.round(found.reduce((sum, entry) => sum + (entry.weight ?? 1), 0) * 10);
-  const first = doc.sentences.find((sentence) => found.some((entry) => entryIn(sentence, entry)));
+  const first = doc.sentences.find((sentence) => found.some((entry) => writtenIn(sentence, entry)));
   if (first === undefined || score <= options.limit) return [];
   return [
     {

package/src/detectors/lookalike-character.ts

@@ -0,0 +1,75 @@
+import type { Detector, Finding, Span } from "../plugin.ts";
+import { codePointName } from "./invisible-character.ts";
+
+/**
+ * A character that looks like a common one but is another code point, so search, sorting and a dictionary miss it.
+ * radical: a Kangxi or supplementary radical (⼈ U+2F08 for 人), from PDF text or an input method's radical list.
+ * compatibility: a CJK compatibility ideograph (or one of its supplement) that Unicode maps to a unified one (樂 U+F914 for 樂).
+ * decomposed: a letter and a separate combining mark (か + U+3099 for が, e + U+0301 for é), from file names or text
+ * copied on macOS. spacing-mark: kana followed by the spacing ゛ or ゜, typed in place of the combined letter.
+ */
+export type LookalikeKind = "radical" | "compatibility" | "decomposed" | "spacing-mark";
+
+export type Lookalike = { readonly span: Span; readonly kind: LookalikeKind; readonly written: string; readonly usual: string };
+
+const RADICAL = /[\u2E80-\u2EFF\u2F00-\u2FDF]/u;
+const COMPATIBILITY = /[\uF900-\uFAFF\u{2F800}-\u{2FA1F}]/u;
+/** A letter or mark base and the combining marks after it. */
+const WITH_MARKS = /\P{M}\p{M}+/gu;
+/** Kana followed by the spacing voiced or semi-voiced mark (か゛, は゜). */
+const SPACING_MARK = /[\p{Script=Hiragana}\p{Script=Katakana}][゛゜]/gu;
+const COMBINING_OF: Readonly<Record<string, string>> = { "゛": "゙", "゜": "゚" };
+const SINGLE_CHAR = /[\u2E80-\u2EFF\u2F00-\u2FDF\uF900-\uFAFF\u{2F800}-\u{2FA1F}]/gu;
+
+/** A radical or compatibility ideograph, with the unified ideograph it stands for. One that maps to nothing is left alone. */
+const singleLookalikes = (source: string): Lookalike[] =>
+  [...source.matchAll(SINGLE_CHAR)].flatMap((match) => {
+    const written = match[0];
+    const radical = RADICAL.test(written);
+    const usual = written.normalize(radical ? "NFKC" : "NFC");
+    if (usual === written || (!radical && !COMPATIBILITY.test(written))) return [];
+    return [{ span: { start: match.index, end: match.index + written.length }, kind: radical ? "radical" : "compatibility", written, usual }];
+  });
+
+/** A base and combining marks that compose into one precomposed letter. Marks with no precomposed form are writing, not a slip. */
+const decomposedLookalikes = (source: string): Lookalike[] =>
+  [...source.matchAll(WITH_MARKS)].flatMap((match) => {
+    const usual = match[0].normalize("NFC");
+    if (Array.from(usual).length >= Array.from(match[0]).length) return [];
+    return [{ span: { start: match.index, end: match.index + match[0].length }, kind: "decomposed", written: match[0], usual }];
+  });
+
+/** Kana and a spacing ゛ or ゜ whose combining form makes one letter (か゛ → が). */
+const spacingMarkLookalikes = (source: string): Lookalike[] =>
+  [...source.matchAll(SPACING_MARK)].flatMap((match) => {
+    const [kana = "", mark = ""] = Array.from(match[0]);
+    const usual = `${kana}${COMBINING_OF[mark] ?? ""}`.normalize("NFC");
+    if (Array.from(usual).length !== 1) return [];
+    return [{ span: { start: match.index, end: match.index + match[0].length }, kind: "spacing-mark", written: match[0], usual }];
+  });
+
+export const lookalikesIn = (source: string): Lookalike[] =>
+  [...singleLookalikes(source), ...decomposedLookalikes(source), ...spacingMarkLookalikes(source)].toSorted(
+    (left, right) => left.span.start - right.span.start,
+  );
+
+const QUOTE_REACH = 20;
+
+const quoteOf = (source: string, span: Span): string =>
+  source
+    .slice(Math.max(0, span.start - QUOTE_REACH), span.end + QUOTE_REACH)
+    .replace(/\s+/gu, " ")
+    .trim();
+
+const codesOf = (text: string): string => Array.from(text).map(codePointName).join(" ");
+
+export const lookalikeCharacter: Detector = (doc): Finding[] =>
+  lookalikesIn(doc.source).map((lookalike) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteOf(doc.source, lookalike.span),
+    values: { written: lookalike.written, usual: lookalike.usual, code: codesOf(lookalike.written), offset: lookalike.span.start },
+    variant: lookalike.kind,
+  }));

package/src/detectors/lowercase-name.ts

@@ -0,0 +1,58 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// A word English always capitalises (a weekday, a month) written in lower case ("on monday"). The words come from the rule's
+// lexicon "calendar-name"; the pattern is the capitalised form.
+
+export type LowercaseName = { readonly offset: number; readonly written: string; readonly usual: string };
+
+/** Characters that make the word part of a name in code, a path, an address or a tag (monday.md, /july/, @friday, #june). */
+const NOT_PROSE_BESIDE = /[\p{L}\p{N}_/.@#:=-]/u;
+
+/** A period or colon ends the sentence or clause unless a name continues after it (monday.md, june:2). */
+const SENTENCE_STOP = /[.:]/u;
+const WORD_CHAR = /[\p{L}\p{N}_]/u;
+
+const joinsAfter = (text: string, end: number): boolean =>
+  SENTENCE_STOP.test(text.charAt(end)) ? WORD_CHAR.test(text.charAt(end + 1)) : NOT_PROSE_BESIDE.test(text.charAt(end));
+
+/** A value after a key or a field marker (day: monday, day = monday, "day": "monday", * * monday) is data, not prose. */
+const VALUE_MARK = /[:=*]/u;
+const STRAIGHT_QUOTE = /["']/u;
+const SPACE_OR_QUOTE = /[\s"']/u;
+/** How far back to look past spaces and quotes for the key's mark. */
+const VALUE_REACH = 8;
+
+const markBefore = (text: string, start: number): string =>
+  Array.from(text.slice(Math.max(0, start - VALUE_REACH), start))
+    .reverse()
+    .find((char) => !SPACE_OR_QUOTE.test(char)) ?? "";
+
+const isValue = (text: string, start: number): boolean => STRAIGHT_QUOTE.test(text.charAt(start - 1)) || VALUE_MARK.test(markBefore(text, start));
+
+const capitalOf = (word: string): string => `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
+
+export const lowercaseNamesIn = (text: string, names: readonly string[]): LowercaseName[] => {
+  const lower = new Map(names.map((name) => [name.toLowerCase(), capitalOf(name)]));
+  return [...text.matchAll(/\p{Ll}+/gu)].flatMap((match) => {
+    const usual = lower.get(match[0]);
+    const end = match.index + match[0].length;
+    if (usual === undefined || NOT_PROSE_BESIDE.test(text.charAt(match.index - 1)) || isValue(text, match.index) || joinsAfter(text, end)) return [];
+    return [{ offset: match.index, written: match[0], usual }];
+  });
+};
+
+export const lowercaseName: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return lowercaseNamesIn(
+    text,
+    (doc.lexicons["calendar-name"] ?? []).map((entry) => entry.pattern),
+  ).map((name) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, name.offset, name.offset + name.written.length),
+    values: { written: name.written, usual: name.usual, offset: name.offset },
+  }));
+};

package/src/detectors/missing-final-period.ts

@@ -0,0 +1,79 @@
+import type { Detector, Finding, LexiconEntry, Paragraph, ProseDocument, Token } from "../plugin.ts";
+import { formMinority } from "./form-minority.ts";
+
+// A paragraph whose last sentence stops without its closing mark, in a document whose other paragraphs end with one. It
+// takes no side: a document that ends none of its paragraphs with the mark (slides, labels) is not reported. The marks
+// come from the language's lexicon "final-period": group "end" is the period, group "other-end" closes a sentence another
+// way (？, ！) so the paragraph is not counted, and group "note" opens a note line. The
+// lexicon is read directly rather than as the rule's word list, since its marks are what a fixed paragraph ends with.
+
+/** A paragraph's end, and whether it closes with a sentence-ending mark. form is "closed" or "open". */
+export type ParagraphEnd = { readonly offset: number; readonly form: string; readonly text: string };
+
+/** The marks the detector reads, from the lexicon. */
+export type PeriodMarks = { readonly ends: readonly string[]; readonly otherEnds: readonly string[]; readonly notes: readonly string[] };
+
+/** Brackets and quotes that may follow a closing mark (〜です。」). */
+const CLOSERS = '」』）)"”’';
+/** A line that is itself a quotation closes like a sentence. */
+const QUOTE_CLOSERS = "」』";
+/** A paragraph ending in a colon leads into a list or a block; it is not a sentence left open. */
+const LEAD_IN = /[：:]$/u;
+/** Two spaces in a row, half- or full-width, lay a line out like a table (an ingredient, then its amount), so it is not a sentence. */
+const LAYOUT = /[ \u3000]{2}/u;
+/** Fewer characters than this is a label or a caption, not a sentence. */
+const MIN_SENTENCE_CHARS = 15;
+/** Words that end a clause: a verb, an adjective or an auxiliary in its dictionary form ends the sentence. */
+const PREDICATE: ReadonlySet<string> = new Set(["VERB", "ADJ", "AUX"]);
+
+/** The line's last mark before any closing brackets and quotes is one of these. */
+const endsWithMark = (line: string, marks: readonly string[]): boolean => {
+  const chars = Array.from(line);
+  return marks.includes(chars[chars.findLastIndex((char) => !CLOSERS.includes(char))] ?? "");
+};
+
+const isClosed = (line: string, ends: readonly string[]): boolean => endsWithMark(line, ends) || QUOTE_CLOSERS.includes(line.at(-1) ?? "\0");
+
+/** A note, a laid-out row, or a question or exclamation: not a sentence that could take the period. */
+const isAside = (line: string, marks: PeriodMarks): boolean =>
+  marks.notes.some((note) => line.startsWith(note)) || LAYOUT.test(line) || endsWithMark(line, marks.otherEnds);
+
+/** The paragraph's last word ends a sentence: a predicate written in its dictionary form (〜します, 〜である, 望ましい). */
+const endsInPredicate = (paragraph: Paragraph): boolean => {
+  const last = (paragraph.sentences.at(-1)?.tokens ?? []).filter((token: Token) => token.surface.trim() !== "").at(-1);
+  return last !== undefined && PREDICATE.has(last.pos) && last.lemma === last.surface;
+};
+
+/** How a paragraph ends, or undefined when its last line is not a sentence (a label, a lead-in, a note, a laid-out row). */
+export const paragraphEnd = (text: string, paragraph: Paragraph, marks: PeriodMarks): ParagraphEnd | undefined => {
+  const body = text.slice(paragraph.span.start, paragraph.span.end).trimEnd();
+  const last = body.split("\n").at(-1)?.trim() ?? "";
+  if (Array.from(last).length < MIN_SENTENCE_CHARS || LEAD_IN.test(last)) return undefined;
+  const offset = paragraph.span.start + body.length - 1;
+  if (isAside(last, marks)) return undefined;
+  if (isClosed(last, marks.ends)) return { offset, form: "closed", text: last };
+  // A closing parenthetical after the sentence (〜します（別紙を参照する）) is not where the period goes.
+  return !CLOSERS.includes(last.at(-1) ?? "\0") && endsInPredicate(paragraph) ? { offset, form: "open", text: last } : undefined;
+};
+
+const marksOf = (lexicon: readonly LexiconEntry[]): PeriodMarks => ({
+  ends: lexicon.filter((entry) => entry.group === "end").map((entry) => entry.pattern),
+  otherEnds: lexicon.filter((entry) => entry.group === "other-end").map((entry) => entry.pattern),
+  notes: lexicon.filter((entry) => entry.group === "note").map((entry) => entry.pattern),
+});
+
+export const missingFinalPeriod: Detector = (doc: ProseDocument, options): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  const marks = marksOf(doc.lexicons["final-period"] ?? []);
+  const ends = doc.paragraphs.flatMap((paragraph) => paragraphEnd(text, paragraph, marks) ?? []);
+  const minority = formMinority(ends, options.limit);
+  if (minority === undefined || minority.usual.form !== "closed") return [];
+  return minority.odd.map((end) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: end.text,
+    values: { count: minority.odd.length, of: ends.length, offset: end.offset },
+  }));
+};

package/src/detectors/missing-space-after-comma.ts

@@ -0,0 +1,54 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// A comma between two words with no space after it ("address,and"): a slip in English prose. A run of values joined by
+// commas ("blue,black,brown"), and anything inside an address, a path or an assignment, is data, not prose.
+
+/** One comma with no space after it, where it is, and the two words it joins as written. */
+export type TightComma = { readonly offset: number; readonly written: string };
+
+/** A word of three letters or more (a possessive 's may follow), a comma, and a lower-case word of three letters or more. */
+const JOINED = /(?<![\p{L}\p{N}])[A-Za-z]{3,}(?:['’]s)?,[a-z]{3,}(?![\p{L}\p{N}])/u;
+/** Characters that make a run of text an address, a path, a parameter or data (a=b, a/b, a.b, @a, #a, a_b, 3,abc). */
+const DATA_MARK = /[/\\=@#:.&?_|+*~$%^<>{}[\]\p{N}]/u;
+/** Opening and closing marks a word of prose may carry ("(and,then)"), and the sentence's own end ("and,then."). */
+const OPENERS = "(\"'“‘[";
+const CLOSERS = ")\"'”’].,;!?";
+/** A run quoted whole, inside brackets or not ("true,false", ("true,false")): a value written out, not two words of the sentence. */
+const QUOTED_WHOLE = /^[([]*["'“‘].*["'”’][)\].,;!?]*$/u;
+/** A run of text between whitespace. */
+const RUN = /\S+/gu;
+const COMMA = ",";
+
+/** The run without the marks around it, trimmed by scanning rather than by a pattern that could backtrack. */
+const bareOf = (run: string): string => {
+  const chars = run.split("");
+  const start = chars.findIndex((char) => !OPENERS.includes(char));
+  const end = chars.findLastIndex((char) => !CLOSERS.includes(char));
+  return start === -1 || end < start ? "" : run.slice(start, end + 1);
+};
+
+/** A run holding one comma and nothing that marks it as data. */
+const isProseRun = (run: string): boolean => {
+  const bare = bareOf(run);
+  return bare.split(COMMA).length === 2 && !DATA_MARK.test(bare) && !QUOTED_WHOLE.test(run);
+};
+
+/** Each run is read once, so a long line of values costs one pass. */
+export const tightCommasIn = (text: string): TightComma[] =>
+  [...text.matchAll(RUN)].flatMap((run) => {
+    const joined = isProseRun(run[0]) ? JOINED.exec(run[0]) : null;
+    return joined === null ? [] : [{ offset: run.index + joined.index + joined[0].indexOf(COMMA), written: joined[0] }];
+  });
+
+export const missingSpaceAfterComma: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return tightCommasIn(text).map((comma) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, comma.offset, comma.offset + 1),
+    values: { written: comma.written, offset: comma.offset },
+  }));
+};

package/src/detectors/registry/bare-comparative.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { bareComparative } from "../bare-comparative.ts";
+
+export const detector: Detector = bareComparative;

package/src/detectors/registry/calendar-name-case.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { lowercaseName } from "../lowercase-name.ts";
+
+export const detector: Detector = lowercaseName;

package/src/detectors/registry/connective-hierarchy.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { connectiveHierarchy } from "../connective-hierarchy.ts";
+
+export const detector: Detector = connectiveHierarchy;

package/src/detectors/registry/generic-heading.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { genericHeading } from "../generic-heading.ts";
+
+export const detector: Detector = genericHeading;

package/src/detectors/registry/ime-residue.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { imeResidue } from "../ime-residue.ts";
+
+export const detector: Detector = imeResidue;

package/src/detectors/registry/lookalike-character.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { lookalikeCharacter } from "../lookalike-character.ts";
+
+export const detector: Detector = lookalikeCharacter;

package/src/detectors/registry/missing-final-period.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { missingFinalPeriod } from "../missing-final-period.ts";
+
+export const detector: Detector = missingFinalPeriod;

package/src/detectors/registry/missing-space-after-comma.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { missingSpaceAfterComma } from "../missing-space-after-comma.ts";
+
+export const detector: Detector = missingSpaceAfterComma;

package/src/detectors/registry/unit-spacing-consistency.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { unitSpacing } from "../unit-spacing.ts";
+
+export const detector: Detector = unitSpacing;

package/src/detectors/signals.ts

@@ -11,6 +11,7 @@ import { evidenceSpans, hasNumeral, startsWithin } from "./concrete-evidence.ts"
 import { letteredIndexEntries } from "./lettered-index.ts";
 import { hasPredicateIn } from "./gram-predicate.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
+import { referenceListSpans } from "../reference-lists.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence } from "../plugin.ts";
 
 const PER = 1000;
@@ -250,9 +251,12 @@ const firstHits = (hits: readonly AcronymHit[]): Map<string, Hit> => {
   return seen;
 };
 
-/** 日付の中の月（SEP 01, 2022）は略語ではない。 */
-const outsideDates = (hits: readonly AcronymHit[], dates: readonly Span[]): AcronymHit[] =>
-  hits.filter(({ hit }) => !dates.some((span) => span.start <= hit.offset && hit.offset < span.end));
+/**
+ * 範囲の外の略語。日付の中の月（SEP 01, 2022）は略語ではない。文献一覧の誌名や会議名（Appeared in: LREC 2008.）は
+ * 引いた文献の書き方で、本文が説明する略語ではない。
+ */
+const outsideSpans = (hits: readonly AcronymHit[], spans: readonly Span[]): AcronymHit[] =>
+  hits.filter(({ hit }) => !spans.some((span) => span.start <= hit.offset && hit.offset < span.end));
 
 /**
  * どこか 1 か所で展開してあればよい。初出が節の見出し代わりの語（「5.3. DPA.」）で、
@@ -300,11 +304,11 @@ export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const headings = doc.sections.map((section) => section.heading);
   const explainedAlone = (word: string): boolean =>
     common.has(word) || entries.has(word) || isExpanded(body, word, expandedAt) || headings.some((heading) => expandsInHeading(heading, word, expandedAt));
-  const hits = acronymsOf(doc, notationOf(doc));
+  const hits = outsideSpans(acronymsOf(doc, notationOf(doc)), referenceListSpans(doc.source, patternsOf(doc, "reference-list-heading")));
   const unexplained = new Set([...firstHits(hits).keys()].filter((acronym) => !isExplained(acronym, explainedAlone)));
   // 日付を読むには文書の木を作る。上限に届かない文書では作らない。
   if (unexplained.size < options.limit) return [];
-  const bare = [...firstHits(outsideDates(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
+  const bare = [...firstHits(outsideSpans(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
   if (bare.length < options.limit) return [];
   return bare.map(([acronym, hit]) => ({
     rule: "undefined-acronym",

package/src/detectors/structure-tree.ts

@@ -6,6 +6,7 @@ import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
+import { isQuotedAlone } from "../quoted-span.ts";
 
 const QUOTE_LENGTH = 80;
 
@@ -42,22 +43,43 @@ const dayName = (doc: ProseDocument, day: unknown): string => {
   return doc.lexicons["weekday"]?.[index]?.pattern ?? String(index);
 };
 
-export const dateWeekdayMismatch: Detector = (doc): Finding[] =>
-  doc.structure === undefined
-    ? []
-    : weekdayMismatches(doc.structure).map((issue) => ({
-        rule: "date-weekday-mismatch",
-        severity: "error",
-        line: 0,
-        column: 0,
-        quote: quoteAt(doc.source, issue.offset),
-        values: {
-          date: String(issue.values["date"]),
-          written: dayName(doc, issue.values["written"]),
-          actual: dayName(doc, issue.values["actual"]),
-          offset: issue.offset,
-        },
-      }));
+const datedSpans = (tree: NonNullable<ProseDocument["structure"]>): DatedSpan[] =>
+  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+
+/** 引用符の中で日付の横にあってよい語は、曜日の一語だけ（"Monday, December 5, 2026"、「2026年12月5日（月）」）。 */
+const WEEKDAY_WORDS = 1;
+
+/**
+ * 引用符で日付だけを挙げたもの（"Monday, December 5, 2026" falls on a Saturday）は、誤りの例で、文書の日付ではない。
+ * from から until の日付の終わりまでを見る。
+ */
+const quotedDates = (doc: ProseDocument, from: DatedSpan | undefined, until: DatedSpan | undefined, wordsBesides = 0): boolean =>
+  from !== undefined && until !== undefined && isQuotedAlone(doc.source, { start: from.offset, end: until.end }, wordsBesides);
+
+const dateAt = (dates: readonly DatedSpan[], offset: number): number => dates.findIndex((date) => date.offset === offset);
+
+export const dateWeekdayMismatch: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const dates = datedSpans(doc.structure);
+  return weekdayMismatches(doc.structure)
+    .filter((issue) => {
+      const date = dates[dateAt(dates, issue.offset)];
+      return !quotedDates(doc, date, date, WEEKDAY_WORDS);
+    })
+    .map((issue) => ({
+      rule: "date-weekday-mismatch",
+      severity: "error",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: {
+        date: String(issue.values["date"]),
+        written: dayName(doc, issue.values["written"]),
+        actual: dayName(doc, issue.values["actual"]),
+        offset: issue.offset,
+      },
+    }));
+};
 
 /** 木の日付を、原文の位置と一緒に並べる。 */
 const datedPoints = (tree: NonNullable<ProseDocument["structure"]>): { offset: number; value: string }[] =>
@@ -99,9 +121,6 @@ export const totalMismatch: Detector = (doc): Finding[] =>
         values: { ...issue.values, offset: issue.offset },
       }));
 
-const datedSpans = (tree: NonNullable<ProseDocument["structure"]>): DatedSpan[] =>
-  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
-
 const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   connectors: (doc.lexicons["range-connector"] ?? []).map((entry) => entry.pattern),
   openers: (doc.lexicons["range-opener"] ?? []).map((entry) => entry.pattern),
@@ -111,17 +130,23 @@ const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
 });
 
 /** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */
-export const dateRangeReversed: Detector = (doc): Finding[] =>
-  doc.structure === undefined
-    ? []
-    : reversedRanges(doc.source, datedSpans(doc.structure), rangeWordsOf(doc)).map((issue) => ({
-        rule: "date-range-reversed",
-        severity: "warning",
-        line: 0,
-        column: 0,
-        quote: quoteAt(doc.source, issue.offset),
-        values: { ...issue.values, offset: issue.offset },
-      }));
+export const dateRangeReversed: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const dates = datedSpans(doc.structure);
+  return reversedRanges(doc.source, dates, rangeWordsOf(doc))
+    .filter((issue) => {
+      const start = dateAt(dates, issue.offset);
+      return !quotedDates(doc, dates[start], dates[start + 1]);
+    })
+    .map((issue) => ({
+      rule: "date-range-reversed",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+    }));
+};
 
 const shareWordsOf = (doc: ProseDocument): ShareWords => ({
   labels: (doc.lexicons["share-label"] ?? []).map((entry) => entry.pattern),