chaffjs 0.35.0 → 0.37.0

package/src/detectors/list-parallel.ts

@@ -3,6 +3,7 @@
 // one list is reported. です/ます against plain endings inside a list is no-mixed-desumasu's, not this.
 import { minorityWithin } from "../orthography.ts";
 import { isQuotedAt } from "./bold-label.ts";
+import { endsAsHeadline, markOrSkipped, withoutFootnoteReference, withoutTrailingMarks } from "./list-item-ending.ts";
 import type { BulletList, Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
 /** What an item is made of: a phrase or a sentence (ending), and the word it opens with (head, English only). */
@@ -12,6 +13,7 @@ export type Axis = "ending" | "head";
 export const FORMS: Readonly<Record<Axis, readonly [string, string]>> = { ending: ["phrase", "sentence"], head: ["verb", "noun"] };
 
 const SKIPPED_AT_END = new Set(["PUNCT", "SYM", "X"]);
+const isMark = markOrSkipped(SKIPPED_AT_END);
 const NOMINAL = new Set(["NOUN", "PROPN", "NUM", "PRON"]);
 const PREDICATE = new Set(["VERB", "AUX", "ADJ"]);
 const NOUN_HEAD = new Set(["NOUN", "ADJ", "DET", "NUM", "PRON", "PROPN"]);
@@ -33,12 +35,16 @@ const withoutClosingAside = (tokens: readonly Token[]): readonly Token[] => {
   return open <= 0 ? tokens : tokens.slice(0, open);
 };
 
-/** Japanese: a predicate at the end (出します, 済ませる, 早い) is a sentence; a noun (月末, 確認すること) is a phrase. */
-const japaneseEnding = (sentences: readonly Sentence[]): string | undefined => {
+/**
+ * Japanese: a predicate at the end (出します, 済ませる, 早い) is a sentence; a noun (月末, 確認すること) or a headline's
+ * あり / なし after a noun (翻訳あり) is a phrase. Marks after the last word (!!, a footnote reference) are not words.
+ */
+const japaneseEnding = (sentences: readonly Sentence[], headlineEndings: ReadonlySet<string>): string | undefined => {
   if (sentences.length > 1) return "sentence";
-  const last = withoutClosingAside(sentences[0]?.tokens ?? []).findLast((token) => !SKIPPED_AT_END.has(token.pos));
+  const words = withoutTrailingMarks(withoutClosingAside(withoutFootnoteReference(sentences[0]?.tokens ?? [], isMark)), isMark);
+  const last = words.at(-1);
   if (last === undefined) return undefined;
-  if (NOMINAL.has(last.pos)) return "phrase";
+  if (NOMINAL.has(last.pos) || endsAsHeadline(words, headlineEndings)) return "phrase";
   return PREDICATE.has(last.pos) ? "sentence" : undefined;
 };
 
@@ -72,47 +78,124 @@ const AFTER_ADJECTIVE = new Set(["ADP", "PART"]);
 const isNounOrAdjective = (token: Token): boolean =>
   token.pos === "NOUN" || token.pos === "ADJ" || (token.pos === "PROPN" && token.features?.["OrdinaryWord"] === "Yes");
 
+/** A verb in the base form an instruction takes (describe), not a past or third-person form (described, describes). */
+const isBaseVerb = (token: Token | undefined): boolean =>
+  token?.pos === "VERB" && token.features?.["VerbForm"] === undefined && token.lemma === token.surface.toLowerCase();
+
+/**
+ * An -ed word the tagger left without VerbForm (decreased, agreed, unauthorized): like a participle, it may modify the noun
+ * after it. Proceed and need end in -ed too but are their own base forms.
+ */
+const isPastForm = (token: Token): boolean =>
+  token.pos === "VERB" &&
+  token.features?.["VerbForm"] === undefined &&
+  /ed$/iu.test(token.surface) &&
+  (token.lemma !== token.surface.toLowerCase() || !/eed$/iu.test(token.surface));
+
+/** An -s word read as a verb that the tagger could not take back to a base form (Revisions): a plural noun, misread. Discuss and Focus are verbs. */
+const isMisreadPlural = (token: Token): boolean =>
+  token.pos === "VERB" && token.features?.["VerbForm"] === undefined && /[^su]s$/iu.test(token.surface) && token.lemma === token.surface.toLowerCase();
+
+/** Participles (Generated files) and gerunds (Recovering from illness) open noun phrases and duties alike, so neither form. */
+const NEITHER_FORM_VERB = new Set(["Part", "Ger"]);
+
+/** The head as the first word's tag gives it. */
+const headFromTag = (first: Token): string | undefined => {
+  if (isUnsure(first) || isPastForm(first) || isMisreadPlural(first)) return undefined;
+  if (first.pos === "VERB") return NEITHER_FORM_VERB.has(first.features?.["VerbForm"] ?? "") ? undefined : "verb";
+  return NOUN_HEAD.has(first.pos) ? "noun" : undefined;
+};
+
+/** What the axes read besides the item's own words: the adapter's word lists, and the nouns of the item's list. */
+export type HeadContext = {
+  /** Verbs the tagger does not know as verbs (click), from the adapter's instruction-verb word list. */
+  readonly instructionVerbs: ReadonlySet<string>;
+  /** Words that open an instruction or an adjective phrase (Secure the server, Secure configuration), from verb-or-adjective. */
+  readonly verbOrAdjective: ReadonlySet<string>;
+  /** The lemmas the tagger read as nouns anywhere in the item's list. */
+  readonly nounsInList: ReadonlySet<string>;
+  /** Words that end a Japanese item as a headline does after a noun (翻訳あり), from headline-ending. */
+  readonly headlineEndings: ReadonlySet<string>;
+};
+
+export const NO_HEAD_CONTEXT: HeadContext = { instructionVerbs: new Set(), verbOrAdjective: new Set(), nounsInList: new Set(), headlineEndings: new Set() };
+
+type HeadReading = "verb" | "noun" | "unjudged" | undefined;
+
+/** Reads the head from the item's tokens, its first word at `at`; undefined leaves it to the next reader. */
+type HeadReader = (tokens: readonly Token[], at: number, context: HeadContext) => HeadReading;
+
+/** A subject and its verb in one word (you're, we've): the item opens with its subject, as "you love …" does. */
+const SUBJECT_CONTRACTION = /^(?:i|you|we|they|he|she|it)['’]\p{L}+$/iu;
+
+const subjectContraction: HeadReader = (tokens, at) => (SUBJECT_CONTRACTION.test(tokens[at]?.surface ?? "") ? "noun" : undefined);
+
+/** Secure, Open: a verb before "the", "a" or "your" (Secure the server), else maybe an adjective (Secure configuration). */
+const verbOrAdjective: HeadReader = (tokens, at, context) => {
+  if (!context.verbOrAdjective.has(tokens[at]?.surface.toLowerCase() ?? "")) return undefined;
+  return opensObject(tokens[at + 1]) ? "verb" : "unjudged";
+};
+
+/** A verb the tagger does not know. Before a common noun the word may head a compound (Click fraud, Scroll bar), so its tag decides. */
+const instructionVerb: HeadReader = (tokens, at, context) =>
+  context.instructionVerbs.has(tokens[at]?.surface.toLowerCase() ?? "") && tokens[at + 1]?.pos !== "NOUN" ? "verb" : undefined;
+
+const isSeriesJoint = (token: Token): boolean => token.surface === "," || token.pos === "CCONJ";
+
+/** The single words of a series the item opens with: "Scope, estimate and describe tasks" gives Scope, estimate, describe. */
+const openingSeries = (tokens: readonly Token[], at: number): readonly Token[] => {
+  const word = tokens[at];
+  if (word === undefined) return [];
+  const after = tokens.findIndex((token, index) => index > at && !isSeriesJoint(token));
+  return after === -1 || after === at + 1 ? [word] : [word, ...openingSeries(tokens, after)];
+};
+
+/** A series one of whose later words is a verb in its base form (Instrument, monitor and profile): it is a series of verbs. */
+const seriesOfVerbs: HeadReader = (tokens, at) => (openingSeries(tokens, at).slice(1).some(isBaseVerb) ? "verb" : undefined);
+
 /**
- * The head of an item whose first two words overrule the first word's tag, or undefined when they do not. "Open the console"
- * and "Press the button" open with a verb. "Clean up after closing" and "Bake in the oven" may open with a verb or an
- * adjective phrase (Close to the station), and "Washing machine space" with a compound noun or a gerund and its object
- * (Washing dishes): neither is judged.
+ * The first two words overrule the first word's tag. "Open the console" and "Press the button" open with a verb. "Clean up
+ * after closing" and "Bake in the oven" may open with a verb or an adjective phrase (Close to the station), and "Washing
+ * machine space" with a compound noun or a gerund and its object (Washing dishes): neither is judged.
  */
-const headFromNextWord = (first: Token, next: Token | undefined): "verb" | "unjudged" | undefined => {
+const nextWord: HeadReader = (tokens, at) => {
+  const first = tokens[at];
+  // The word right after, punctuation included: in "Next, the candidate" the comma ends the opener.
+  const next = tokens[at + 1];
+  if (first === undefined) return undefined;
   if (isNounOrAdjective(first) && opensObject(next)) return "verb";
   if (first.pos === "ADJ" && AFTER_ADJECTIVE.has(next?.pos ?? "")) return "unjudged";
   return first.features?.["VerbForm"] === "Ger" && next?.pos === "NOUN" ? "unjudged" : undefined;
 };
 
-/** The head as the first word's tag gives it. */
-const headFromTag = (first: Token): string | undefined => {
-  if (isUnsure(first)) return undefined;
-  // A participle (Generated files, Nested lists) modifies the noun after it; the item is a noun phrase, but the tag does not say so.
-  if (first.pos === "VERB") return first.features?.["VerbForm"] === "Part" ? undefined : "verb";
-  return NOUN_HEAD.has(first.pos) ? "noun" : undefined;
+/** A verb that the same list uses as a noun (holiday pay … pay during your notice), with no object after it: either reading. */
+const nounElsewhereInList: HeadReader = (tokens, at, context) => {
+  const first = tokens[at];
+  return first?.pos === "VERB" && context.nounsInList.has(first.lemma ?? "") && !opensObject(tokens[at + 1]) ? "unjudged" : undefined;
 };
 
-const englishHead = (sentences: readonly Sentence[], instructionVerbs: ReadonlySet<string>): string | undefined => {
+const HEAD_READERS: readonly HeadReader[] = [subjectContraction, verbOrAdjective, instructionVerb, seriesOfVerbs, nextWord, nounElsewhereInList];
+
+const englishHead = (sentences: readonly Sentence[], context: HeadContext): string | undefined => {
   const tokens = sentences[0]?.tokens ?? [];
   const at = tokens.findIndex((token) => !SKIPPED_AT_END.has(token.pos));
   const first = tokens[at];
   if (at === -1 || first === undefined || isTitleCase(sentences[0]?.text ?? "")) return undefined;
-  // The word right after, punctuation included: in "Next, the candidate" the comma ends the opener.
-  const next = tokens[at + 1];
-  // Before a common noun the word may head a compound (Click fraud, Scroll bar), so its tag decides.
-  if (instructionVerbs.has(first.surface.toLowerCase()) && next?.pos !== "NOUN") return "verb";
-  const overruled = headFromNextWord(first, next);
-  if (overruled === undefined) return headFromTag(first);
-  return overruled === "verb" ? "verb" : undefined;
+  const reading = HEAD_READERS.reduce<HeadReading>((found, reader) => found ?? reader(tokens, at, context), undefined);
+  if (reading === undefined) return headFromTag(first);
+  return reading === "unjudged" ? undefined : reading;
 };
 
-/**
- * An item's form on an axis, or undefined when its words do not tell. Japanese items have no head axis (the verb comes last).
- * instructionVerbs: verbs the tagger does not know as verbs (click), from the adapter's instruction-verb word list.
- */
-export const formOf = (axis: Axis, sentences: readonly Sentence[], language: string, instructionVerbs: ReadonlySet<string> = new Set()): string | undefined => {
-  if (language === "ja") return axis === "ending" ? japaneseEnding(sentences) : undefined;
-  return axis === "ending" ? englishEnding(sentences) : englishHead(sentences, instructionVerbs);
+/** An item's form on an axis, or undefined when its words do not tell. Japanese items have no head axis (the verb comes last). */
+/** An item that ends in a colon (Other kinds of decisions:) leads into what follows it: its ending is not its own, its opening still is. */
+const LEAD_IN = /[:：]$/u;
+
+const leadsIn = (sentences: readonly Sentence[]): boolean => LEAD_IN.test(sentences.at(-1)?.text.trim() ?? "");
+
+export const formOf = (axis: Axis, sentences: readonly Sentence[], language: string, context: HeadContext = NO_HEAD_CONTEXT): string | undefined => {
+  if (axis === "ending" && leadsIn(sentences)) return undefined;
+  if (language === "ja") return axis === "ending" ? japaneseEnding(sentences, context.headlineEndings) : undefined;
+  return axis === "ending" ? englishEnding(sentences) : englishHead(sentences, context);
 };
 
 const within = (inner: Span, outer: Span): boolean => inner.start >= outer.start && inner.end <= outer.end;
@@ -123,6 +206,33 @@ export const itemSentences = (doc: ProseDocument, item: Span): Sentence[] => {
   return doc.sentences.filter((sentence) => within(sentence.span, item) && !nested.some((span) => within(sentence.span, span)));
 };
 
+/**
+ * Where an item's own words end: before a line in it that opens, unindented, with a note lead (※応募書類は返却できません。,
+ * "Note: …"). Markdown reads such a line as the last item's, but the note is about the whole list.
+ */
+export const itemOwnEnd = (source: string, item: Span, noteLeads: readonly string[]): number => {
+  const lineStarts = [...source.slice(item.start, item.end).matchAll(/\n/gu)].map((match) => item.start + match.index + 1);
+  const noteLine = lineStarts.find((start) => noteLeads.some((lead) => lead !== "" && source.startsWith(lead, start)));
+  return noteLine === undefined ? item.end : noteLine - 1;
+};
+
+/** The sentence up to `end`: a note line under the item is not part of the item's last sentence. */
+const cutAt = (sentence: Sentence, end: number, source: string): Sentence =>
+  sentence.span.end <= end
+    ? sentence
+    : {
+        ...sentence,
+        span: { start: sentence.span.start, end },
+        text: source.slice(sentence.span.start, end),
+        ...(sentence.tokens === undefined ? {} : { tokens: sentence.tokens.filter((token) => token.span.end <= end) }),
+      };
+
+/** The item's own sentences, up to a note line under it. */
+const ownSentences = (doc: ProseDocument, item: Span, noteLeads: readonly string[]): Sentence[] => {
+  const end = itemOwnEnd(doc.source, item, noteLeads);
+  return itemSentences(doc, item).flatMap((sentence) => (sentence.span.start < end ? [cutAt(sentence, end, doc.source)] : []));
+};
+
 type Item = { readonly sentences: readonly Sentence[]; readonly form: string };
 
 const findingOf = (axis: Axis, item: Item, count: number, of: number, limit: number): Finding => {
@@ -162,17 +272,32 @@ const isJudged = (written: string, sentences: readonly Sentence[]): boolean => {
 
 const runsOn = (sentences: readonly Sentence[]): boolean => RUNNING_ON.test(sentences.at(-1)?.text.trim() ?? "");
 
+const wordsOf = (doc: ProseDocument, lexicon: string): ReadonlySet<string> =>
+  new Set((doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern.toLowerCase()));
+
+const headContext = (doc: ProseDocument, items: readonly (readonly Sentence[])[]): HeadContext => ({
+  instructionVerbs: wordsOf(doc, "instruction-verb"),
+  verbOrAdjective: wordsOf(doc, "verb-or-adjective"),
+  headlineEndings: wordsOf(doc, "headline-ending"),
+  nounsInList: new Set(
+    items.flatMap((sentences) =>
+      sentences.flatMap((sentence) => (sentence.tokens ?? []).flatMap((token) => (token.pos === "NOUN" && token.lemma !== undefined ? [token.lemma] : []))),
+    ),
+  ),
+});
+
 const listFindings = (doc: ProseDocument, list: BulletList, limit: number): Finding[] => {
-  const sentencesOf = list.itemSpans.map((span) => itemSentences(doc, span));
+  const noteLeads = (doc.lexicons["list-note-lead"] ?? []).map((entry) => entry.pattern);
+  const sentencesOf = list.itemSpans.map((span) => ownSentences(doc, span, noteLeads));
   if (sentencesOf.some(runsOn)) return [];
   const judged = sentencesOf.filter((sentences, index) => {
     const span = list.itemSpans[index];
     return span !== undefined && isJudged(doc.source.slice(span.start, sentences.at(-1)?.span.end ?? span.end), sentences);
   });
-  const instructionVerbs = new Set((doc.lexicons["instruction-verb"] ?? []).map((entry) => entry.pattern.toLowerCase()));
+  const context = headContext(doc, judged);
   return AXES.flatMap((axis) => {
     const items = judged.flatMap((sentences) => {
-      const form = formOf(axis, sentences, doc.language, instructionVerbs);
+      const form = formOf(axis, sentences, doc.language, context);
       return form === undefined ? [] : [{ sentences, form }];
     });
     const odd = minorityWithin(items, (item) => item.form === FORMS[axis][0], limit);

package/src/detectors/list-sentence.ts

@@ -12,6 +12,10 @@ export type ListWords = {
   readonly example: Lexicon;
   readonly pair: ReadonlySet<string>;
   readonly region: Lexicon;
+  /** 題名を導く語（whose full title is、entitled）。すぐ後ろの Title Case の語の続きは題名で、その中の読点は題名を付けた人のもの。 */
+  readonly titleCue?: readonly string[];
+  /** 文頭で順番を言う一語（First, Next, Finally）。解析器が形容詞と読んでも、並びの項目ではなく導入の語。 */
+  readonly sequence?: ReadonlySet<string>;
 };
 
 const LIST_CONJUNCTION: ReadonlySet<string> = new Set(["and", "or"]);
@@ -193,6 +197,6 @@ export const listSentenceOf = (tokens: readonly Token[], words: ListWords, sourc
     exampleStarts: byDepth(depths, (index) => (exampleEnds[index]?.length ?? 0) > 0),
     pairOpeners: pairOpenersOf(tokens, depths, words.pair),
     commas: byDepth(depths, (index) => tokens[index]?.surface === "," && !regionCommas.has(index)),
-    inCitedTitle: citedTitles(tokens, source),
+    inCitedTitle: citedTitles(tokens, source, words.titleCue),
   };
 };

package/src/detectors/mark-shape.ts

@@ -1,8 +1,12 @@
 import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
 import { escapeRegExp } from "../orthography.ts";
+import { isConventionalPhrase } from "./caps-phrase.ts";
 import { minorityReport } from "../spacing-minority.ts";
+import { externalLinkTitleSpans } from "../link-title.ts";
+import { formulaBracketSpans } from "../formula-brackets.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
-import { captionsOf, isCaptionAt } from "./caps-caption.ts";
+import { capitalLineSpans, captionsOf, isCaptionAt, isWithinSorted } from "./caps-caption.ts";
+import { lineStarts } from "../position.ts";
 
 /** The letters a mark must touch to count as part of the document's text, by language. */
 const SCRIPT: Readonly<Record<string, RegExp>> = {
@@ -43,15 +47,17 @@ const besideLetter = (text: string, at: number, step: number, script: RegExp): b
 const touchesScript = (text: string, at: number, script: RegExp): boolean => besideLetter(text, at, -1, script) || besideLetter(text, at, 1, script);
 
 /**
- * The marks in a sentence that touch a letter of the document's script, outside 「」『』 quotations. spaced is the lexicon's pattern side.
+ * The marks in a sentence that touch a letter of the document's script, outside 「」『』 quotations and outside the brackets
+ * of a formula (× (1 - 時間 ÷ 月平均)), which follow the formula's notation. spaced is the lexicon's pattern side.
  * The letters beside a mark are read in the source, so a mark that opens a sentence (。(2）当社) counts wherever the sentence starts.
  */
 export const marksIn = (source: string, sentence: Sentence, forms: ReadonlyMap<string, Form>, script: RegExp): Mark[] => {
   const quoted = quotedSpans(sentence.text);
+  const formulas = formulaBracketSpans(sentence.text);
   return sentence.text.split("").flatMap((char, at) => {
     const form = forms.get(char);
     if (form === undefined || !touchesScript(source, sentence.span.start + at, script)) return [];
-    if (isWithinAny(quoted, { start: at, end: at })) return [];
+    if (isWithinAny(quoted, { start: at, end: at }) || isWithinAny(formulas, { start: at, end: at + 1 })) return [];
     return [{ sentence, char, form, offset: sentence.span.start + at, spaced: form.side }];
   });
 };
@@ -83,20 +89,84 @@ const minorityFindings = <T extends Sided>(items: readonly T[], limit: number, v
 /** Sentences written in the document's own language; a quoted sentence in another language follows its own marks. */
 const ownSentences = (doc: ProseDocument): readonly Sentence[] => doc.sentences.filter((sentence) => sentence.embeddedLanguage === undefined);
 
+/**
+ * A bracketed item number opening a line ((1)開催趣旨, （ア）, (iv), a list bullet before it), both brackets of one width.
+ * It numbers the line, a style of its own: the brackets of the prose around it may be written the other width. A
+ * bracketed word at a line's head ((背景), (注)) is not a number, and an item number the prose refers to (次の(1)及び(2))
+ * is written in the prose; both stay with the prose's brackets.
+ */
+const LINE_HEAD = /^\s*(?:[-*+] +)?/u;
+const BRACKETED = /^([(（[［])([^)）\]］]{1,4})([)）\]］])/u;
+const NUMBERING = /^(?:[0-9０-９]{1,3}|[一二三四五六七八九十]{1,3}|[A-Za-zＡ-Ｚａ-ｚァ-ヶぁ-んｦ-ﾝ])$/u;
+/** Roman numerals i to x, either case. */
+const ROMAN = /^(?:i{2,3}|iv|vi{1,3}|ix|I{2,3}|IV|VI{1,3}|IX)$/u;
+const CLOSER_OF: Readonly<Record<string, string>> = { "(": ")", "（": "）", "[": "]", "［": "］" };
+
+const isItemNumber = (text: string): boolean => NUMBERING.test(text) || ROMAN.test(text);
+
+/** The offsets in a line of its item number's opening and closing bracket, or none. */
+const enumeratorIn = (line: string): readonly number[] => {
+  const head = LINE_HEAD.exec(line)?.[0].length ?? 0;
+  const found = BRACKETED.exec(line.slice(head));
+  if (found === null || CLOSER_OF[found[1] ?? ""] !== found[3] || !isItemNumber(found[2] ?? "")) return [];
+  return [head, head + found[0].length - 1];
+};
+
+/** The offsets in `source` of each line's item number's opening and closing bracket. */
+export const enumeratorBracketOffsets = (source: string): ReadonlySet<number> => {
+  const starts = lineStarts(source);
+  return new Set(source.split("\n").flatMap((line, index) => enumeratorIn(line).map((at) => (starts[index] ?? 0) + at)));
+};
+
+/** Appended to a mark's kind for an item number's bracket. A lexicon's group, a word from YAML, never holds a NUL. */
+const ENUMERATOR_KIND = "\u0000enumerator";
+
+/** A line's item number's bracket is a kind of its own, compared only with the other item numbers' brackets. */
+const withEnumeratorKind = (mark: Mark, enumerators: ReadonlySet<number>): Mark =>
+  enumerators.has(mark.offset) ? { ...mark, form: { ...mark.form, kind: `${mark.form.kind}${ENUMERATOR_KIND}` } } : mark;
+
+/**
+ * A doubled parenthesis around text with no parenthesis inside, such as ((居住の用に供したとき等)) or （（注））: one mark written
+ * with two characters, as a directive sets an article's caption. Its width is that notation's, not the prose's.
+ */
+const DOUBLED_PAREN = /\(\([^()（）\n]*\)\)|（（[^()（）\n]*））/gu;
+const PAIR_LENGTH = 2;
+
+/** The offsets in `source` of every character of a doubled parenthesis. */
+export const doubledParenOffsets = (source: string): ReadonlySet<number> =>
+  new Set(
+    [...source.matchAll(DOUBLED_PAREN)].flatMap((match) => {
+      const end = match.index + match[0].length;
+      return [match.index, match.index + 1, end - PAIR_LENGTH, end - 1];
+    }),
+  );
+
+const DOUBLED_KIND = "\u0000doubled";
+
+/** A doubled parenthesis is a kind of its own, compared only with the other doubled parentheses. */
+const withDoubledKind = (mark: Mark, doubled: ReadonlySet<number>): Mark =>
+  doubled.has(mark.offset) ? { ...mark, form: { ...mark.form, kind: `${mark.form.kind}${DOUBLED_KIND}` } } : mark;
+
 /**
  * A mark written two ways in one document (（ and (, “ and "), the less common way reported. The two ways come from the
  * lexicon; neither is called right. Only marks next to a letter of the document's script count, so a bracket in code-like
- * text (f(x)) or an English aside in a Japanese document does not.
+ * text (f(x)) or an English aside in a Japanese document does not. A line enumerator's brackets ((1)) are compared apart.
  */
 export const markConsistency: Detector = (doc, options): Finding[] => {
   const script = SCRIPT[doc.language];
   if (script === undefined) return [];
+  // A link that quotes an outside page's title keeps that page's marks ((コンテキスト内) in a WCAG title).
+  const titles = externalLinkTitleSpans(doc.source, doc.links);
   const forms = formsOf(options.lexicon ?? []);
-  const marks = ownSentences(doc).flatMap((sentence) => marksIn(doc.source, sentence, forms, script));
+  const enumerators = enumeratorBracketOffsets(doc.source);
+  const doubled = doubledParenOffsets(doc.source);
+  const marks = ownSentences(doc).flatMap((sentence) =>
+    marksIn(doc.source, sentence, forms, script).map((mark) => withDoubledKind(withEnumeratorKind(mark, enumerators), doubled)),
+  );
   const kinds = [...new Set(marks.map((mark) => mark.form.kind))];
   return kinds.flatMap((kind) =>
     minorityFindings(
-      marks.filter((mark) => mark.form.kind === kind),
+      marks.filter((mark) => mark.form.kind === kind && !isWithinAny(titles, { start: mark.offset, end: mark.offset + 1 })),
       options.limit,
       (mark) => ({ mark: mark.char, usual: mark.form.other }),
     ),
@@ -205,21 +275,30 @@ export const lowerCaseWords = (source: string): ReadonlySet<string> =>
 
 /**
  * Whether more than half the words of a capital run are also written elsewhere in lower case. Words the lexicon lists as
- * written in capitals by convention (MUST NOT in a specification) count like acronyms.
+ * written in capitals by convention (MUST NOT in a specification) count like acronyms, and a run made of its phrases
+ * (NOW, THEREFORE, BE IT RESOLVED) is not shouting.
  */
 export const isShouting = (run: string, known: ReadonlySet<string>, conventional: ReadonlySet<string>): boolean => {
+  if (isConventionalPhrase(run, conventional)) return false;
   const words = run.split(/,? /u);
   const ordinary = words.filter((word) => !conventional.has(word) && known.has(word.toLowerCase()));
   const long = words.filter((word) => word.length > 1);
   return long.length >= MIN_LONG_WORDS && ordinary.length * 2 > words.length;
 };
 
-/** Runs of three or more all-capital words that are ordinary words, not acronyms ("DO NOT DELETE THIS"), and not a caption or a mention of one. */
+/**
+ * Runs of three or more all-capital words that are ordinary words, not acronyms ("DO NOT DELETE THIS"), and not a
+ * caption, a mention of one, a paragraph of capital lines that ends no sentence (a letterhead, a heading), or a roster name.
+ */
 export const capsShouting: Detector = (doc, options): Finding[] => {
   const known = lowerCaseWords(doc.prose ?? doc.source);
   const conventional = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
   const captions = captionsOf(doc.source);
-  const isCaption = (hit: Hit): boolean => captions.has(hit.matched) || isCaptionAt(doc.source, hit.offset, hit.offset + hit.matched.length);
-  const hits = hitsOf(ownSentences(doc), CAPS_RUN).filter((hit) => isShouting(hit.matched, known, conventional) && !isCaption(hit));
+  const capitalLines = capitalLineSpans(doc.source);
+  const isCaptionOrLetterhead = (hit: Hit): boolean =>
+    captions.has(hit.matched) ||
+    isCaptionAt(doc.source, hit.offset, hit.offset + hit.matched.length) ||
+    isWithinSorted(capitalLines, { start: hit.offset, end: hit.offset + hit.matched.length });
+  const hits = hitsOf(ownSentences(doc), CAPS_RUN).filter((hit) => isShouting(hit.matched, known, conventional) && !isCaptionOrLetterhead(hit));
   return reportFrom(hits, options.limit);
 };

package/src/detectors/mentioned-phrase.ts

@@ -0,0 +1,38 @@
+// A phrase that is mentioned rather than used: named as a term (when saying "raise the bar", the phrase "low-hanging
+// fruit", 「徹底解説」という言い方). The writer is talking about the words, not leaning on them. The cue words come from the
+// language's mention-cue word list: group before stands right before the phrase, group after right after it. Pure.
+import type { LexiconEntry, Sentence, Token } from "../plugin.ts";
+import { entryEndsAt, entryRanges, type TokenRange } from "./lexicon-match.ts";
+
+const BEFORE = "before";
+const AFTER = "after";
+
+/** Quote marks and brackets that may stand between the cue and the phrase ("raise the bar", 「徹底解説」). */
+const QUOTE_MARKS = new Set(["'", '"', "‘", "’", "“", "”", "「", "」", "『", "』", "(", ")", "（", "）"]);
+
+export type MentionCues = { readonly before: readonly LexiconEntry[]; readonly after: readonly LexiconEntry[] };
+
+export const mentionCuesOf = (entries: readonly LexiconEntry[]): MentionCues => ({
+  before: entries.filter((entry) => entry.group === BEFORE),
+  after: entries.filter((entry) => entry.group === AFTER),
+});
+
+const isQuoteMark = (token: Token | undefined): boolean => token !== undefined && QUOTE_MARKS.has(token.surface);
+
+/** The index past the quote marks from `at` in direction `step`. */
+const pastQuotes = (tokens: readonly Token[], at: number, step: 1 | -1): number => (isQuoteMark(tokens[at]) ? pastQuotes(tokens, at + step, step) : at);
+
+const startsAt = (tokens: readonly Token[], entry: LexiconEntry, start: number): boolean => entryEndsAt(tokens, entry, start + (entry.tokens?.length ?? 0));
+
+const isMention = (tokens: readonly Token[], range: TokenRange, cues: MentionCues): boolean => {
+  const before = pastQuotes(tokens, range.start - 1, -1) + 1;
+  const after = pastQuotes(tokens, range.end, 1);
+  return cues.before.some((cue) => entryEndsAt(tokens, cue, before)) || cues.after.some((cue) => startsAt(tokens, cue, after));
+};
+
+/** Whether every use of the entry in the sentence is a mention. Without tokens no use can be told apart, so none is. */
+export const onlyMentioned = (sentence: Sentence, entry: LexiconEntry, cues: MentionCues): boolean => {
+  const tokens = sentence.tokens;
+  const ranges = entryRanges(sentence, entry);
+  return tokens !== undefined && ranges.length > 0 && ranges.every((range) => isMention(tokens, range, cues));
+};

package/src/detectors/middle-dot.ts

@@ -3,8 +3,13 @@ const MIDDLE_DOT = /・/gu;
 /** 文頭か行頭（前に空白だけ）の「・」。前に並べる項目が無いので、箇条書きの印。 */
 const BULLET_DOT = /(^|\n)[^\S\n]*・/gu;
 
+/** 中黒を含めて 1 語の語（キャッシュ・フロー）を、中黒を除いた形にする。この中黒は語の切れ目で、項目を並べてはいない。 */
+const withoutWordDots = (text: string, words: readonly string[]): string =>
+  words.reduce((joined, word) => joined.replaceAll(word, word.replaceAll("・", "")), text);
+
 /**
- * 項目を並べる中黒の数。箇条書きの印の「・」は数えない。
+ * 項目を並べる中黒の数。箇条書きの印の「・」と、中黒を含めて 1 語の語（words: キャッシュ・フロー）の中黒は数えない。
  * 「・ 水分を補給すること」が何行続いても、どこまでが 1 つの項目かは改行で読める。
  */
-export const parallelDotCount = (text: string): number => [...text.replace(BULLET_DOT, "$1").matchAll(MIDDLE_DOT)].length;
+export const parallelDotCount = (text: string, words: readonly string[] = []): number =>
+  [...withoutWordDots(text, words).replace(BULLET_DOT, "$1").matchAll(MIDDLE_DOT)].length;

package/src/detectors/modal-conflict.ts

@@ -1,8 +1,10 @@
 import type { Detector, Finding, StructureNode } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
+import { listLeadIns } from "../structure/list-lead-in.ts";
 import { modalConflicts, modalStatements, type Obligation } from "../structure/modal-conflict.ts";
 import { linesOf, lineNumberAt } from "../structure/lines.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { negationsMarked, negationWords } from "../structure/negated-act.ts";
 
 export const obligationsOf = (tree: StructureNode): Obligation[] =>
   inDocumentOrder(tree).flatMap((node) =>
@@ -12,10 +14,11 @@ export const obligationsOf = (tree: StructureNode): Obligation[] =>
   );
 
 /** 同じ主語と行為に、前の文と逆の様相（しなければならない と してはならない、may と must not）を書いた文。 */
-export const modalConflict: Detector = (doc): Finding[] => {
+export const modalConflict: Detector = (written): Finding[] => {
+  const doc = { ...written, sentences: negationsMarked(written.sentences, negationWords(written.lexicons["negation-word"])) };
   if (doc.structure === undefined) return [];
   const lines = linesOf(doc.source);
-  return modalConflicts(modalStatements(obligationsOf(doc.structure), doc.sentences)).map(({ statement, earlier }) => ({
+  return modalConflicts(modalStatements(obligationsOf(doc.structure), doc.sentences, listLeadIns(doc.source, doc.sentences))).map(({ statement, earlier }) => ({
     rule: "",
     severity: "warning",
     line: 0,

package/src/detectors/name-variant.ts

@@ -24,6 +24,9 @@ import { isOrdinaryToken, withOrdinaryWords } from "../name-ordinary-word.ts";
 import { isInPersonField } from "../person-field.ts";
 import { labelledSpans, orderNamesOf, quotedSpans, stemOf, titleCaseSpans, wordOrderVariants, type OrderWord } from "../name-word-order.ts";
 import { isGroupPairOf, notDefinedTerms, outsideCapitals, sentenceIndexOf, withGivenNames } from "./name-variant-apart.ts";
+import { usualIsMisspelt } from "../name-misspelt-usual.ts";
+import { spellerOf } from "./unknown-word.ts";
+import { isKnownWord } from "../spelling.ts";
 
 // 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、人を指す前置き（担当の）は person-lead、名前のすぐ後ろに来る語
 // （です、まで）は name-particle、字体の違う同じ字（斎・斉・齋）は name-variant-char が組（group）ごとに言う。
@@ -387,7 +390,10 @@ export const nameVariant: Detector = (doc): Finding[] => {
   const withProducts = [...withPlaces, ...productFindings(doc, prose, withPlaces)];
   const withOrder = [...withProducts, ...orderFindings(doc, prose, withProducts)];
   const codes = modelCodeFindings(doc, prose).filter((code) => !overlapsAny(withOrder, code.offset, code.name.length));
+  const dictionary = doc.dictionary?.();
+  const speller = dictionary === undefined ? undefined : spellerOf(doc, dictionary);
   return [...withOrder, ...codes]
+    .filter(({ name, usual }) => speller === undefined || !usualIsMisspelt(name, usual, (word) => isKnownWord(word, speller)))
     .toSorted((left, right) => left.offset - right.offset)
     .map(({ offset, name, usual, kind }) => ({
       rule: "",

package/src/detectors/notice-paragraph.ts

@@ -0,0 +1,33 @@
+import { entryIn } from "./lexicon-match.ts";
+import type { LexiconEntry, Paragraph, Sentence } from "../plugin.ts";
+
+/** 一文だけの断りは本文の書き損じのことがある。段落ごと別の調子で揃えてあるときだけ、意図した別の声と読む。 */
+const MIN_SENTENCES = 2;
+
+/**
+ * 断り書きの段落（「…無償で提供します。…一切の責任を負いません。…ご了承ください。」）の文。
+ * 免責や変更の予告は、である調の文書でもですます調で書く決まり文句で、本文と文末の調子を比べるものではない。
+ * 断りの語（cues）を含み、調子を持つ文が MIN_SENTENCES 以上あって、それがみな同じ、文書の多いほう（majority）ではない調子の段落だけ。
+ * 調子が混ざった段落と、文書と同じ調子の段落は、本文と同じに数える。
+ */
+export const noticeSentences = <R>(
+  paragraphs: readonly Paragraph[],
+  cues: readonly LexiconEntry[],
+  registerOf: (sentence: Sentence) => R | undefined,
+  majority: R | undefined,
+): Set<Sentence> =>
+  new Set(
+    paragraphs.flatMap((paragraph) => {
+      const registers = new Set(
+        paragraph.sentences.flatMap((sentence) => {
+          const register = registerOf(sentence);
+          return register === undefined ? [] : [register];
+        }),
+      );
+      const counted = paragraph.sentences.filter((sentence) => registerOf(sentence) !== undefined).length;
+      const [only] = registers;
+      const ownVoice = counted >= MIN_SENTENCES && registers.size === 1 && only !== majority;
+      const notice = ownVoice && paragraph.sentences.some((sentence) => cues.some((cue) => entryIn(sentence, cue)));
+      return notice ? paragraph.sentences : [];
+    }),
+  );

package/src/detectors/number-style.ts

@@ -51,12 +51,24 @@ const MAGNITUDES = /^[一百千万億]+$/u;
 
 const isIdiomNumeral = (numeral: string): boolean => MAGNITUDES.test(numeral);
 
-const countMarks = (text: string, base: number, words: NumberWords): NumberMark[] => {
+/**
+ * A number set off by a space from a word that only begins with a counter: 三, a space, 人事委員会 is the item number 三 of a list,
+ * not 三人. The tokenizer reads 人事 as one word there and 人 alone in 3 人が来た.
+ */
+const isBeforeLongerWord = (numeral: string, written: string, offset: number, tokens: readonly Token[]): boolean => {
+  const counter = written.slice(numeral.length).trimStart();
+  if (counter.length === written.length - numeral.length) return false;
+  const word = tokens.find((token) => token.span.start === offset + written.length - counter.length);
+  return word !== undefined && word.surface.length > counter.length;
+};
+
+const countMarks = (text: string, base: number, words: NumberWords, tokens: readonly Token[]): NumberMark[] => {
   const pattern = countPattern(words);
   if (pattern === undefined) return [];
   return [...text.matchAll(pattern)].flatMap((match): NumberMark[] => {
     const [written, digits, kanji] = match;
     if (kanji !== undefined && isIdiomNumeral(kanji)) return [];
+    if (isBeforeLongerWord(digits ?? kanji ?? "", written, base + match.index, tokens)) return [];
     return [{ kind: "count", style: digits === undefined ? "kanji" : "digits", written, offset: base + match.index }];
   });
 };
@@ -176,7 +188,7 @@ const englishCountMarks = (sentence: Sentence, words: NumberWords): NumberMark[]
 export const numberMarksIn = (sentence: Sentence, words: NumberWords, language: string, source: string): NumberMark[] => {
   const base = sentence.span.start;
   const marks = [
-    ...countMarks(sentence.text, base, words),
+    ...countMarks(sentence.text, base, words, sentence.tokens ?? []),
     ...groupingMarks(sentence.text, base, words, source),
     ...percentMarks(sentence.text, base, words),
     ...(language === "ja" ? [] : englishCountMarks(sentence, words)),